From d3857cbc558ac44e547b267ffda71825d5b9d66a Mon Sep 17 00:00:00 2001
From: Cary Xu <klxu@taosdata.com>
Date: Thu, 21 Apr 2022 21:37:33 +0800
Subject: [PATCH 01/23] register rsma info

---
 include/common/tmsg.h                 |   4 +-
 source/dnode/vnode/src/inc/tsdbSma.h  |  33 ++++++
 source/dnode/vnode/src/inc/vnodeInt.h |   2 +
 source/dnode/vnode/src/tsdb/tsdbSma.c | 160 ++++++++++++++++++++++----
 source/dnode/vnode/src/vnd/vnodeSvr.c |  10 +-
 5 files changed, 178 insertions(+), 31 deletions(-)
 create mode 100644 source/dnode/vnode/src/inc/tsdbSma.h

diff --git a/include/common/tmsg.h b/include/common/tmsg.h
index 38308a1293..aa7b466328 100644
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@@ -1483,8 +1483,8 @@ typedef struct {
   int32_t    qmsg1Len;
   int32_t    qmsg2Len;
   func_id_t* pFuncIds;
-  char*      qmsg1;  // not null: pAst1:qmsg1:SRetention1 => trigger aggr task1
-  char*      qmsg2;  // not null: pAst2:qmsg2:SRetention2 => trigger aggr task2
+  char*      qmsg1;  // pAst1:qmsg1:SRetention1 => trigger aggr task1
+  char*      qmsg2;  // pAst2:qmsg2:SRetention2 => trigger aggr task2
   int8_t     nFuncIds;
 } SRSmaParam;
 
diff --git a/source/dnode/vnode/src/inc/tsdbSma.h b/source/dnode/vnode/src/inc/tsdbSma.h
new file mode 100644
index 0000000000..a178b2e4c0
--- /dev/null
+++ b/source/dnode/vnode/src/inc/tsdbSma.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_VNODE_TSDB_SMA_H_
+#define _TD_VNODE_TSDB_SMA_H_
+
+#include "os.h"
+#include "thash.h"
+#include "tmsg.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int32_t tsdbRegisterRSma(STsdb *pTsdb, SMeta *pMeta, SVCreateTbReq *pReq);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_VNODE_TSDB_SMA_H_*/
\ No newline at end of file
diff --git a/source/dnode/vnode/src/inc/vnodeInt.h b/source/dnode/vnode/src/inc/vnodeInt.h
index 0ff1408c91..23a6d97a66 100644
--- a/source/dnode/vnode/src/inc/vnodeInt.h
+++ b/source/dnode/vnode/src/inc/vnodeInt.h
@@ -113,6 +113,8 @@ void smaHandleRes(void* pVnode, int64_t smaId, const SArray* data);
 
 #include "tq.h"
 
+#include "tsdbSma.h"
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/dnode/vnode/src/tsdb/tsdbSma.c b/source/dnode/vnode/src/tsdb/tsdbSma.c
index 273b7447ff..51b492b297 100644
--- a/source/dnode/vnode/src/tsdb/tsdbSma.c
+++ b/source/dnode/vnode/src/tsdb/tsdbSma.c
@@ -33,6 +33,8 @@ static const char *TSDB_SMA_DNAME[] = {
 
 #define SMA_TEST_INDEX_NAME "smaTestIndexName"  // TODO: just for test
 #define SMA_TEST_INDEX_UID  2000000001          // TODO: just for test
+
+typedef struct SRSmaInfo SRSmaInfo;
 typedef enum {
   SMA_STORAGE_LEVEL_TSDB = 0,     // use days of self-defined  e.g. vnode${N}/tsdb/tsma/sma_index_uid/v2f200.tsma
   SMA_STORAGE_LEVEL_DFILESET = 1  // use days of TS data       e.g. vnode${N}/tsdb/tsma/sma_index_uid/v2f1906.tsma
@@ -98,9 +100,38 @@ typedef struct {
 } SSmaStatItem;
 
 struct SSmaStat {
-  SHashObj *smaStatItems;  // key: indexUid, value: SSmaStatItem
+  union {
+    SHashObj *smaStatItems;  // key: indexUid, value: SSmaStatItem for tsma
+    SHashObj *rsmaInfoHash;  // key: stbUid, value: SRSmaInfo;
+  };
+
   T_REF_DECLARE()
 };
+#define SSMA_STAT_ITEMS(s)     ((s)->smaStatItems)
+#define SSMA_STAT_INFO_HASH(s) ((s)->rsmaInfoHash)
+
+#define RSMA_MAX_LEVEL           2
+#define RSMA_TASK_INFO_HASH_SLOT 8
+    struct SRSmaInfo {
+  void *taskInfo[RSMA_MAX_LEVEL];  // qTaskInfo_t
+};
+
+static FORCE_INLINE void tsdbFreeTaskHandle(qTaskInfo_t *taskHandle) {
+  // Note: free/kill may in RC
+  qTaskInfo_t otaskHandle = atomic_load_ptr(taskHandle);
+  if (otaskHandle && atomic_val_compare_exchange_ptr(taskHandle, otaskHandle, NULL)) {
+    qDestroyTask(otaskHandle);
+  }
+}
+
+static FORCE_INLINE void *tsdbFreeRSmaInfo(SRSmaInfo *pInfo) {
+  for (int32_t i = 0; i < RSMA_MAX_LEVEL; ++i) {
+    if (pInfo->taskInfo[i]) {
+      tsdbFreeTaskHandle(pInfo->taskInfo[i]);
+    }
+  }
+  return NULL;
+}
 
 // declaration of static functions
 
@@ -108,11 +139,11 @@ struct SSmaStat {
 static int32_t  tsdbUpdateExpiredWindowImpl(STsdb *pTsdb, SSubmitReq *pMsg, int64_t version);
 static int32_t  tsdbSetExpiredWindow(STsdb *pTsdb, SHashObj *pItemsHash, int64_t indexUid, int64_t winSKey,
                                      int64_t version);
-static int32_t  tsdbInitSmaStat(SSmaStat **pSmaStat);
+static int32_t  tsdbInitSmaStat(SSmaStat **pSmaStat, int8_t smaType);
 static void    *tsdbFreeSmaStatItem(SSmaStatItem *pSmaStatItem);
 static int32_t  tsdbDestroySmaState(SSmaStat *pSmaStat);
-static SSmaEnv *tsdbNewSmaEnv(const STsdb *pTsdb, const char *path, SDiskID did);
-static int32_t  tsdbInitSmaEnv(STsdb *pTsdb, const char *path, SDiskID did, SSmaEnv **pEnv);
+static SSmaEnv *tsdbNewSmaEnv(const STsdb *pTsdb, int8_t smaType, const char *path, SDiskID did);
+static int32_t  tsdbInitSmaEnv(STsdb *pTsdb, int8_t smaType, const char *path, SDiskID did, SSmaEnv **pEnv);
 static int32_t  tsdbResetExpiredWindow(STsdb *pTsdb, SSmaStat *pStat, int64_t indexUid, TSKEY skey);
 static int32_t  tsdbRefSmaStat(STsdb *pTsdb, SSmaStat *pStat);
 static int32_t  tsdbUnRefSmaStat(STsdb *pTsdb, SSmaStat *pStat);
@@ -317,7 +348,7 @@ static void tsdbGetSmaDir(int32_t vgId, ETsdbSmaType smaType, char dirName[]) {
   snprintf(dirName, TSDB_FILENAME_LEN, "vnode%svnode%d%s%s", TD_DIRSEP, vgId, TD_DIRSEP, TSDB_SMA_DNAME[smaType]);
 }
 
-static SSmaEnv *tsdbNewSmaEnv(const STsdb *pTsdb, const char *path, SDiskID did) {
+static SSmaEnv *tsdbNewSmaEnv(const STsdb *pTsdb, int8_t smaType, const char *path, SDiskID did) {
   SSmaEnv *pEnv = NULL;
 
   pEnv = (SSmaEnv *)taosMemoryCalloc(1, sizeof(SSmaEnv));
@@ -342,7 +373,7 @@ static SSmaEnv *tsdbNewSmaEnv(const STsdb *pTsdb, const char *path, SDiskID did)
 
   pEnv->did = did;
 
-  if (tsdbInitSmaStat(&pEnv->pStat) != TSDB_CODE_SUCCESS) {
+  if (tsdbInitSmaStat(&pEnv->pStat, smaType) != TSDB_CODE_SUCCESS) {
     tsdbFreeSmaEnv(pEnv);
     return NULL;
   }
@@ -362,14 +393,14 @@ static SSmaEnv *tsdbNewSmaEnv(const STsdb *pTsdb, const char *path, SDiskID did)
   return pEnv;
 }
 
-static int32_t tsdbInitSmaEnv(STsdb *pTsdb, const char *path, SDiskID did, SSmaEnv **pEnv) {
+static int32_t tsdbInitSmaEnv(STsdb *pTsdb, int8_t smaType, const char *path, SDiskID did, SSmaEnv **pEnv) {
   if (!pEnv) {
     terrno = TSDB_CODE_INVALID_PTR;
     return TSDB_CODE_FAILED;
   }
 
   if (*pEnv == NULL) {
-    if ((*pEnv = tsdbNewSmaEnv(pTsdb, path, did)) == NULL) {
+    if ((*pEnv = tsdbNewSmaEnv(pTsdb, smaType, path, did)) == NULL) {
       return TSDB_CODE_FAILED;
     }
   }
@@ -416,7 +447,7 @@ static int32_t tsdbUnRefSmaStat(STsdb *pTsdb, SSmaStat *pStat) {
   return 0;
 }
 
-static int32_t tsdbInitSmaStat(SSmaStat **pSmaStat) {
+static int32_t tsdbInitSmaStat(SSmaStat **pSmaStat, int8_t smaType) {
   ASSERT(pSmaStat != NULL);
 
   if (*pSmaStat != NULL) {  // no lock
@@ -435,12 +466,24 @@ static int32_t tsdbInitSmaStat(SSmaStat **pSmaStat) {
       return TSDB_CODE_FAILED;
     }
 
-    (*pSmaStat)->smaStatItems =
-        taosHashInit(SMA_STATE_HASH_SLOT, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
+    if (smaType == TSDB_SMA_TYPE_ROLLUP) {
+      SSMA_STAT_INFO_HASH(*pSmaStat) = taosHashInit(
+          RSMA_TASK_INFO_HASH_SLOT, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_ENTRY_LOCK);
 
-    if ((*pSmaStat)->smaStatItems == NULL) {
-      taosMemoryFreeClear(*pSmaStat);
-      return TSDB_CODE_FAILED;
+      if (SSMA_STAT_INFO_HASH(*pSmaStat) == NULL) {
+        taosMemoryFreeClear(*pSmaStat);
+        return TSDB_CODE_FAILED;
+      }
+    } else if (smaType == TSDB_SMA_TYPE_TIME_RANGE) {
+      SSMA_STAT_ITEMS(*pSmaStat) =
+          taosHashInit(SMA_STATE_HASH_SLOT, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
+
+      if (SSMA_STAT_ITEMS(*pSmaStat) == NULL) {
+        taosMemoryFreeClear(*pSmaStat);
+        return TSDB_CODE_FAILED;
+      }
+    } else {
+      ASSERT(0);
     }
   }
   return TSDB_CODE_SUCCESS;
@@ -531,7 +574,7 @@ static int32_t tsdbCheckAndInitSmaEnv(STsdb *pTsdb, int8_t smaType) {
       return TSDB_CODE_FAILED;
     }
 
-    if (tsdbInitSmaEnv(pTsdb, rname, did, &pEnv) != TSDB_CODE_SUCCESS) {
+    if (tsdbInitSmaEnv(pTsdb, smaType, rname, did, &pEnv) != TSDB_CODE_SUCCESS) {
       tsdbUnlockRepo(pTsdb);
       return TSDB_CODE_FAILED;
     }
@@ -1290,12 +1333,6 @@ static int32_t tsdbInsertRSmaDataImpl(STsdb *pTsdb, const char *msg) {
     return terrno;
   }
 
-  if (pEnv == NULL) {
-    terrno = TSDB_CODE_INVALID_PTR;
-    tsdbWarn("vgId:%d insert rSma data failed since pTSmaEnv is NULL", REPO_ID(pTsdb));
-    return terrno;
-  }
-
   if (pDataBlocks == NULL) {
     terrno = TSDB_CODE_INVALID_PTR;
     tsdbWarn("vgId:%d insert rSma data failed since pDataBlocks is NULL", REPO_ID(pTsdb));
@@ -1633,6 +1670,87 @@ int32_t tsdbDropTSma(STsdb *pTsdb, char *pMsg) {
   return TSDB_CODE_SUCCESS;
 }
 
+/**
+ * @brief Only applicable to stable.
+ *
+ * @param pTsdb
+ * @param pMeta
+ * @param pReq
+ * @return int32_t
+ */
+int32_t tsdbRegisterRSma(STsdb *pTsdb, SMeta *pMeta, SVCreateTbReq *pReq) {
+  SRSmaParam *param = pReq->stbCfg.pRSmaParam;
+
+  if (param == NULL) {
+    tsdbDebug("vgId:%d return directly since no rollup for stable %s %" PRIi64, REPO_ID(pTsdb), pReq->name,
+              pReq->stbCfg.suid);
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if ((param->qmsg1Len == 0) && (param->qmsg2Len == 0)) {
+    tsdbWarn("vgId:%d no qmsg1/qmsg2 for rollup stable %s %" PRIi64, REPO_ID(pTsdb), pReq->name, pReq->stbCfg.suid);
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if (tsdbCheckAndInitSmaEnv(pTsdb, TSDB_SMA_TYPE_ROLLUP) != TSDB_CODE_SUCCESS) {
+    terrno = TSDB_CODE_TDB_INIT_FAILED;
+    return TSDB_CODE_FAILED;
+  }
+
+  SSmaEnv   *pEnv = REPO_RSMA_ENV(pTsdb);
+  SSmaStat  *pStat = SMA_ENV_STAT(pEnv);
+  SRSmaInfo *pRSmaInfo = NULL;
+
+  TASSERT(pEnv != NULL && pStat != NULL);
+
+  pRSmaInfo = taosHashGet(pStat->rsmaInfoHash, &pReq->stbCfg.suid, sizeof(tb_uid_t));
+  if (pRSmaInfo != NULL) {
+    pRSmaInfo = tsdbFreeRSmaInfo(pRSmaInfo);
+  }
+
+  STqReadHandle *pReadHandle = tqInitSubmitMsgScanner(pMeta);
+  if (pReadHandle == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return TSDB_CODE_FAILED;
+  }
+
+  pRSmaInfo = (SRSmaInfo *)taosMemoryCalloc(1, sizeof(SRSmaInfo));
+  if (pRSmaInfo == NULL) {
+    taosMemoryFree(pReadHandle);
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return TSDB_CODE_FAILED;
+  }
+
+  SReadHandle handle = {
+      .reader = pReadHandle,
+      .meta = pMeta,
+  };
+
+  if (param->qmsg1) {
+    pRSmaInfo->taskInfo[0] = qCreateStreamExecTaskInfo(param->qmsg1, &handle);
+    if (pRSmaInfo->taskInfo[0] == NULL) {
+      taosMemoryFree(pRSmaInfo);
+      taosMemoryFree(pReadHandle);
+      return TSDB_CODE_FAILED;
+    }
+  }
+
+  if (param->qmsg2) {
+    pRSmaInfo->taskInfo[1] = qCreateStreamExecTaskInfo(param->qmsg2, &handle);
+    if (pRSmaInfo->taskInfo[1] == NULL) {
+      taosMemoryFree(pRSmaInfo);
+      taosMemoryFree(pReadHandle);
+      return TSDB_CODE_FAILED;
+    }
+  }
+
+  if (taosHashPut(pStat->rsmaInfoHash, &pReq->stbCfg.suid, sizeof(tb_uid_t), &pRSmaInfo, sizeof(pRSmaInfo)) != 0) {
+    return TSDB_CODE_FAILED;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
 #if 0
 /**
  * @brief Get the start TS key of the last data block of one interval/sliding.
diff --git a/source/dnode/vnode/src/vnd/vnodeSvr.c b/source/dnode/vnode/src/vnd/vnodeSvr.c
index 1c3a3787f3..4b570c8045 100644
--- a/source/dnode/vnode/src/vnd/vnodeSvr.c
+++ b/source/dnode/vnode/src/vnd/vnodeSvr.c
@@ -215,14 +215,8 @@ static int vnodeProcessCreateStbReq(SVnode *pVnode, void *pReq) {
     return -1;
   }
 
-  // TODO: remove the debug log
-  SRSmaParam *param = vCreateTbReq.stbCfg.pRSmaParam;
-  if (param) {
-    printf("qmsg1 len = %d, body = %s\n", param->qmsg1 ? (int32_t)strlen(param->qmsg1) : 0,
-           param->qmsg1 ? param->qmsg1 : "");
-    printf("qmsg1 len = %d, body = %s\n", param->qmsg2 ? (int32_t)strlen(param->qmsg2) : 0,
-           param->qmsg2 ? param->qmsg2 : "");
-  }
+  // deploy Rollup SMA
+  tsdbRegisterRSma(pVnode->pTsdb, pVnode->pMeta, &vCreateTbReq);
 
   taosMemoryFree(vCreateTbReq.stbCfg.pSchema);
   taosMemoryFree(vCreateTbReq.stbCfg.pTagSchema);

From 1ec6fa12f603bab900c87dd7be3e7127b0725c68 Mon Sep 17 00:00:00 2001
From: Cary Xu <klxu@taosdata.com>
Date: Thu, 21 Apr 2022 23:33:47 +0800
Subject: [PATCH 02/23] add release method for rsma

---
 source/dnode/vnode/src/tsdb/tsdbMain.c |  4 +--
 source/dnode/vnode/src/tsdb/tsdbSma.c  | 44 ++++++++++++++++++--------
 2 files changed, 32 insertions(+), 16 deletions(-)

diff --git a/source/dnode/vnode/src/tsdb/tsdbMain.c b/source/dnode/vnode/src/tsdb/tsdbMain.c
index 2753579e9e..8691920c8f 100644
--- a/source/dnode/vnode/src/tsdb/tsdbMain.c
+++ b/source/dnode/vnode/src/tsdb/tsdbMain.c
@@ -81,8 +81,8 @@ static STsdb *tsdbNew(const char *path, SVnode *pVnode, const STsdbCfg *pTsdbCfg
 
 static void tsdbFree(STsdb *pTsdb) {
   if (pTsdb) {
-    // tsdbFreeSmaEnv(REPO_TSMA_ENV(pTsdb));
-    // tsdbFreeSmaEnv(REPO_RSMA_ENV(pTsdb));
+    tsdbFreeSmaEnv(REPO_TSMA_ENV(pTsdb));
+    tsdbFreeSmaEnv(REPO_RSMA_ENV(pTsdb));
     tsdbFreeFS(pTsdb->fs);
     taosMemoryFreeClear(pTsdb->path);
     taosMemoryFree(pTsdb);
diff --git a/source/dnode/vnode/src/tsdb/tsdbSma.c b/source/dnode/vnode/src/tsdb/tsdbSma.c
index 51b492b297..03ad5c10a5 100644
--- a/source/dnode/vnode/src/tsdb/tsdbSma.c
+++ b/source/dnode/vnode/src/tsdb/tsdbSma.c
@@ -48,6 +48,7 @@ typedef struct SPoolMem {
 
 struct SSmaEnv {
   TdThreadRwlock lock;
+  int8_t         type;
   TXN            txn;
   SPoolMem      *pPool;
   SDiskID        did;
@@ -57,6 +58,7 @@ struct SSmaEnv {
 };
 
 #define SMA_ENV_LOCK(env)       ((env)->lock)
+#define SMA_ENV_TYPE(env)       ((env)->type)
 #define SMA_ENV_DID(env)        ((env)->did)
 #define SMA_ENV_ENV(env)        ((env)->dbEnv)
 #define SMA_ENV_PATH(env)       ((env)->path)
@@ -141,7 +143,7 @@ static int32_t  tsdbSetExpiredWindow(STsdb *pTsdb, SHashObj *pItemsHash, int64_t
                                      int64_t version);
 static int32_t  tsdbInitSmaStat(SSmaStat **pSmaStat, int8_t smaType);
 static void    *tsdbFreeSmaStatItem(SSmaStatItem *pSmaStatItem);
-static int32_t  tsdbDestroySmaState(SSmaStat *pSmaStat);
+static int32_t  tsdbDestroySmaState(SSmaStat *pSmaStat, int8_t smaType);
 static SSmaEnv *tsdbNewSmaEnv(const STsdb *pTsdb, int8_t smaType, const char *path, SDiskID did);
 static int32_t  tsdbInitSmaEnv(STsdb *pTsdb, int8_t smaType, const char *path, SDiskID did, SSmaEnv **pEnv);
 static int32_t  tsdbResetExpiredWindow(STsdb *pTsdb, SSmaStat *pStat, int64_t indexUid, TSKEY skey);
@@ -357,6 +359,8 @@ static SSmaEnv *tsdbNewSmaEnv(const STsdb *pTsdb, int8_t smaType, const char *pa
     return NULL;
   }
 
+  SMA_ENV_TYPE(pEnv) = smaType;
+
   int code = taosThreadRwlockInit(&(pEnv->lock), NULL);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -365,15 +369,15 @@ static SSmaEnv *tsdbNewSmaEnv(const STsdb *pTsdb, int8_t smaType, const char *pa
   }
 
   ASSERT(path && (strlen(path) > 0));
-  pEnv->path = strdup(path);
-  if (pEnv->path == NULL) {
+  SMA_ENV_PATH(pEnv) = strdup(path);
+  if (SMA_ENV_PATH(pEnv) == NULL) {
     tsdbFreeSmaEnv(pEnv);
     return NULL;
   }
 
-  pEnv->did = did;
+  SMA_ENV_DID(pEnv) = did;
 
-  if (tsdbInitSmaStat(&pEnv->pStat, smaType) != TSDB_CODE_SUCCESS) {
+  if (tsdbInitSmaStat(&SMA_ENV_STAT(pEnv), smaType) != TSDB_CODE_SUCCESS) {
     tsdbFreeSmaEnv(pEnv);
     return NULL;
   }
@@ -416,7 +420,7 @@ static int32_t tsdbInitSmaEnv(STsdb *pTsdb, int8_t smaType, const char *path, SD
  */
 void tsdbDestroySmaEnv(SSmaEnv *pSmaEnv) {
   if (pSmaEnv) {
-    tsdbDestroySmaState(pSmaEnv->pStat);
+    tsdbDestroySmaState(pSmaEnv->pStat, SMA_ENV_TYPE(pSmaEnv));
     taosMemoryFreeClear(pSmaEnv->pStat);
     taosMemoryFreeClear(pSmaEnv->path);
     taosThreadRwlockDestroy(&(pSmaEnv->lock));
@@ -520,16 +524,28 @@ static void *tsdbFreeSmaStatItem(SSmaStatItem *pSmaStatItem) {
  * @param pSmaStat
  * @return int32_t
  */
-int32_t tsdbDestroySmaState(SSmaStat *pSmaStat) {
+int32_t tsdbDestroySmaState(SSmaStat *pSmaStat, int8_t smaType) {
   if (pSmaStat) {
     // TODO: use taosHashSetFreeFp when taosHashSetFreeFp is ready.
-    void *item = taosHashIterate(pSmaStat->smaStatItems, NULL);
-    while (item != NULL) {
-      SSmaStatItem *pItem = *(SSmaStatItem **)item;
-      tsdbFreeSmaStatItem(pItem);
-      item = taosHashIterate(pSmaStat->smaStatItems, item);
+    if (smaType == TSDB_SMA_TYPE_TIME_RANGE) {
+      void *item = taosHashIterate(SSMA_STAT_ITEMS(pSmaStat), NULL);
+      while (item != NULL) {
+        SSmaStatItem *pItem = *(SSmaStatItem **)item;
+        tsdbFreeSmaStatItem(pItem);
+        item = taosHashIterate(SSMA_STAT_ITEMS(pSmaStat), item);
+      }
+      taosHashCleanup(SSMA_STAT_ITEMS(pSmaStat));
+    } else if (smaType == TSDB_SMA_TYPE_ROLLUP) {
+      void *infoHash = taosHashIterate(SSMA_STAT_INFO_HASH(pSmaStat), NULL);
+      while (infoHash != NULL) {
+        SRSmaInfo *pInfoHash = *(SRSmaInfo **)infoHash;
+        tsdbFreeRSmaInfo(pInfoHash);
+        infoHash = taosHashIterate(SSMA_STAT_INFO_HASH(pSmaStat), infoHash);
+      }
+      taosHashCleanup(SSMA_STAT_INFO_HASH(pSmaStat));
+    } else {
+      ASSERT(0);
     }
-    taosHashCleanup(pSmaStat->smaStatItems);
   }
   return TSDB_CODE_SUCCESS;
 }
@@ -1744,7 +1760,7 @@ int32_t tsdbRegisterRSma(STsdb *pTsdb, SMeta *pMeta, SVCreateTbReq *pReq) {
     }
   }
 
-  if (taosHashPut(pStat->rsmaInfoHash, &pReq->stbCfg.suid, sizeof(tb_uid_t), &pRSmaInfo, sizeof(pRSmaInfo)) != 0) {
+  if (taosHashPut(SSMA_STAT_INFO_HASH(pStat), &pReq->stbCfg.suid, sizeof(tb_uid_t), &pRSmaInfo, sizeof(pRSmaInfo)) != 0) {
     return TSDB_CODE_FAILED;
   }
 

From 2d328c8930908c622534646820816462214c10f3 Mon Sep 17 00:00:00 2001
From: Cary Xu <klxu@taosdata.com>
Date: Thu, 21 Apr 2022 23:55:20 +0800
Subject: [PATCH 03/23] refactor

---
 source/dnode/vnode/src/inc/tsdbSma.h  |  1 +
 source/dnode/vnode/src/tsdb/tsdbSma.c | 41 ++++++++++++++-------------
 source/dnode/vnode/src/vnd/vnodeSvr.c |  1 -
 3 files changed, 22 insertions(+), 21 deletions(-)

diff --git a/source/dnode/vnode/src/inc/tsdbSma.h b/source/dnode/vnode/src/inc/tsdbSma.h
index a178b2e4c0..322ba215ad 100644
--- a/source/dnode/vnode/src/inc/tsdbSma.h
+++ b/source/dnode/vnode/src/inc/tsdbSma.h
@@ -25,6 +25,7 @@ extern "C" {
 #endif
 
 int32_t tsdbRegisterRSma(STsdb *pTsdb, SMeta *pMeta, SVCreateTbReq *pReq);
+int32_t tsdbTriggerRSma(STsdb *pTsdb, SMeta *pMeta, SSubmitReq *pMsg);
 
 #ifdef __cplusplus
 }
diff --git a/source/dnode/vnode/src/tsdb/tsdbSma.c b/source/dnode/vnode/src/tsdb/tsdbSma.c
index 03ad5c10a5..34d41b1c79 100644
--- a/source/dnode/vnode/src/tsdb/tsdbSma.c
+++ b/source/dnode/vnode/src/tsdb/tsdbSma.c
@@ -109,12 +109,12 @@ struct SSmaStat {
 
   T_REF_DECLARE()
 };
-#define SSMA_STAT_ITEMS(s)     ((s)->smaStatItems)
-#define SSMA_STAT_INFO_HASH(s) ((s)->rsmaInfoHash)
+#define SMA_STAT_ITEMS(s)     ((s)->smaStatItems)
+#define SMA_STAT_INFO_HASH(s) ((s)->rsmaInfoHash)
 
 #define RSMA_MAX_LEVEL           2
 #define RSMA_TASK_INFO_HASH_SLOT 8
-    struct SRSmaInfo {
+struct SRSmaInfo {
   void *taskInfo[RSMA_MAX_LEVEL];  // qTaskInfo_t
 };
 
@@ -471,18 +471,18 @@ static int32_t tsdbInitSmaStat(SSmaStat **pSmaStat, int8_t smaType) {
     }
 
     if (smaType == TSDB_SMA_TYPE_ROLLUP) {
-      SSMA_STAT_INFO_HASH(*pSmaStat) = taosHashInit(
+      SMA_STAT_INFO_HASH(*pSmaStat) = taosHashInit(
           RSMA_TASK_INFO_HASH_SLOT, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_ENTRY_LOCK);
 
-      if (SSMA_STAT_INFO_HASH(*pSmaStat) == NULL) {
+      if (SMA_STAT_INFO_HASH(*pSmaStat) == NULL) {
         taosMemoryFreeClear(*pSmaStat);
         return TSDB_CODE_FAILED;
       }
     } else if (smaType == TSDB_SMA_TYPE_TIME_RANGE) {
-      SSMA_STAT_ITEMS(*pSmaStat) =
+      SMA_STAT_ITEMS(*pSmaStat) =
           taosHashInit(SMA_STATE_HASH_SLOT, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
 
-      if (SSMA_STAT_ITEMS(*pSmaStat) == NULL) {
+      if (SMA_STAT_ITEMS(*pSmaStat) == NULL) {
         taosMemoryFreeClear(*pSmaStat);
         return TSDB_CODE_FAILED;
       }
@@ -528,21 +528,21 @@ int32_t tsdbDestroySmaState(SSmaStat *pSmaStat, int8_t smaType) {
   if (pSmaStat) {
     // TODO: use taosHashSetFreeFp when taosHashSetFreeFp is ready.
     if (smaType == TSDB_SMA_TYPE_TIME_RANGE) {
-      void *item = taosHashIterate(SSMA_STAT_ITEMS(pSmaStat), NULL);
+      void *item = taosHashIterate(SMA_STAT_ITEMS(pSmaStat), NULL);
       while (item != NULL) {
         SSmaStatItem *pItem = *(SSmaStatItem **)item;
         tsdbFreeSmaStatItem(pItem);
-        item = taosHashIterate(SSMA_STAT_ITEMS(pSmaStat), item);
+        item = taosHashIterate(SMA_STAT_ITEMS(pSmaStat), item);
       }
-      taosHashCleanup(SSMA_STAT_ITEMS(pSmaStat));
+      taosHashCleanup(SMA_STAT_ITEMS(pSmaStat));
     } else if (smaType == TSDB_SMA_TYPE_ROLLUP) {
-      void *infoHash = taosHashIterate(SSMA_STAT_INFO_HASH(pSmaStat), NULL);
+      void *infoHash = taosHashIterate(SMA_STAT_INFO_HASH(pSmaStat), NULL);
       while (infoHash != NULL) {
         SRSmaInfo *pInfoHash = *(SRSmaInfo **)infoHash;
         tsdbFreeRSmaInfo(pInfoHash);
-        infoHash = taosHashIterate(SSMA_STAT_INFO_HASH(pSmaStat), infoHash);
+        infoHash = taosHashIterate(SMA_STAT_INFO_HASH(pSmaStat), infoHash);
       }
-      taosHashCleanup(SSMA_STAT_INFO_HASH(pSmaStat));
+      taosHashCleanup(SMA_STAT_INFO_HASH(pSmaStat));
     } else {
       ASSERT(0);
     }
@@ -1687,7 +1687,7 @@ int32_t tsdbDropTSma(STsdb *pTsdb, char *pMsg) {
 }
 
 /**
- * @brief Only applicable to stable.
+ * @brief Check and init qTaskInfo_t, only applicable to stable with SRSmaParam.
  *
  * @param pTsdb
  * @param pMeta
@@ -1724,15 +1724,15 @@ int32_t tsdbRegisterRSma(STsdb *pTsdb, SMeta *pMeta, SVCreateTbReq *pReq) {
     pRSmaInfo = tsdbFreeRSmaInfo(pRSmaInfo);
   }
 
-  STqReadHandle *pReadHandle = tqInitSubmitMsgScanner(pMeta);
-  if (pReadHandle == NULL) {
+  pRSmaInfo = (SRSmaInfo *)taosMemoryCalloc(1, sizeof(SRSmaInfo));
+  if (pRSmaInfo == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return TSDB_CODE_FAILED;
   }
 
-  pRSmaInfo = (SRSmaInfo *)taosMemoryCalloc(1, sizeof(SRSmaInfo));
-  if (pRSmaInfo == NULL) {
-    taosMemoryFree(pReadHandle);
+  STqReadHandle *pReadHandle = tqInitSubmitMsgScanner(pMeta);
+  if (pReadHandle == NULL) {
+    taosMemoryFree(pRSmaInfo);
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return TSDB_CODE_FAILED;
   }
@@ -1760,7 +1760,8 @@ int32_t tsdbRegisterRSma(STsdb *pTsdb, SMeta *pMeta, SVCreateTbReq *pReq) {
     }
   }
 
-  if (taosHashPut(SSMA_STAT_INFO_HASH(pStat), &pReq->stbCfg.suid, sizeof(tb_uid_t), &pRSmaInfo, sizeof(pRSmaInfo)) != 0) {
+  if (taosHashPut(SMA_STAT_INFO_HASH(pStat), &pReq->stbCfg.suid, sizeof(tb_uid_t), &pRSmaInfo, sizeof(pRSmaInfo)) !=
+      0) {
     return TSDB_CODE_FAILED;
   }
 
diff --git a/source/dnode/vnode/src/vnd/vnodeSvr.c b/source/dnode/vnode/src/vnd/vnodeSvr.c
index 4b570c8045..a81bbf4298 100644
--- a/source/dnode/vnode/src/vnd/vnodeSvr.c
+++ b/source/dnode/vnode/src/vnd/vnodeSvr.c
@@ -215,7 +215,6 @@ static int vnodeProcessCreateStbReq(SVnode *pVnode, void *pReq) {
     return -1;
   }
 
-  // deploy Rollup SMA
   tsdbRegisterRSma(pVnode->pTsdb, pVnode->pMeta, &vCreateTbReq);
 
   taosMemoryFree(vCreateTbReq.stbCfg.pSchema);

From 4a8db28554fdc6fc444748013b900356414aa712 Mon Sep 17 00:00:00 2001
From: Cary Xu <klxu@taosdata.com>
Date: Fri, 22 Apr 2022 00:19:50 +0800
Subject: [PATCH 04/23] trigger CI


From fb45d0d9356eec2646877900733da2e0253d0a9e Mon Sep 17 00:00:00 2001
From: Cary Xu <klxu@taosdata.com>
Date: Sat, 23 Apr 2022 19:15:20 +0800
Subject: [PATCH 05/23] roll up sma generate

---
 include/libs/executor/executor.h          |   4 +-
 source/dnode/mnode/impl/src/mndStb.c      |   1 -
 source/dnode/vnode/inc/vnode.h            |   1 +
 source/dnode/vnode/src/inc/meta.h         |   4 +-
 source/dnode/vnode/src/inc/tsdbSma.h      |  31 +++-
 source/dnode/vnode/src/inc/vnodeInt.h     |   2 +
 source/dnode/vnode/src/meta/metaTDBImpl.c |   8 +-
 source/dnode/vnode/src/meta/metaTable.c   |   4 +-
 source/dnode/vnode/src/tq/tq.c            |   4 +-
 source/dnode/vnode/src/tq/tqRead.c        |  16 ++
 source/dnode/vnode/src/tsdb/tsdbSma.c     | 176 ++++++++++++++++++++--
 source/dnode/vnode/src/vnd/vnodeSvr.c     |  15 +-
 source/libs/executor/src/executor.c       |  21 ++-
 source/libs/stream/src/tstream.c          |   4 +-
 14 files changed, 253 insertions(+), 38 deletions(-)

diff --git a/include/libs/executor/executor.h b/include/libs/executor/executor.h
index 4d289147d0..04f67b584f 100644
--- a/include/libs/executor/executor.h
+++ b/include/libs/executor/executor.h
@@ -57,7 +57,7 @@ qTaskInfo_t qCreateStreamExecTaskInfo(void* msg, void* streamReadHandle);
  * @param type
  * @return
  */
-int32_t qSetStreamInput(qTaskInfo_t tinfo, const void* input, int32_t type);
+int32_t qSetStreamInput(qTaskInfo_t tinfo, const void* input, int32_t type, bool converted);
 
 /**
  * Set multiple input data blocks for the stream scan.
@@ -67,7 +67,7 @@ int32_t qSetStreamInput(qTaskInfo_t tinfo, const void* input, int32_t type);
  * @param type
  * @return
  */
-int32_t qSetMultiStreamInput(qTaskInfo_t tinfo, const void* pBlocks, size_t numOfBlocks, int32_t type);
+int32_t qSetMultiStreamInput(qTaskInfo_t tinfo, const void* pBlocks, size_t numOfBlocks, int32_t type, bool converted);
 
 /**
  * Update the table id list, add or remove.
diff --git a/source/dnode/mnode/impl/src/mndStb.c b/source/dnode/mnode/impl/src/mndStb.c
index f304e3153d..1e63dd9833 100644
--- a/source/dnode/mnode/impl/src/mndStb.c
+++ b/source/dnode/mnode/impl/src/mndStb.c
@@ -453,7 +453,6 @@ static void *mndBuildVCreateStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pSt
       }
     }
     if (pStb->ast2Len > 0) {
-      int32_t qmsgLen2 = 0;
       if (mndConvertRSmaTask(pStb->pAst2, 0, 0, &pRSmaParam->qmsg2, &pRSmaParam->qmsg2Len) != TSDB_CODE_SUCCESS) {
         taosMemoryFreeClear(pRSmaParam->pFuncIds);
         taosMemoryFreeClear(pRSmaParam->qmsg1);
diff --git a/source/dnode/vnode/inc/vnode.h b/source/dnode/vnode/inc/vnode.h
index 2b52d333da..9f80f0beff 100644
--- a/source/dnode/vnode/inc/vnode.h
+++ b/source/dnode/vnode/inc/vnode.h
@@ -108,6 +108,7 @@ void    tqReadHandleSetColIdList(STqReadHandle *pReadHandle, SArray *pColIdList)
 int     tqReadHandleSetTbUidList(STqReadHandle *pHandle, const SArray *tbUidList);
 int     tqReadHandleAddTbUidList(STqReadHandle *pHandle, const SArray *tbUidList);
 int32_t tqReadHandleSetMsg(STqReadHandle *pHandle, SSubmitReq *pMsg, int64_t ver);
+int32_t tqReadHandleSetMsgEx(STqReadHandle *pHandle, SSubmitReq *pMsg, int64_t ver);
 bool    tqNextDataBlock(STqReadHandle *pHandle);
 int32_t tqRetrieveDataBlock(SArray **ppCols, STqReadHandle *pHandle, uint64_t *pGroupId, int32_t *pNumOfRows);
 
diff --git a/source/dnode/vnode/src/inc/meta.h b/source/dnode/vnode/src/inc/meta.h
index fb875a46e0..2d417fd626 100644
--- a/source/dnode/vnode/src/inc/meta.h
+++ b/source/dnode/vnode/src/inc/meta.h
@@ -51,7 +51,7 @@ static FORCE_INLINE tb_uid_t metaGenerateUid(SMeta* pMeta) { return tGenIdPI64()
 #define META_CHILD_TABLE  TD_CHILD_TABLE
 #define META_NORMAL_TABLE TD_NORMAL_TABLE
 
-int             metaCreateTable(SMeta* pMeta, STbCfg* pTbCfg);
+int             metaCreateTable(SMeta* pMeta, STbCfg* pTbCfg, STbDdlHandle *pHandle);
 int             metaDropTable(SMeta* pMeta, tb_uid_t uid);
 int             metaCommit(SMeta* pMeta);
 int32_t         metaCreateTSma(SMeta* pMeta, SSmaCfg* pCfg);
@@ -74,7 +74,7 @@ tb_uid_t        metaCtbCursorNext(SMCtbCursor* pCtbCur);
 // SMetaDB
 int  metaOpenDB(SMeta* pMeta);
 void metaCloseDB(SMeta* pMeta);
-int  metaSaveTableToDB(SMeta* pMeta, STbCfg* pTbCfg);
+int  metaSaveTableToDB(SMeta* pMeta, STbCfg* pTbCfg, STbDdlHandle *pHandle);
 int  metaRemoveTableFromDb(SMeta* pMeta, tb_uid_t uid);
 int  metaSaveSmaToDB(SMeta* pMeta, STSma* pTbCfg);
 int  metaRemoveSmaFromDb(SMeta* pMeta, int64_t indexUid);
diff --git a/source/dnode/vnode/src/inc/tsdbSma.h b/source/dnode/vnode/src/inc/tsdbSma.h
index 322ba215ad..3aad11a6b5 100644
--- a/source/dnode/vnode/src/inc/tsdbSma.h
+++ b/source/dnode/vnode/src/inc/tsdbSma.h
@@ -24,8 +24,37 @@
 extern "C" {
 #endif
 
+typedef int32_t (*__tb_ddl_fn_t)(void *ahandle, void **result, void *p1, void *p2);
+
+struct STbDdlHandle {
+  void         *ahandle;
+  void         *result;
+  __tb_ddl_fn_t fp;
+};
+
+typedef struct {
+  tb_uid_t  suid;
+  SArray   *tbUids;
+  SHashObj *uidHash;
+} STbUidStore;
+
+static FORCE_INLINE int32_t tsdbUidStoreInit(STbUidStore **pStore) {
+  ASSERT(*pStore == NULL);
+  *pStore = taosMemoryCalloc(1, sizeof(STbUidStore));
+  if (*pStore == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return TSDB_CODE_FAILED;
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t tsdbUidStorePut(STbUidStore *pStore, tb_uid_t suid, tb_uid_t uid);
+void   *tsdbUidStoreFree(STbUidStore *pStore);
+
 int32_t tsdbRegisterRSma(STsdb *pTsdb, SMeta *pMeta, SVCreateTbReq *pReq);
-int32_t tsdbTriggerRSma(STsdb *pTsdb, SMeta *pMeta, SSubmitReq *pMsg);
+int32_t tsdbFetchTbUidList(void *pTsdb, void **result, void *suid, void *uid);
+int32_t tsdbUpdateTbUidList(STsdb *pTsdb, STbUidStore *pUidStore);
+int32_t tsdbTriggerRSma(STsdb *pTsdb, SMeta *pMeta, const void *pMsg, int32_t inputType);
 
 #ifdef __cplusplus
 }
diff --git a/source/dnode/vnode/src/inc/vnodeInt.h b/source/dnode/vnode/src/inc/vnodeInt.h
index 23a6d97a66..5566681dc0 100644
--- a/source/dnode/vnode/src/inc/vnodeInt.h
+++ b/source/dnode/vnode/src/inc/vnodeInt.h
@@ -102,6 +102,8 @@ struct SVnode {
 
 #define TD_VID(PVNODE) (PVNODE)->config.vgId
 
+typedef struct STbDdlHandle STbDdlHandle;
+
 // sma
 void smaHandleRes(void* pVnode, int64_t smaId, const SArray* data);
 
diff --git a/source/dnode/vnode/src/meta/metaTDBImpl.c b/source/dnode/vnode/src/meta/metaTDBImpl.c
index 149a7ca3cb..96e2a34b7b 100644
--- a/source/dnode/vnode/src/meta/metaTDBImpl.c
+++ b/source/dnode/vnode/src/meta/metaTDBImpl.c
@@ -248,7 +248,7 @@ void metaCloseDB(SMeta *pMeta) {
   }
 }
 
-int metaSaveTableToDB(SMeta *pMeta, STbCfg *pTbCfg) {
+int metaSaveTableToDB(SMeta *pMeta, STbCfg *pTbCfg, STbDdlHandle *pHandle) {
   tb_uid_t       uid;
   SMetaDB       *pMetaDb;
   void          *pKey;
@@ -347,6 +347,12 @@ int metaSaveTableToDB(SMeta *pMeta, STbCfg *pTbCfg) {
     if (ret < 0) {
       return -1;
     }
+    // child table handle for rsma
+    if (pHandle && pHandle->fp) {
+      if (((*pHandle->fp)(pHandle->ahandle, &pHandle->result, &ctbIdxKey.suid, &uid)) < 0) {
+        return -1;
+      };
+    }
   } else if (pTbCfg->type == META_NORMAL_TABLE) {
     pKey = &uid;
     kLen = sizeof(uid);
diff --git a/source/dnode/vnode/src/meta/metaTable.c b/source/dnode/vnode/src/meta/metaTable.c
index 7f06ba8855..32e7c24b64 100644
--- a/source/dnode/vnode/src/meta/metaTable.c
+++ b/source/dnode/vnode/src/meta/metaTable.c
@@ -15,7 +15,7 @@
 
 #include "vnodeInt.h"
 
-int metaCreateTable(SMeta *pMeta, STbCfg *pTbCfg) {
+int metaCreateTable(SMeta *pMeta, STbCfg *pTbCfg, STbDdlHandle *pHandle) {
   // Validate the tbOptions
   // if (metaValidateTbCfg(pMeta, pTbCfg) < 0) {
   //   // TODO: handle error
@@ -24,7 +24,7 @@ int metaCreateTable(SMeta *pMeta, STbCfg *pTbCfg) {
 
   // TODO: add atomicity
 
-  if (metaSaveTableToDB(pMeta, pTbCfg) < 0) {
+  if (metaSaveTableToDB(pMeta, pTbCfg, pHandle) < 0) {
     // TODO: handle error
     return -1;
   }
diff --git a/source/dnode/vnode/src/tq/tq.c b/source/dnode/vnode/src/tq/tq.c
index 510dd32459..1d693ddff5 100644
--- a/source/dnode/vnode/src/tq/tq.c
+++ b/source/dnode/vnode/src/tq/tq.c
@@ -287,7 +287,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
       SSubmitReq* pCont = (SSubmitReq*)&pHead->body;
       qTaskInfo_t task = pExec->task[workerId];
       ASSERT(task);
-      qSetStreamInput(task, pCont, STREAM_DATA_TYPE_SUBMIT_BLOCK);
+      qSetStreamInput(task, pCont, STREAM_DATA_TYPE_SUBMIT_BLOCK, false);
       while (1) {
         SSDataBlock* pDataBlock = NULL;
         uint64_t     ts = 0;
@@ -450,7 +450,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
       SSubmitReq* pCont = (SSubmitReq*)&pHead->body;
       qTaskInfo_t task = pTopic->buffer.output[workerId].task;
       ASSERT(task);
-      qSetStreamInput(task, pCont, STREAM_DATA_TYPE_SUBMIT_BLOCK);
+      qSetStreamInput(task, pCont, STREAM_DATA_TYPE_SUBMIT_BLOCK, false);
       SArray* pRes = taosArrayInit(0, sizeof(SSDataBlock));
       while (1) {
         SSDataBlock* pDataBlock = NULL;
diff --git a/source/dnode/vnode/src/tq/tqRead.c b/source/dnode/vnode/src/tq/tqRead.c
index 02ce6c4aad..3cdd88a597 100644
--- a/source/dnode/vnode/src/tq/tqRead.c
+++ b/source/dnode/vnode/src/tq/tqRead.c
@@ -56,6 +56,22 @@ int32_t tqReadHandleSetMsg(STqReadHandle* pReadHandle, SSubmitReq* pMsg, int64_t
   return 0;
 }
 
+int32_t tqReadHandleSetMsgEx(STqReadHandle* pReadHandle, SSubmitReq* pMsg, int64_t ver) {
+  pReadHandle->pMsg = pMsg;
+
+  // iterate
+  if (tInitSubmitMsgIter(pMsg, &pReadHandle->msgIter) < 0) return -1;
+  while (true) {
+    if (tGetSubmitMsgNext(&pReadHandle->msgIter, &pReadHandle->pBlock) < 0) return -1;
+    if (pReadHandle->pBlock == NULL) break;
+  }
+
+  if (tInitSubmitMsgIter(pMsg, &pReadHandle->msgIter) < 0) return -1;
+  pReadHandle->ver = ver;
+  memset(&pReadHandle->blkIter, 0, sizeof(SSubmitBlkIter));
+  return 0;
+}
+
 bool tqNextDataBlock(STqReadHandle* pHandle) {
   while (1) {
     if (tGetSubmitMsgNext(&pHandle->msgIter, &pHandle->pBlock) < 0) {
diff --git a/source/dnode/vnode/src/tsdb/tsdbSma.c b/source/dnode/vnode/src/tsdb/tsdbSma.c
index 34d41b1c79..4722e27391 100644
--- a/source/dnode/vnode/src/tsdb/tsdbSma.c
+++ b/source/dnode/vnode/src/tsdb/tsdbSma.c
@@ -101,23 +101,24 @@ typedef struct {
   STSma    *pSma;            // cache schema
 } SSmaStatItem;
 
-struct SSmaStat {
-  union {
-    SHashObj *smaStatItems;  // key: indexUid, value: SSmaStatItem for tsma
-    SHashObj *rsmaInfoHash;  // key: stbUid, value: SRSmaInfo;
-  };
-
-  T_REF_DECLARE()
-};
-#define SMA_STAT_ITEMS(s)     ((s)->smaStatItems)
-#define SMA_STAT_INFO_HASH(s) ((s)->rsmaInfoHash)
-
 #define RSMA_MAX_LEVEL           2
 #define RSMA_TASK_INFO_HASH_SLOT 8
 struct SRSmaInfo {
   void *taskInfo[RSMA_MAX_LEVEL];  // qTaskInfo_t
 };
 
+struct SSmaStat {
+  union {
+    SHashObj *smaStatItems;  // key: indexUid, value: SSmaStatItem for tsma
+    SHashObj *rsmaInfoHash;  // key: stbUid, value: SRSmaInfo;
+  };
+  SRSmaInfo rsmaInfo;
+
+  T_REF_DECLARE()
+};
+#define SMA_STAT_ITEMS(s)     ((s)->smaStatItems)
+#define SMA_STAT_INFO_HASH(s) ((s)->rsmaInfoHash)
+
 static FORCE_INLINE void tsdbFreeTaskHandle(qTaskInfo_t *taskHandle) {
   // Note: free/kill may in RC
   qTaskInfo_t otaskHandle = atomic_load_ptr(taskHandle);
@@ -1120,9 +1121,8 @@ static int32_t tsdbInsertTSmaDataImpl(STsdb *pTsdb, int64_t indexUid, const char
   int32_t storageLevel = tsdbGetSmaStorageLevel(pSma->interval, pSma->intervalUnit);
   int32_t daysPerFile = tsdbGetTSmaDays(pTsdb, tSmaH.interval, storageLevel);
 
-  // key: skey + groupId
-  char    smaKey[SMA_KEY_LEN] = {0};
-  char    dataBuf[512] = {0};
+  char    smaKey[SMA_KEY_LEN] = {0};  // key: skey + groupId
+  char    dataBuf[512] = {0};         // val: aggr data // TODO: handle 512 buffer?
   void   *pDataBuf = NULL;
   int32_t sz = taosArrayGetSize(pDataBlocks);
   for (int32_t i = 0; i < sz; ++i) {
@@ -1716,6 +1716,7 @@ int32_t tsdbRegisterRSma(STsdb *pTsdb, SMeta *pMeta, SVCreateTbReq *pReq) {
   SSmaEnv   *pEnv = REPO_RSMA_ENV(pTsdb);
   SSmaStat  *pStat = SMA_ENV_STAT(pEnv);
   SRSmaInfo *pRSmaInfo = NULL;
+  SRSmaInfo *tRSmaInfo = &pStat->rsmaInfo;
 
   TASSERT(pEnv != NULL && pStat != NULL);
 
@@ -1749,6 +1750,7 @@ int32_t tsdbRegisterRSma(STsdb *pTsdb, SMeta *pMeta, SVCreateTbReq *pReq) {
       taosMemoryFree(pReadHandle);
       return TSDB_CODE_FAILED;
     }
+    tRSmaInfo->taskInfo[0] = pRSmaInfo->taskInfo[0];
   }
 
   if (param->qmsg2) {
@@ -1758,6 +1760,7 @@ int32_t tsdbRegisterRSma(STsdb *pTsdb, SMeta *pMeta, SVCreateTbReq *pReq) {
       taosMemoryFree(pReadHandle);
       return TSDB_CODE_FAILED;
     }
+    tRSmaInfo->taskInfo[1] = pRSmaInfo->taskInfo[1];
   }
 
   if (taosHashPut(SMA_STAT_INFO_HASH(pStat), &pReq->stbCfg.suid, sizeof(tb_uid_t), &pRSmaInfo, sizeof(pRSmaInfo)) !=
@@ -1768,6 +1771,151 @@ int32_t tsdbRegisterRSma(STsdb *pTsdb, SMeta *pMeta, SVCreateTbReq *pReq) {
   return TSDB_CODE_SUCCESS;
 }
 
+int32_t tsdbUidStorePut(STbUidStore *pStore, tb_uid_t suid, tb_uid_t uid) {
+  if ((suid == pStore->suid) || (pStore->suid == 0)) {
+    if (pStore->tbUids == NULL) {
+      if ((pStore->tbUids = taosArrayInit(1, sizeof(tb_uid_t))) == NULL) {
+        terrno = TSDB_CODE_OUT_OF_MEMORY;
+        return TSDB_CODE_FAILED;
+      }
+      pStore->suid = suid;
+    }
+    if (taosArrayPush(pStore->tbUids, &uid) == NULL) {
+      return TSDB_CODE_FAILED;
+    }
+  } else {
+    if (pStore->uidHash == NULL) {
+      pStore->uidHash = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK);
+      if (pStore->uidHash == NULL) {
+        return TSDB_CODE_FAILED;
+      }
+    }
+    SArray *hashVal = taosHashGet(pStore->uidHash, &suid, sizeof(tb_uid_t));
+    if (hashVal && ((hashVal = *(SArray **)hashVal) != NULL)) {
+      taosArrayPush(hashVal, &uid);
+    } else {
+      SArray *pItem = taosArrayInit(1, sizeof(tb_uid_t));
+      if (pItem == NULL) {
+        terrno = TSDB_CODE_OUT_OF_MEMORY;
+        return TSDB_CODE_FAILED;
+      }
+      if (taosArrayPush(pItem, &uid) == NULL) {
+        terrno = TSDB_CODE_OUT_OF_MEMORY;
+        return TSDB_CODE_FAILED;
+      }
+      if (taosHashPut(pStore->uidHash, &suid, sizeof(suid), &pItem, sizeof(pItem)) != 0) {
+        return TSDB_CODE_FAILED;
+      }
+    }
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t tsdbFetchTbUidList(void *pTsdb, void **ppStore, void *suid, void *uid) {
+  SSmaEnv *pEnv = REPO_RSMA_ENV((STsdb *)pTsdb);
+  if (!pEnv) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  SSmaStat *pStat = SMA_ENV_STAT(pEnv);
+  SHashObj *infoHash = NULL;
+  if (!pStat || !(infoHash = SMA_STAT_INFO_HASH(pStat))) {
+    terrno = TSDB_CODE_TDB_INVALID_SMA_STAT;
+    return TSDB_CODE_FAILED;
+  }
+
+  // info cached when create rsma stable
+  if (!taosHashGet(infoHash, suid, sizeof(suid))) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if (*ppStore == NULL) {
+    if (tsdbUidStoreInit((STbUidStore **)ppStore) != 0) {
+      return TSDB_CODE_FAILED;
+    }
+  }
+  if (tsdbUidStorePut(*ppStore, *(tb_uid_t *)suid, *(tb_uid_t *)uid) != 0) {
+    *ppStore = tsdbUidStoreFree(*ppStore);
+    return TSDB_CODE_FAILED;
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
+void *tsdbUidStoreFree(STbUidStore *pStore) {
+  if (pStore) {
+    taosArrayDestroy(pStore->tbUids);
+    if (pStore->uidHash) {
+      void *pIter = taosHashIterate(pStore->uidHash, NULL);
+      while (pIter != NULL) {
+        SArray *arr = *(SArray **)pIter;
+        taosArrayDestroy(arr);
+        pIter = taosHashIterate(pStore->uidHash, pIter);
+      }
+    }
+    taosMemoryFree(pStore);
+  }
+  return NULL;
+}
+
+int32_t tsdbUpdateTbUidList(STsdb *pTsdb, STbUidStore *pUidStore) {
+  if (!pUidStore || (taosArrayGetSize(pUidStore->tbUids) == 0)) {
+    tsdbDebug("vgId:%d empty uidStore and no need to update", REPO_ID(pTsdb));
+    return TSDB_CODE_SUCCESS;
+  }
+  SSmaEnv   *pEnv = REPO_RSMA_ENV(pTsdb);
+  SSmaStat  *pStat = SMA_ENV_STAT(pEnv);
+  SRSmaInfo *pRSmaInfo = &pStat->rsmaInfo;
+
+  if (qUpdateQualifiedTableId(pRSmaInfo->taskInfo[0], pUidStore->tbUids, true) != 0) {
+    tsdbUidStoreFree(pUidStore);
+    tsdbError("vgId:%d update tbUidList failed since %s", REPO_ID(pTsdb), terrstr(terrno));
+    return TSDB_CODE_FAILED;
+  }
+
+  tsdbUidStoreFree(pUidStore);
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t tsdbTriggerRSma(STsdb *pTsdb, SMeta *pMeta, const void *pMsg, int32_t inputType) {
+  SArray *pResult = NULL;
+
+  pResult = taosArrayInit(0, sizeof(SSDataBlock));
+  if (pResult == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
+
+  SSmaEnv   *pEnv = REPO_RSMA_ENV(pTsdb);
+  SSmaStat  *pStat = SMA_ENV_STAT(pEnv);
+  SRSmaInfo *pRSmaInfo = NULL;
+
+  TASSERT(pEnv != NULL && pStat != NULL);
+
+  if (inputType == STREAM_DATA_TYPE_SUBMIT_BLOCK) {
+    // pRSmaInfo = taosHashGet(pStat->rsmaInfoHash, &pReq->stbCfg.suid, sizeof(tb_uid_t));
+    // if (pRSmaInfo != NULL) {
+    //   pRSmaInfo = tsdbFreeRSmaInfo(pRSmaInfo);
+    // }
+
+    SRSmaInfo *tRSmaInfo = &pStat->rsmaInfo;
+
+    qSetStreamInput(tRSmaInfo->taskInfo[0], pMsg, inputType, true);
+    while (1) {
+      SSDataBlock *output;
+      uint64_t     ts;
+      if (qExecTask(tRSmaInfo->taskInfo[0], &output, &ts) < 0) {
+        ASSERT(false);
+      }
+      if (output == NULL) {
+        break;
+      }
+      taosArrayPush(pResult, output);
+    }
+  }
+  blockDebugShowData(pResult);
+  return TSDB_CODE_SUCCESS;
+}
+
 #if 0
 /**
  * @brief Get the start TS key of the last data block of one interval/sliding.
diff --git a/source/dnode/vnode/src/vnd/vnodeSvr.c b/source/dnode/vnode/src/vnd/vnodeSvr.c
index a81bbf4298..310a2751dd 100644
--- a/source/dnode/vnode/src/vnd/vnodeSvr.c
+++ b/source/dnode/vnode/src/vnd/vnodeSvr.c
@@ -79,6 +79,7 @@ int vnodeProcessWriteReq(SVnode *pVnode, SRpcMsg *pMsg, int64_t version, SRpcMsg
     case TDMT_VND_SUBMIT:
       pRsp->msgType = TDMT_VND_SUBMIT_RSP;
       vnodeProcessSubmitReq(pVnode, ptr, pRsp);
+      tsdbTriggerRSma(pVnode->pTsdb, pVnode->pMeta, ptr, STREAM_DATA_TYPE_SUBMIT_BLOCK);
       break;
     case TDMT_VND_MQ_VG_CHANGE:
       if (tqProcessVgChangeReq(pVnode->pTq, POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead)),
@@ -112,7 +113,6 @@ int vnodeProcessWriteReq(SVnode *pVnode, SRpcMsg *pMsg, int64_t version, SRpcMsg
       }
     } break;
     case TDMT_VND_CREATE_SMA: {  // timeRangeSMA
-
       if (tsdbCreateTSma(pVnode->pTsdb, POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead))) < 0) {
         // TODO
       }
@@ -210,7 +210,7 @@ int vnodeProcessSyncReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
 static int vnodeProcessCreateStbReq(SVnode *pVnode, void *pReq) {
   SVCreateTbReq vCreateTbReq = {0};
   tDeserializeSVCreateTbReq(pReq, &vCreateTbReq);
-  if (metaCreateTable(pVnode->pMeta, &(vCreateTbReq)) < 0) {
+  if (metaCreateTable(pVnode->pMeta, &(vCreateTbReq), NULL) < 0) {
     // TODO
     return -1;
   }
@@ -235,6 +235,13 @@ static int vnodeProcessCreateTbReq(SVnode *pVnode, SRpcMsg *pMsg, void *pReq, SR
   SVCreateTbBatchRsp vCreateTbBatchRsp = {0};
   tDeserializeSVCreateTbBatchReq(pReq, &vCreateTbBatchReq);
   int reqNum = taosArrayGetSize(vCreateTbBatchReq.pArray);
+
+  STbDdlHandle ddlHandle = {
+      .ahandle = pVnode->pTsdb,
+      .result = NULL,
+      .fp = tsdbFetchTbUidList,
+  };
+
   for (int i = 0; i < reqNum; i++) {
     SVCreateTbReq *pCreateTbReq = taosArrayGet(vCreateTbBatchReq.pArray, i);
 
@@ -250,7 +257,7 @@ static int vnodeProcessCreateTbReq(SVnode *pVnode, SRpcMsg *pMsg, void *pReq, SR
       taosArrayPush(vCreateTbBatchRsp.rspList, &rsp);
     }
 
-    if (metaCreateTable(pVnode->pMeta, pCreateTbReq) < 0) {
+    if (metaCreateTable(pVnode->pMeta, pCreateTbReq, &ddlHandle) < 0) {
       // TODO: handle error
       vError("vgId:%d, failed to create table: %s", TD_VID(pVnode), pCreateTbReq->name);
     }
@@ -286,6 +293,8 @@ static int vnodeProcessCreateTbReq(SVnode *pVnode, SRpcMsg *pMsg, void *pReq, SR
     pRsp->contLen = contLen;
   }
 
+  tsdbUpdateTbUidList(pVnode->pTsdb, ddlHandle.result);
+
   return 0;
 }
 
diff --git a/source/libs/executor/src/executor.c b/source/libs/executor/src/executor.c
index 4863b03fb9..8f7f55eb33 100644
--- a/source/libs/executor/src/executor.c
+++ b/source/libs/executor/src/executor.c
@@ -19,7 +19,7 @@
 #include "tdatablock.h"
 #include "vnode.h"
 
-static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void* input, size_t numOfBlocks, int32_t type, char* id) {
+static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void* input, size_t numOfBlocks, int32_t type, char* id, bool converted) {
   ASSERT(pOperator != NULL);
   if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN) {
     if (pOperator->numOfDownstream == 0) {
@@ -32,7 +32,7 @@ static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void* input, size_t nu
       return TSDB_CODE_QRY_APP_ERROR;
     }
     pOperator->status = OP_NOT_OPENED;
-    return doSetStreamBlock(pOperator->pDownstream[0], input, numOfBlocks, type, id);
+    return doSetStreamBlock(pOperator->pDownstream[0], input, numOfBlocks, type, id, converted);
   } else {
     pOperator->status = OP_NOT_OPENED;
 
@@ -46,8 +46,13 @@ static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void* input, size_t nu
     }
 
     if (type == STREAM_DATA_TYPE_SUBMIT_BLOCK) {
-      if (tqReadHandleSetMsg(pInfo->readerHandle, input, 0) < 0) {
-        qError("submit msg messed up when initing stream block, %s" PRIx64, id);
+      if (converted) {
+        if (tqReadHandleSetMsgEx(pInfo->readerHandle, input, 0) < 0) {
+          qError("converted: submit msg messed up when initing stream block, %s" PRIx64, id);
+          return TSDB_CODE_QRY_APP_ERROR;
+        }
+      } else if (tqReadHandleSetMsg(pInfo->readerHandle, input, 0) < 0) {
+        qError("raw msg: submit msg messed up when initing stream block, %s" PRIx64, id);
         return TSDB_CODE_QRY_APP_ERROR;
       }
     } else {
@@ -67,11 +72,11 @@ static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void* input, size_t nu
   }
 }
 
-int32_t qSetStreamInput(qTaskInfo_t tinfo, const void* input, int32_t type) {
-  return qSetMultiStreamInput(tinfo, input, 1, type);
+int32_t qSetStreamInput(qTaskInfo_t tinfo, const void* input, int32_t type, bool converted) {
+  return qSetMultiStreamInput(tinfo, input, 1, type, converted);
 }
 
-int32_t qSetMultiStreamInput(qTaskInfo_t tinfo, const void* pBlocks, size_t numOfBlocks, int32_t type) {
+int32_t qSetMultiStreamInput(qTaskInfo_t tinfo, const void* pBlocks, size_t numOfBlocks, int32_t type, bool converted) {
   if (tinfo == NULL) {
     return TSDB_CODE_QRY_APP_ERROR;
   }
@@ -82,7 +87,7 @@ int32_t qSetMultiStreamInput(qTaskInfo_t tinfo, const void* pBlocks, size_t numO
 
   SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo;
 
-  int32_t code = doSetStreamBlock(pTaskInfo->pRoot, (void**)pBlocks, numOfBlocks, type, GET_TASKID(pTaskInfo));
+  int32_t code = doSetStreamBlock(pTaskInfo->pRoot, (void**)pBlocks, numOfBlocks, type, GET_TASKID(pTaskInfo), converted);
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed to set the stream block data", GET_TASKID(pTaskInfo));
   } else {
diff --git a/source/libs/stream/src/tstream.c b/source/libs/stream/src/tstream.c
index 8aaaa414ca..1f0c269ca1 100644
--- a/source/libs/stream/src/tstream.c
+++ b/source/libs/stream/src/tstream.c
@@ -110,7 +110,7 @@ int32_t streamExecTask(SStreamTask* pTask, SMsgCb* pMsgCb, const void* input, in
       return -1;
     }
     if (inputType == STREAM_DATA_TYPE_SUBMIT_BLOCK) {
-      qSetStreamInput(exec, input, inputType);
+      qSetStreamInput(exec, input, inputType, true);
       while (1) {
         SSDataBlock* output;
         uint64_t     ts;
@@ -128,7 +128,7 @@ int32_t streamExecTask(SStreamTask* pTask, SMsgCb* pMsgCb, const void* input, in
       /*for (int32_t i = 0; i < sz; i++) {*/
       /*SSDataBlock* pBlock = taosArrayGet(blocks, i);*/
       /*qSetStreamInput(exec, pBlock, inputType);*/
-      qSetMultiStreamInput(exec, blocks->pData, blocks->size, STREAM_DATA_TYPE_SSDATA_BLOCK);
+      qSetMultiStreamInput(exec, blocks->pData, blocks->size, STREAM_DATA_TYPE_SSDATA_BLOCK, true);
       while (1) {
         SSDataBlock* output;
         uint64_t     ts;

From fa4cb8794bf4cd3bfd16562f8f71d281cfd06e4d Mon Sep 17 00:00:00 2001
From: Cary Xu <klxu@taosdata.com>
Date: Sat, 23 Apr 2022 19:47:05 +0800
Subject: [PATCH 06/23] more logic

---
 source/dnode/vnode/src/tsdb/tsdbSma.c | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/source/dnode/vnode/src/tsdb/tsdbSma.c b/source/dnode/vnode/src/tsdb/tsdbSma.c
index 4722e27391..ddef1a649d 100644
--- a/source/dnode/vnode/src/tsdb/tsdbSma.c
+++ b/source/dnode/vnode/src/tsdb/tsdbSma.c
@@ -1877,6 +1877,14 @@ int32_t tsdbUpdateTbUidList(STsdb *pTsdb, STbUidStore *pUidStore) {
 }
 
 int32_t tsdbTriggerRSma(STsdb *pTsdb, SMeta *pMeta, const void *pMsg, int32_t inputType) {
+  SSmaEnv *pEnv = REPO_RSMA_ENV(pTsdb);
+  if (!pEnv) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  SSmaStat  *pStat = SMA_ENV_STAT(pEnv);
+  SRSmaInfo *pRSmaInfo = NULL;
+
   SArray *pResult = NULL;
 
   pResult = taosArrayInit(0, sizeof(SSDataBlock));
@@ -1885,12 +1893,6 @@ int32_t tsdbTriggerRSma(STsdb *pTsdb, SMeta *pMeta, const void *pMsg, int32_t in
     return -1;
   }
 
-  SSmaEnv   *pEnv = REPO_RSMA_ENV(pTsdb);
-  SSmaStat  *pStat = SMA_ENV_STAT(pEnv);
-  SRSmaInfo *pRSmaInfo = NULL;
-
-  TASSERT(pEnv != NULL && pStat != NULL);
-
   if (inputType == STREAM_DATA_TYPE_SUBMIT_BLOCK) {
     // pRSmaInfo = taosHashGet(pStat->rsmaInfoHash, &pReq->stbCfg.suid, sizeof(tb_uid_t));
     // if (pRSmaInfo != NULL) {

From 173abdeedd645b2131a9008556716291f730a83f Mon Sep 17 00:00:00 2001
From: Cary Xu <klxu@taosdata.com>
Date: Sun, 24 Apr 2022 21:00:05 +0800
Subject: [PATCH 07/23] refactor

---
 include/common/tmsg.h                      |  21 +-
 include/libs/executor/executor.h           |   4 +-
 source/common/src/tmsg.c                   |  81 +++-
 source/dnode/vnode/inc/vnode.h             |   1 -
 source/dnode/vnode/src/inc/tsdb.h          |   1 -
 source/dnode/vnode/src/inc/tsdbSma.h       |   3 +-
 source/dnode/vnode/src/tq/tq.c             |   6 +-
 source/dnode/vnode/src/tq/tqRead.c         |  48 +--
 source/dnode/vnode/src/tsdb/tsdbMemTable.c |  28 --
 source/dnode/vnode/src/tsdb/tsdbSma.c      | 434 ++++++++++++++-------
 source/dnode/vnode/src/vnd/vnodeSvr.c      |   6 +-
 source/dnode/vnode/test/tsdbSmaTest.cpp    |   2 +-
 source/libs/executor/src/executor.c        |  21 +-
 source/libs/stream/src/tstream.c           |   4 +-
 14 files changed, 424 insertions(+), 236 deletions(-)

diff --git a/include/common/tmsg.h b/include/common/tmsg.h
index fbfdfc1e39..e0c99e6054 100644
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@@ -227,8 +227,16 @@ typedef struct {
 } SSubmitBlkIter;
 
 typedef struct {
-  int32_t     totalLen;
-  int32_t     len;
+  int32_t totalLen;
+  int32_t len;
+  // head of SSubmitBlk
+  int64_t uid;        // table unique id
+  int64_t suid;       // stable id
+  int32_t sversion;   // data schema version
+  int32_t dataLen;    // data part length, not including the SSubmitBlk head
+  int32_t schemaLen;  // schema length, if length is 0, no schema exists
+  int16_t numOfRows;  // total number of rows in current submit block
+  // head of SSubmitBlk
   const void* pMsg;
 } SSubmitMsgIter;
 
@@ -237,6 +245,15 @@ int32_t tGetSubmitMsgNext(SSubmitMsgIter* pIter, SSubmitBlk** pPBlock);
 int32_t tInitSubmitBlkIter(SSubmitBlk* pBlock, SSubmitBlkIter* pIter);
 STSRow* tGetSubmitBlkNext(SSubmitBlkIter* pIter);
 
+// TODO: KEEP one suite of iterator API finally.
+// 1) use tInitSubmitMsgIterEx firstly as not decrease the merge conflicts
+// 2) replace tInitSubmitMsgIterEx with tInitSubmitMsgIter later
+// 3) finally, rename tInitSubmitMsgIterEx to tInitSubmitMsgIter
+int32_t tInitSubmitMsgIterEx(const SSubmitReq* pMsg, SSubmitMsgIter* pIter);
+int32_t tGetSubmitMsgNextEx(SSubmitMsgIter* pIter, SSubmitBlk** pPBlock);
+int32_t tInitSubmitBlkIterEx(SSubmitMsgIter* pMsgIter, SSubmitBlk* pBlock, SSubmitBlkIter* pIter);
+STSRow* tGetSubmitBlkNextEx(SSubmitBlkIter* pIter);
+
 typedef struct {
   int32_t index;  // index of failed block in submit blocks
   int32_t vnode;  // vnode index of failed block
diff --git a/include/libs/executor/executor.h b/include/libs/executor/executor.h
index 04f67b584f..4d289147d0 100644
--- a/include/libs/executor/executor.h
+++ b/include/libs/executor/executor.h
@@ -57,7 +57,7 @@ qTaskInfo_t qCreateStreamExecTaskInfo(void* msg, void* streamReadHandle);
  * @param type
  * @return
  */
-int32_t qSetStreamInput(qTaskInfo_t tinfo, const void* input, int32_t type, bool converted);
+int32_t qSetStreamInput(qTaskInfo_t tinfo, const void* input, int32_t type);
 
 /**
  * Set multiple input data blocks for the stream scan.
@@ -67,7 +67,7 @@ int32_t qSetStreamInput(qTaskInfo_t tinfo, const void* input, int32_t type, bool
  * @param type
  * @return
  */
-int32_t qSetMultiStreamInput(qTaskInfo_t tinfo, const void* pBlocks, size_t numOfBlocks, int32_t type, bool converted);
+int32_t qSetMultiStreamInput(qTaskInfo_t tinfo, const void* pBlocks, size_t numOfBlocks, int32_t type);
 
 /**
  * Update the table id list, add or remove.
diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c
index eb7c9a763f..14195471b6 100644
--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@@ -94,6 +94,86 @@ STSRow *tGetSubmitBlkNext(SSubmitBlkIter *pIter) {
   }
 }
 
+// TODO: KEEP one suite of iterator API finally.
+// 1) use tInitSubmitMsgIterEx firstly as not decrease the merge conflicts
+// 2) replace tInitSubmitMsgIterEx with tInitSubmitMsgIter later
+// 3) finally, rename tInitSubmitMsgIterEx to tInitSubmitMsgIter
+
+int32_t tInitSubmitMsgIterEx(const SSubmitReq *pMsg, SSubmitMsgIter *pIter) {
+  if (pMsg == NULL) {
+    terrno = TSDB_CODE_TDB_SUBMIT_MSG_MSSED_UP;
+    return -1;
+  }
+
+  pIter->totalLen = htonl(pMsg->length);
+  ASSERT(pIter->totalLen > 0);
+  pIter->len = 0;
+  pIter->pMsg = pMsg;
+  if (pIter->totalLen <= sizeof(SSubmitReq)) {
+    terrno = TSDB_CODE_TDB_SUBMIT_MSG_MSSED_UP;
+    return -1;
+  }
+
+  return 0;
+}
+
+int32_t tGetSubmitMsgNextEx(SSubmitMsgIter *pIter, SSubmitBlk **pPBlock) {
+  ASSERT(pIter->len >= 0);
+
+  if (pIter->len == 0) {
+    pIter->len += sizeof(SSubmitReq);
+  } else {
+    if (pIter->len >= pIter->totalLen) {
+      ASSERT(0);
+    }
+
+    SSubmitBlk *pSubmitBlk = (SSubmitBlk *)POINTER_SHIFT(pIter->pMsg, pIter->len);
+    pIter->len += (sizeof(SSubmitBlk) + pIter->dataLen + pIter->schemaLen);
+    ASSERT(pIter->len > 0);
+  }
+
+  if (pIter->len > pIter->totalLen) {
+    terrno = TSDB_CODE_TDB_SUBMIT_MSG_MSSED_UP;
+    *pPBlock = NULL;
+    return -1;
+  }
+
+  if (pIter->len == pIter->totalLen) {
+    *pPBlock = NULL;
+  } else {
+    *pPBlock = (SSubmitBlk *)POINTER_SHIFT(pIter->pMsg, pIter->len);
+    pIter->uid = htobe64((*pPBlock)->uid);
+    pIter->suid = htobe64((*pPBlock)->suid);
+    pIter->sversion = htonl((*pPBlock)->sversion);
+    pIter->dataLen = htonl((*pPBlock)->dataLen);
+    pIter->schemaLen = htonl((*pPBlock)->schemaLen);
+    pIter->numOfRows = htons((*pPBlock)->numOfRows);
+  }
+  return 0;
+}
+
+int32_t tInitSubmitBlkIterEx(SSubmitMsgIter *pMsgIter, SSubmitBlk *pBlock, SSubmitBlkIter *pIter) {
+  if (pMsgIter->dataLen <= 0) return -1;
+  pIter->totalLen = pMsgIter->dataLen;
+  pIter->len = 0;
+  pIter->row = (STSRow *)(pBlock->data + pMsgIter->schemaLen);
+  return 0;
+}
+
+STSRow *tGetSubmitBlkNextEx(SSubmitBlkIter *pIter) {
+  STSRow *row = pIter->row;
+
+  if (pIter->len >= pIter->totalLen) {
+    return NULL;
+  } else {
+    pIter->len += TD_ROW_LEN(row);
+    if (pIter->len < pIter->totalLen) {
+      pIter->row = POINTER_SHIFT(row, TD_ROW_LEN(row));
+    }
+    return row;
+  }
+}
+
 int32_t tEncodeSEpSet(SCoder *pEncoder, const SEpSet *pEp) {
   if (tEncodeI8(pEncoder, pEp->inUse) < 0) return -1;
   if (tEncodeI8(pEncoder, pEp->numOfEps) < 0) return -1;
@@ -126,7 +206,6 @@ int32_t tDecodeSQueryNodeAddr(SCoder *pDecoder, SQueryNodeAddr *pAddr) {
   return 0;
 }
 
-
 int32_t taosEncodeSEpSet(void **buf, const SEpSet *pEp) {
   int32_t tlen = 0;
   tlen += taosEncodeFixedI8(buf, pEp->inUse);
diff --git a/source/dnode/vnode/inc/vnode.h b/source/dnode/vnode/inc/vnode.h
index 76e56bcfa2..f4975c183e 100644
--- a/source/dnode/vnode/inc/vnode.h
+++ b/source/dnode/vnode/inc/vnode.h
@@ -112,7 +112,6 @@ void    tqReadHandleSetColIdList(STqReadHandle *pReadHandle, SArray *pColIdList)
 int     tqReadHandleSetTbUidList(STqReadHandle *pHandle, const SArray *tbUidList);
 int     tqReadHandleAddTbUidList(STqReadHandle *pHandle, const SArray *tbUidList);
 int32_t tqReadHandleSetMsg(STqReadHandle *pHandle, SSubmitReq *pMsg, int64_t ver);
-int32_t tqReadHandleSetMsgEx(STqReadHandle *pHandle, SSubmitReq *pMsg, int64_t ver);
 bool    tqNextDataBlock(STqReadHandle *pHandle);
 int32_t tqRetrieveDataBlock(SArray **ppCols, STqReadHandle *pHandle, uint64_t *pGroupId, int32_t *pNumOfRows,
                             int16_t *pNumOfCols);
diff --git a/source/dnode/vnode/src/inc/tsdb.h b/source/dnode/vnode/src/inc/tsdb.h
index a84776abfd..8cfbffc962 100644
--- a/source/dnode/vnode/src/inc/tsdb.h
+++ b/source/dnode/vnode/src/inc/tsdb.h
@@ -56,7 +56,6 @@ int32_t tsdbInsertTSmaData(STsdb *pTsdb, int64_t indexUid, const char *msg);
 int32_t tsdbDropTSmaData(STsdb *pTsdb, int64_t indexUid);
 int32_t tsdbInsertRSmaData(STsdb *pTsdb, char *msg);
 void    tsdbCleanupReadHandle(tsdbReaderT queryHandle);
-int32_t tdScanAndConvertSubmitMsg(SSubmitReq *pMsg);
 
 typedef enum {
   TSDB_FILE_HEAD = 0,  // .head
diff --git a/source/dnode/vnode/src/inc/tsdbSma.h b/source/dnode/vnode/src/inc/tsdbSma.h
index 28d1a6e9a0..3a865ddc51 100644
--- a/source/dnode/vnode/src/inc/tsdbSma.h
+++ b/source/dnode/vnode/src/inc/tsdbSma.h
@@ -48,7 +48,8 @@ static FORCE_INLINE int32_t tsdbUidStoreInit(STbUidStore **pStore) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t tsdbUidStorePut(STbUidStore *pStore, tb_uid_t suid, tb_uid_t uid);
+int32_t tsdbUidStorePut(STbUidStore *pStore, tb_uid_t suid, tb_uid_t *uid);
+void    tsdbUidStoreDestory(STbUidStore *pStore);
 void   *tsdbUidStoreFree(STbUidStore *pStore);
 
 int32_t tsdbRegisterRSma(STsdb *pTsdb, SMeta *pMeta, SVCreateTbReq *pReq);
diff --git a/source/dnode/vnode/src/tq/tq.c b/source/dnode/vnode/src/tq/tq.c
index f933c6e8de..0b3feb5010 100644
--- a/source/dnode/vnode/src/tq/tq.c
+++ b/source/dnode/vnode/src/tq/tq.c
@@ -83,7 +83,7 @@ int32_t tqPushMsgNew(STQ* pTq, void* msg, int32_t msgLen, tmsg_t msgType, int64_
     if (pExec->subType == TOPIC_SUB_TYPE__TABLE) {
       qTaskInfo_t task = pExec->task[workerId];
       ASSERT(task);
-      qSetStreamInput(task, pReq, STREAM_DATA_TYPE_SUBMIT_BLOCK, false);
+      qSetStreamInput(task, pReq, STREAM_DATA_TYPE_SUBMIT_BLOCK);
       while (1) {
         SSDataBlock* pDataBlock = NULL;
         uint64_t     ts = 0;
@@ -454,7 +454,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
       if (pExec->subType == TOPIC_SUB_TYPE__TABLE) {
         qTaskInfo_t task = pExec->task[workerId];
         ASSERT(task);
-        qSetStreamInput(task, pCont, STREAM_DATA_TYPE_SUBMIT_BLOCK, false);
+        qSetStreamInput(task, pCont, STREAM_DATA_TYPE_SUBMIT_BLOCK);
         while (1) {
           SSDataBlock* pDataBlock = NULL;
           uint64_t     ts = 0;
@@ -648,7 +648,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
       SSubmitReq* pCont = (SSubmitReq*)&pHead->body;
       qTaskInfo_t task = pTopic->buffer.output[workerId].task;
       ASSERT(task);
-      qSetStreamInput(task, pCont, STREAM_DATA_TYPE_SUBMIT_BLOCK, false);
+      qSetStreamInput(task, pCont, STREAM_DATA_TYPE_SUBMIT_BLOCK);
       SArray* pRes = taosArrayInit(0, sizeof(SSDataBlock));
       while (1) {
         SSDataBlock* pDataBlock = NULL;
diff --git a/source/dnode/vnode/src/tq/tqRead.c b/source/dnode/vnode/src/tq/tqRead.c
index dfc3fba1b4..ada2460d97 100644
--- a/source/dnode/vnode/src/tq/tqRead.c
+++ b/source/dnode/vnode/src/tq/tqRead.c
@@ -33,40 +33,15 @@ STqReadHandle* tqInitSubmitMsgScanner(SMeta* pMeta) {
 
 int32_t tqReadHandleSetMsg(STqReadHandle* pReadHandle, SSubmitReq* pMsg, int64_t ver) {
   pReadHandle->pMsg = pMsg;
-  pMsg->length = htonl(pMsg->length);
-  pMsg->numOfBlocks = htonl(pMsg->numOfBlocks);
-
-  // iterate and convert
-  if (tInitSubmitMsgIter(pMsg, &pReadHandle->msgIter) < 0) return -1;
-  while (true) {
-    if (tGetSubmitMsgNext(&pReadHandle->msgIter, &pReadHandle->pBlock) < 0) return -1;
-    if (pReadHandle->pBlock == NULL) break;
-
-    pReadHandle->pBlock->uid = htobe64(pReadHandle->pBlock->uid);
-    pReadHandle->pBlock->suid = htobe64(pReadHandle->pBlock->suid);
-    pReadHandle->pBlock->sversion = htonl(pReadHandle->pBlock->sversion);
-    pReadHandle->pBlock->dataLen = htonl(pReadHandle->pBlock->dataLen);
-    pReadHandle->pBlock->schemaLen = htonl(pReadHandle->pBlock->schemaLen);
-    pReadHandle->pBlock->numOfRows = htons(pReadHandle->pBlock->numOfRows);
-  }
-
-  if (tInitSubmitMsgIter(pMsg, &pReadHandle->msgIter) < 0) return -1;
-  pReadHandle->ver = ver;
-  memset(&pReadHandle->blkIter, 0, sizeof(SSubmitBlkIter));
-  return 0;
-}
-
-int32_t tqReadHandleSetMsgEx(STqReadHandle* pReadHandle, SSubmitReq* pMsg, int64_t ver) {
-  pReadHandle->pMsg = pMsg;
 
   // iterate
-  if (tInitSubmitMsgIter(pMsg, &pReadHandle->msgIter) < 0) return -1;
+  if (tInitSubmitMsgIterEx(pMsg, &pReadHandle->msgIter) < 0) return -1;
   while (true) {
-    if (tGetSubmitMsgNext(&pReadHandle->msgIter, &pReadHandle->pBlock) < 0) return -1;
+    if (tGetSubmitMsgNextEx(&pReadHandle->msgIter, &pReadHandle->pBlock) < 0) return -1;
     if (pReadHandle->pBlock == NULL) break;
   }
 
-  if (tInitSubmitMsgIter(pMsg, &pReadHandle->msgIter) < 0) return -1;
+  if (tInitSubmitMsgIterEx(pMsg, &pReadHandle->msgIter) < 0) return -1;
   pReadHandle->ver = ver;
   memset(&pReadHandle->blkIter, 0, sizeof(SSubmitBlkIter));
   return 0;
@@ -74,7 +49,7 @@ int32_t tqReadHandleSetMsgEx(STqReadHandle* pReadHandle, SSubmitReq* pMsg, int64
 
 bool tqNextDataBlock(STqReadHandle* pHandle) {
   while (1) {
-    if (tGetSubmitMsgNext(&pHandle->msgIter, &pHandle->pBlock) < 0) {
+    if (tGetSubmitMsgNextEx(&pHandle->msgIter, &pHandle->pBlock) < 0) {
       return false;
     }
     if (pHandle->pBlock == NULL) return false;
@@ -82,7 +57,8 @@ bool tqNextDataBlock(STqReadHandle* pHandle) {
     /*pHandle->pBlock->uid = htobe64(pHandle->pBlock->uid);*/
     /*if (pHandle->tbUid == pHandle->pBlock->uid) {*/
     ASSERT(pHandle->tbIdHash);
-    void* ret = taosHashGet(pHandle->tbIdHash, &pHandle->pBlock->uid, sizeof(int64_t));
+    // void* ret = taosHashGet(pHandle->tbIdHash, &pHandle->pBlock->uid, sizeof(int64_t));
+    void* ret = taosHashGet(pHandle->tbIdHash, &pHandle->msgIter.uid, sizeof(int64_t));
     if (ret != NULL) {
       /*printf("retrieve one tb %ld\n", pHandle->pBlock->uid);*/
       /*pHandle->pBlock->tid = htonl(pHandle->pBlock->tid);*/
@@ -104,14 +80,14 @@ int32_t tqRetrieveDataBlock(SArray** ppCols, STqReadHandle* pHandle, uint64_t* p
   // TODO set to real sversion
   int32_t sversion = 0;
   if (pHandle->sver != sversion) {
-    pHandle->pSchema = metaGetTbTSchema(pHandle->pVnodeMeta, pHandle->pBlock->uid, sversion);
+    pHandle->pSchema = metaGetTbTSchema(pHandle->pVnodeMeta, pHandle->msgIter.uid, sversion);
 
     tb_uid_t quid;
-    STbCfg*  pTbCfg = metaGetTbInfoByUid(pHandle->pVnodeMeta, pHandle->pBlock->uid);
+    STbCfg*  pTbCfg = metaGetTbInfoByUid(pHandle->pVnodeMeta, pHandle->msgIter.uid);
     if (pTbCfg->type == META_CHILD_TABLE) {
       quid = pTbCfg->ctbCfg.suid;
     } else {
-      quid = pHandle->pBlock->uid;
+      quid = pHandle->msgIter.uid;
     }
     pHandle->pSchemaWrapper = metaGetTableSchema(pHandle->pVnodeMeta, quid, sversion, true);
     pHandle->sver = sversion;
@@ -120,7 +96,7 @@ int32_t tqRetrieveDataBlock(SArray** ppCols, STqReadHandle* pHandle, uint64_t* p
   STSchema*       pTschema = pHandle->pSchema;
   SSchemaWrapper* pSchemaWrapper = pHandle->pSchemaWrapper;
 
-  *pNumOfRows = pHandle->pBlock->numOfRows;
+  *pNumOfRows = pHandle->msgIter.numOfRows;
   int32_t colNumNeed = taosArrayGetSize(pHandle->pColIdList);
 
   if (colNumNeed > pSchemaWrapper->nCols) {
@@ -167,8 +143,8 @@ int32_t tqRetrieveDataBlock(SArray** ppCols, STqReadHandle* pHandle, uint64_t* p
   tdSTSRowIterInit(&iter, pTschema);
   STSRow* row;
   int32_t curRow = 0;
-  tInitSubmitBlkIter(pHandle->pBlock, &pHandle->blkIter);
-  while ((row = tGetSubmitBlkNext(&pHandle->blkIter)) != NULL) {
+  tInitSubmitBlkIterEx(&pHandle->msgIter, pHandle->pBlock, &pHandle->blkIter);
+  while ((row = tGetSubmitBlkNextEx(&pHandle->blkIter)) != NULL) {
     tdSTSRowIterReset(&iter, row);
     // get all wanted col of that block
     for (int32_t i = 0; i < colActual; i++) {
diff --git a/source/dnode/vnode/src/tsdb/tsdbMemTable.c b/source/dnode/vnode/src/tsdb/tsdbMemTable.c
index bea2b66af8..3082ee6f2b 100644
--- a/source/dnode/vnode/src/tsdb/tsdbMemTable.c
+++ b/source/dnode/vnode/src/tsdb/tsdbMemTable.c
@@ -227,34 +227,6 @@ int tsdbLoadDataFromCache(STable *pTable, SSkipListIterator *pIter, TSKEY maxKey
   return 0;
 }
 
-int32_t tdScanAndConvertSubmitMsg(SSubmitReq *pMsg) {
-  ASSERT(pMsg != NULL);
-  SSubmitMsgIter msgIter = {0};
-  SSubmitBlk    *pBlock = NULL;
-  SSubmitBlkIter blkIter = {0};
-  STSRow        *row = NULL;
-
-  terrno = TSDB_CODE_SUCCESS;
-  pMsg->length = htonl(pMsg->length);
-  pMsg->numOfBlocks = htonl(pMsg->numOfBlocks);
-
-  if (tInitSubmitMsgIter(pMsg, &msgIter) < 0) return -1;
-  while (true) {
-    if (tGetSubmitMsgNext(&msgIter, &pBlock) < 0) return -1;
-    if (pBlock == NULL) break;
-
-    pBlock->uid = htobe64(pBlock->uid);
-    pBlock->suid = htobe64(pBlock->suid);
-    pBlock->sversion = htonl(pBlock->sversion);
-    pBlock->dataLen = htonl(pBlock->dataLen);
-    pBlock->schemaLen = htonl(pBlock->schemaLen);
-    pBlock->numOfRows = htons(pBlock->numOfRows);
-  }
-
-  if (terrno != TSDB_CODE_SUCCESS) return -1;
-  return 0;
-}
-
 static int tsdbScanAndConvertSubmitMsg(STsdb *pTsdb, SSubmitReq *pMsg) {
   ASSERT(pMsg != NULL);
   // STsdbMeta *    pMeta = pTsdb->tsdbMeta;
diff --git a/source/dnode/vnode/src/tsdb/tsdbSma.c b/source/dnode/vnode/src/tsdb/tsdbSma.c
index ddef1a649d..9c2daaa6d7 100644
--- a/source/dnode/vnode/src/tsdb/tsdbSma.c
+++ b/source/dnode/vnode/src/tsdb/tsdbSma.c
@@ -95,6 +95,7 @@ typedef struct {
    *    - TSDB_SMA_STAT_EXPIRED: 1) If sma calculation of history TS data is not finished; 2) Or if the TSDB is open,
    * without information about its previous state.
    *    - TSDB_SMA_STAT_DROPPED: 1)sma dropped
+   * N.B. only applicable to tsma
    */
   int8_t    state;           // ETsdbSmaStat
   SHashObj *expiredWindows;  // key: skey of time window, value: N/A
@@ -112,8 +113,6 @@ struct SSmaStat {
     SHashObj *smaStatItems;  // key: indexUid, value: SSmaStatItem for tsma
     SHashObj *rsmaInfoHash;  // key: stbUid, value: SRSmaInfo;
   };
-  SRSmaInfo rsmaInfo;
-
   T_REF_DECLARE()
 };
 #define SMA_STAT_ITEMS(s)     ((s)->smaStatItems)
@@ -173,6 +172,7 @@ static void    tsdbGetSmaDir(int32_t vgId, ETsdbSmaType smaType, char dirName[])
 static int32_t tsdbInsertTSmaDataImpl(STsdb *pTsdb, int64_t indexUid, const char *msg);
 static int32_t tsdbInsertRSmaDataImpl(STsdb *pTsdb, const char *msg);
 
+static FORCE_INLINE int32_t tsdbUpdateTbUidListImpl(STsdb *pTsdb, tb_uid_t *suid, SArray *tbUids);
 // mgmt interface
 static int32_t tsdbDropTSmaDataImpl(STsdb *pTsdb, int64_t indexUid);
 
@@ -263,7 +263,7 @@ static void *poolMalloc(void *arg, size_t size) {
   SPoolMem *pMem;
 
   pMem = (SPoolMem *)tdbOsMalloc(sizeof(*pMem) + size);
-  if (pMem == NULL) {
+  if (!pMem) {
     assert(0);
   }
 
@@ -355,7 +355,7 @@ static SSmaEnv *tsdbNewSmaEnv(const STsdb *pTsdb, int8_t smaType, const char *pa
   SSmaEnv *pEnv = NULL;
 
   pEnv = (SSmaEnv *)taosMemoryCalloc(1, sizeof(SSmaEnv));
-  if (pEnv == NULL) {
+  if (!pEnv) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
   }
@@ -371,7 +371,7 @@ static SSmaEnv *tsdbNewSmaEnv(const STsdb *pTsdb, int8_t smaType, const char *pa
 
   ASSERT(path && (strlen(path) > 0));
   SMA_ENV_PATH(pEnv) = strdup(path);
-  if (SMA_ENV_PATH(pEnv) == NULL) {
+  if (!SMA_ENV_PATH(pEnv)) {
     tsdbFreeSmaEnv(pEnv);
     return NULL;
   }
@@ -390,7 +390,7 @@ static SSmaEnv *tsdbNewSmaEnv(const STsdb *pTsdb, int8_t smaType, const char *pa
     return NULL;
   }
 
-  if ((pEnv->pPool = openPool()) == NULL) {
+  if (!(pEnv->pPool = openPool())) {
     tsdbFreeSmaEnv(pEnv);
     return NULL;
   }
@@ -404,8 +404,8 @@ static int32_t tsdbInitSmaEnv(STsdb *pTsdb, int8_t smaType, const char *path, SD
     return TSDB_CODE_FAILED;
   }
 
-  if (*pEnv == NULL) {
-    if ((*pEnv = tsdbNewSmaEnv(pTsdb, smaType, path, did)) == NULL) {
+  if (!(*pEnv)) {
+    if (!(*pEnv = tsdbNewSmaEnv(pTsdb, smaType, path, did))) {
       return TSDB_CODE_FAILED;
     }
   }
@@ -437,7 +437,7 @@ void *tsdbFreeSmaEnv(SSmaEnv *pSmaEnv) {
 }
 
 static int32_t tsdbRefSmaStat(STsdb *pTsdb, SSmaStat *pStat) {
-  if (pStat == NULL) return 0;
+  if (!pStat) return 0;
 
   int ref = T_REF_INC(pStat);
   tsdbDebug("vgId:%d ref sma stat:%p, val:%d", REPO_ID(pTsdb), pStat, ref);
@@ -445,7 +445,7 @@ static int32_t tsdbRefSmaStat(STsdb *pTsdb, SSmaStat *pStat) {
 }
 
 static int32_t tsdbUnRefSmaStat(STsdb *pTsdb, SSmaStat *pStat) {
-  if (pStat == NULL) return 0;
+  if (!pStat) return 0;
 
   int ref = T_REF_DEC(pStat);
   tsdbDebug("vgId:%d unref sma stat:%p, val:%d", REPO_ID(pTsdb), pStat, ref);
@@ -455,7 +455,7 @@ static int32_t tsdbUnRefSmaStat(STsdb *pTsdb, SSmaStat *pStat) {
 static int32_t tsdbInitSmaStat(SSmaStat **pSmaStat, int8_t smaType) {
   ASSERT(pSmaStat != NULL);
 
-  if (*pSmaStat != NULL) {  // no lock
+  if (*pSmaStat) {  // no lock
     return TSDB_CODE_SUCCESS;
   }
 
@@ -464,9 +464,9 @@ static int32_t tsdbInitSmaStat(SSmaStat **pSmaStat, int8_t smaType) {
    *  2. Currently, there is mutex lock when init SSmaEnv, thus no need add lock on SSmaStat, and please add lock if
    * tsdbInitSmaStat invoked in other multithread environment later.
    */
-  if (*pSmaStat == NULL) {
+  if (!(*pSmaStat)) {
     *pSmaStat = (SSmaStat *)taosMemoryCalloc(1, sizeof(SSmaStat));
-    if (*pSmaStat == NULL) {
+    if (!(*pSmaStat)) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       return TSDB_CODE_FAILED;
     }
@@ -475,7 +475,7 @@ static int32_t tsdbInitSmaStat(SSmaStat **pSmaStat, int8_t smaType) {
       SMA_STAT_INFO_HASH(*pSmaStat) = taosHashInit(
           RSMA_TASK_INFO_HASH_SLOT, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_ENTRY_LOCK);
 
-      if (SMA_STAT_INFO_HASH(*pSmaStat) == NULL) {
+      if (!SMA_STAT_INFO_HASH(*pSmaStat)) {
         taosMemoryFreeClear(*pSmaStat);
         return TSDB_CODE_FAILED;
       }
@@ -483,7 +483,7 @@ static int32_t tsdbInitSmaStat(SSmaStat **pSmaStat, int8_t smaType) {
       SMA_STAT_ITEMS(*pSmaStat) =
           taosHashInit(SMA_STATE_HASH_SLOT, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
 
-      if (SMA_STAT_ITEMS(*pSmaStat) == NULL) {
+      if (!SMA_STAT_ITEMS(*pSmaStat)) {
         taosMemoryFreeClear(*pSmaStat);
         return TSDB_CODE_FAILED;
       }
@@ -510,7 +510,7 @@ static SSmaStatItem *tsdbNewSmaStatItem(int8_t state) {
 }
 
 static void *tsdbFreeSmaStatItem(SSmaStatItem *pSmaStatItem) {
-  if (pSmaStatItem != NULL) {
+  if (pSmaStatItem) {
     tdDestroyTSma(pSmaStatItem->pSma);
     taosMemoryFreeClear(pSmaStatItem->pSma);
     taosHashCleanup(pSmaStatItem->expiredWindows);
@@ -530,7 +530,7 @@ int32_t tsdbDestroySmaState(SSmaStat *pSmaStat, int8_t smaType) {
     // TODO: use taosHashSetFreeFp when taosHashSetFreeFp is ready.
     if (smaType == TSDB_SMA_TYPE_TIME_RANGE) {
       void *item = taosHashIterate(SMA_STAT_ITEMS(pSmaStat), NULL);
-      while (item != NULL) {
+      while (item) {
         SSmaStatItem *pItem = *(SSmaStatItem **)item;
         tsdbFreeSmaStatItem(pItem);
         item = taosHashIterate(SMA_STAT_ITEMS(pSmaStat), item);
@@ -538,7 +538,7 @@ int32_t tsdbDestroySmaState(SSmaStat *pSmaStat, int8_t smaType) {
       taosHashCleanup(SMA_STAT_ITEMS(pSmaStat));
     } else if (smaType == TSDB_SMA_TYPE_ROLLUP) {
       void *infoHash = taosHashIterate(SMA_STAT_INFO_HASH(pSmaStat), NULL);
-      while (infoHash != NULL) {
+      while (infoHash) {
         SRSmaInfo *pInfoHash = *(SRSmaInfo **)infoHash;
         tsdbFreeRSmaInfo(pInfoHash);
         infoHash = taosHashIterate(SMA_STAT_INFO_HASH(pSmaStat), infoHash);
@@ -557,12 +557,12 @@ static int32_t tsdbCheckAndInitSmaEnv(STsdb *pTsdb, int8_t smaType) {
   // return if already init
   switch (smaType) {
     case TSDB_SMA_TYPE_TIME_RANGE:
-      if ((pEnv = (SSmaEnv *)atomic_load_ptr(&REPO_TSMA_ENV(pTsdb))) != NULL) {
+      if ((pEnv = (SSmaEnv *)atomic_load_ptr(&REPO_TSMA_ENV(pTsdb)))) {
         return TSDB_CODE_SUCCESS;
       }
       break;
     case TSDB_SMA_TYPE_ROLLUP:
-      if ((pEnv = (SSmaEnv *)atomic_load_ptr(&REPO_RSMA_ENV(pTsdb))) != NULL) {
+      if ((pEnv = (SSmaEnv *)atomic_load_ptr(&REPO_RSMA_ENV(pTsdb)))) {
         return TSDB_CODE_SUCCESS;
       }
       break;
@@ -575,7 +575,7 @@ static int32_t tsdbCheckAndInitSmaEnv(STsdb *pTsdb, int8_t smaType) {
   tsdbLockRepo(pTsdb);
   pEnv = (smaType == TSDB_SMA_TYPE_TIME_RANGE) ? atomic_load_ptr(&REPO_TSMA_ENV(pTsdb))
                                                : atomic_load_ptr(&REPO_RSMA_ENV(pTsdb));
-  if (pEnv == NULL) {
+  if (!pEnv) {
     char rname[TSDB_FILENAME_LEN] = {0};
 
     SDiskID did = {0};
@@ -607,10 +607,10 @@ static int32_t tsdbCheckAndInitSmaEnv(STsdb *pTsdb, int8_t smaType) {
 static int32_t tsdbSetExpiredWindow(STsdb *pTsdb, SHashObj *pItemsHash, int64_t indexUid, int64_t winSKey,
                                     int64_t version) {
   SSmaStatItem *pItem = taosHashGet(pItemsHash, &indexUid, sizeof(indexUid));
-  if (pItem == NULL) {
+  if (!pItem) {
     // TODO: use TSDB_SMA_STAT_EXPIRED and update by stream computing later
     pItem = tsdbNewSmaStatItem(TSDB_SMA_STAT_OK);  // TODO use the real state
-    if (pItem == NULL) {
+    if (!pItem) {
       // Response to stream computing: OOM
       // For query, if the indexUid not found, the TSDB should tell query module to query raw TS data.
       return TSDB_CODE_FAILED;
@@ -618,7 +618,7 @@ static int32_t tsdbSetExpiredWindow(STsdb *pTsdb, SHashObj *pItemsHash, int64_t
 
     // cache smaMeta
     STSma *pSma = metaGetSmaInfoByIndex(REPO_META(pTsdb), indexUid, true);
-    if (pSma == NULL) {
+    if (!pSma) {
       terrno = TSDB_CODE_TDB_NO_SMA_INDEX_IN_META;
       taosHashCleanup(pItem->expiredWindows);
       taosMemoryFree(pItem);
@@ -634,7 +634,7 @@ static int32_t tsdbSetExpiredWindow(STsdb *pTsdb, SHashObj *pItemsHash, int64_t
       taosMemoryFree(pItem);
       return TSDB_CODE_FAILED;
     }
-  } else if ((pItem = *(SSmaStatItem **)pItem) == NULL) {
+  } else if (!(pItem = *(SSmaStatItem **)pItem)) {
     terrno = TSDB_CODE_INVALID_PTR;
     return TSDB_CODE_FAILED;
   }
@@ -678,9 +678,9 @@ int32_t tsdbUpdateExpiredWindowImpl(STsdb *pTsdb, SSubmitReq *pMsg, int64_t vers
     return TSDB_CODE_FAILED;
   }
 
-  if (tdScanAndConvertSubmitMsg(pMsg) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_FAILED;
-  }
+  // if (tdScanAndConvertSubmitMsg(pMsg) != TSDB_CODE_SUCCESS) {
+  //   return TSDB_CODE_FAILED;
+  // }
 
   if (tsdbCheckAndInitSmaEnv(pTsdb, TSDB_SMA_TYPE_TIME_RANGE) != TSDB_CODE_SUCCESS) {
     terrno = TSDB_CODE_TDB_INIT_FAILED;
@@ -694,7 +694,7 @@ int32_t tsdbUpdateExpiredWindowImpl(STsdb *pTsdb, SSubmitReq *pMsg, int64_t vers
   SSmaStat *pStat = SMA_ENV_STAT(pEnv);
   SHashObj *pItemsHash = SMA_ENV_STAT_ITEMS(pEnv);
 
-  TASSERT(pEnv != NULL && pStat != NULL && pItemsHash != NULL);
+  TASSERT(pEnv && pStat && pItemsHash);
 
   // basic procedure
   // TODO: optimization
@@ -705,26 +705,26 @@ int32_t tsdbUpdateExpiredWindowImpl(STsdb *pTsdb, SSubmitReq *pMsg, int64_t vers
   SInterval      interval = {0};
   TSKEY          lastWinSKey = INT64_MIN;
 
-  if (tInitSubmitMsgIter(pMsg, &msgIter) != TSDB_CODE_SUCCESS) {
+  if (tInitSubmitMsgIterEx(pMsg, &msgIter) != TSDB_CODE_SUCCESS) {
     return TSDB_CODE_FAILED;
   }
 
   while (true) {
-    tGetSubmitMsgNext(&msgIter, &pBlock);
-    if (pBlock == NULL) break;
+    tGetSubmitMsgNextEx(&msgIter, &pBlock);
+    if (!pBlock) break;
 
     STSmaWrapper *pSW = NULL;
     STSma        *pTSma = NULL;
 
     SSubmitBlkIter blkIter = {0};
-    if (tInitSubmitBlkIter(pBlock, &blkIter) != TSDB_CODE_SUCCESS) {
+    if (tInitSubmitBlkIterEx(&msgIter, pBlock, &blkIter) != TSDB_CODE_SUCCESS) {
       pSW = tdFreeTSmaWrapper(pSW);
       break;
     }
 
     while (true) {
-      STSRow *row = tGetSubmitBlkNext(&blkIter);
-      if (row == NULL) {
+      STSRow *row = tGetSubmitBlkNextEx(&blkIter);
+      if (!row) {
         tdFreeTSmaWrapper(pSW);
         break;
       }
@@ -732,10 +732,10 @@ int32_t tsdbUpdateExpiredWindowImpl(STsdb *pTsdb, SSubmitReq *pMsg, int64_t vers
         if (pSW) {
           pSW = tdFreeTSmaWrapper(pSW);
         }
-        if ((pSW = metaGetSmaInfoByTable(REPO_META(pTsdb), pBlock->suid)) == NULL) {
+        if (!(pSW = metaGetSmaInfoByTable(REPO_META(pTsdb), pBlock->suid))) {
           break;
         }
-        if ((pSW->number) <= 0 || (pSW->tSma == NULL)) {
+        if ((pSW->number) <= 0 || !pSW->tSma) {
           pSW = tdFreeTSmaWrapper(pSW);
           break;
         }
@@ -781,10 +781,10 @@ static int32_t tsdbResetExpiredWindow(STsdb *pTsdb, SSmaStat *pStat, int64_t ind
 
   tsdbRefSmaStat(pTsdb, pStat);
 
-  if (pStat && pStat->smaStatItems) {
-    pItem = taosHashGet(pStat->smaStatItems, &indexUid, sizeof(indexUid));
+  if (pStat && SMA_STAT_ITEMS(pStat)) {
+    pItem = taosHashGet(SMA_STAT_ITEMS(pStat), &indexUid, sizeof(indexUid));
   }
-  if ((pItem != NULL) && ((pItem = *(SSmaStatItem **)pItem) != NULL)) {
+  if ((pItem) && ((pItem = *(SSmaStatItem **)pItem))) {
     // pItem resides in hash buffer all the time unless drop sma index
     // TODO: multithread protect
     if (taosHashRemove(pItem->expiredWindows, &skey, sizeof(TSKEY)) != 0) {
@@ -994,7 +994,7 @@ static void tsdbDestroyTSmaWriteH(STSmaWriteH *pSmaH) {
 
 static int32_t tsdbSetTSmaDataFile(STSmaWriteH *pSmaH, int64_t indexUid, int32_t fid) {
   STsdb *pTsdb = pSmaH->pTsdb;
-  ASSERT(pSmaH->dFile.path == NULL && pSmaH->dFile.pDB == NULL);
+  ASSERT(!pSmaH->dFile.path && !pSmaH->dFile.pDB);
 
   pSmaH->dFile.fid = fid;
   char tSmaFile[TSDB_FILENAME_LEN] = {0};
@@ -1064,6 +1064,8 @@ static int32_t tsdbInsertTSmaDataImpl(STsdb *pTsdb, int64_t indexUid, const char
   STsdbCfg     *pCfg = REPO_CFG(pTsdb);
   const SArray *pDataBlocks = (const SArray *)msg;
 
+  // TODO: destroy SSDataBlocks(msg)
+
   // For super table aggregation, the sma data is stored in vgroup calculated from the hash value of stable name. Thus
   // the sma data would arrive ahead of the update-expired-window msg.
   if (tsdbCheckAndInitSmaEnv(pTsdb, TSDB_SMA_TYPE_TIME_RANGE) != TSDB_CODE_SUCCESS) {
@@ -1071,7 +1073,7 @@ static int32_t tsdbInsertTSmaDataImpl(STsdb *pTsdb, int64_t indexUid, const char
     return TSDB_CODE_FAILED;
   }
 
-  if (pDataBlocks == NULL) {
+  if (!pDataBlocks) {
     terrno = TSDB_CODE_INVALID_PTR;
     tsdbWarn("vgId:%d insert tSma data failed since pDataBlocks is NULL", REPO_ID(pTsdb));
     return terrno;
@@ -1089,11 +1091,11 @@ static int32_t tsdbInsertTSmaDataImpl(STsdb *pTsdb, int64_t indexUid, const char
 
   tsdbRefSmaStat(pTsdb, pStat);
 
-  if (pStat && pStat->smaStatItems) {
-    pItem = taosHashGet(pStat->smaStatItems, &indexUid, sizeof(indexUid));
+  if (pStat && SMA_STAT_ITEMS(pStat)) {
+    pItem = taosHashGet(SMA_STAT_ITEMS(pStat), &indexUid, sizeof(indexUid));
   }
 
-  if ((pItem == NULL) || ((pItem = *(SSmaStatItem **)pItem) == NULL) || tsdbSmaStatIsDropped(pItem)) {
+  if (!pItem || !(pItem = *(SSmaStatItem **)pItem) || tsdbSmaStatIsDropped(pItem)) {
     terrno = TSDB_CODE_TDB_INVALID_SMA_STAT;
     tsdbUnRefSmaStat(pTsdb, pStat);
     return TSDB_CODE_FAILED;
@@ -1287,7 +1289,7 @@ static int32_t tsdbDropTSmaDataImpl(STsdb *pTsdb, int64_t indexUid) {
     tsdbDebug("vgId:%d drop tSma local cache for %" PRIi64, REPO_ID(pTsdb), indexUid);
 
     SSmaStatItem *pItem = taosHashGet(SMA_ENV_STAT_ITEMS(pEnv), &indexUid, sizeof(indexUid));
-    if ((pItem != NULL) || ((pItem = *(SSmaStatItem **)pItem) != NULL)) {
+    if ((pItem) || ((pItem = *(SSmaStatItem **)pItem))) {
       if (tsdbSmaStatIsDropped(pItem)) {
         tsdbDebug("vgId:%d tSma stat is already dropped for %" PRIi64, REPO_ID(pTsdb), indexUid);
         return TSDB_CODE_TDB_INVALID_ACTION;  // TODO: duplicate drop msg would be intercepted by mnode
@@ -1343,13 +1345,13 @@ static int32_t tsdbInsertRSmaDataImpl(STsdb *pTsdb, const char *msg) {
   SSmaEnv      *pEnv = atomic_load_ptr(&REPO_RSMA_ENV(pTsdb));
   int64_t       indexUid = SMA_TEST_INDEX_UID;
 
-  if (pEnv == NULL) {
+  if (!pEnv) {
     terrno = TSDB_CODE_INVALID_PTR;
     tsdbWarn("vgId:%d insert rSma data failed since pTSmaEnv is NULL", REPO_ID(pTsdb));
     return terrno;
   }
 
-  if (pDataBlocks == NULL) {
+  if (!pDataBlocks) {
     terrno = TSDB_CODE_INVALID_PTR;
     tsdbWarn("vgId:%d insert rSma data failed since pDataBlocks is NULL", REPO_ID(pTsdb));
     return terrno;
@@ -1366,11 +1368,11 @@ static int32_t tsdbInsertRSmaDataImpl(STsdb *pTsdb, const char *msg) {
 
   tsdbRefSmaStat(pTsdb, pStat);
 
-  if (pStat && pStat->smaStatItems) {
-    pItem = taosHashGet(pStat->smaStatItems, &indexUid, sizeof(indexUid));
+  if (pStat && SMA_STAT_ITEMS(pStat)) {
+    pItem = taosHashGet(SMA_STAT_ITEMS(pStat), &indexUid, sizeof(indexUid));
   }
 
-  if ((pItem == NULL) || ((pItem = *(SSmaStatItem **)pItem) == NULL) || tsdbSmaStatIsDropped(pItem)) {
+  if (!pItem || !(pItem = *(SSmaStatItem **)pItem) || tsdbSmaStatIsDropped(pItem)) {
     terrno = TSDB_CODE_TDB_INVALID_SMA_STAT;
     tsdbUnRefSmaStat(pTsdb, pStat);
     return TSDB_CODE_FAILED;
@@ -1491,7 +1493,7 @@ static bool tsdbSetAndOpenTSmaFile(STSmaReadH *pReadH, TSKEY *queryKey) {
     ++pReadH->smaFsIter.iter;
   }
 
-  if (pReadH->pDFile != NULL) {
+  if (pReadH->pDFile) {
     tsdbDebug("vg%d: smaFile %s matched", REPO_ID(pReadH->pTsdb), "[pSmaFile dir]");
     return true;
   }
@@ -1524,7 +1526,7 @@ static int32_t tsdbGetTSmaDataImpl(STsdb *pTsdb, char *pData, int64_t indexUid,
 
   tsdbRefSmaStat(pTsdb, pStat);
   SSmaStatItem *pItem = taosHashGet(SMA_ENV_STAT_ITEMS(pEnv), &indexUid, sizeof(indexUid));
-  if ((pItem == NULL) || ((pItem = *(SSmaStatItem **)pItem) == NULL)) {
+  if (!pItem || !(pItem = *(SSmaStatItem **)pItem)) {
     // Normally pItem should not be NULL, mark all windows as expired and notify query module to fetch raw TS data if
     // it's NULL.
     tsdbUnRefSmaStat(pTsdb, pStat);
@@ -1537,7 +1539,7 @@ static int32_t tsdbGetTSmaDataImpl(STsdb *pTsdb, char *pData, int64_t indexUid,
   int32_t nQueryWin = taosArrayGetSize(pQuerySKey);
   for (int32_t n = 0; n < nQueryWin; ++n) {
     TSKEY skey = taosArrayGet(pQuerySKey, n);
-    if (taosHashGet(pItem->expiredWindows, &skey, sizeof(TSKEY)) != NULL) {
+    if (taosHashGet(pItem->expiredWindows, &skey, sizeof(TSKEY))) {
       // TODO: mark this window as expired.
     }
   }
@@ -1553,7 +1555,7 @@ static int32_t tsdbGetTSmaDataImpl(STsdb *pTsdb, char *pData, int64_t indexUid,
     return TSDB_CODE_FAILED;
   }
 
-  if (taosHashGet(pItem->expiredWindows, &querySKey, sizeof(TSKEY)) != NULL) {
+  if (taosHashGet(pItem->expiredWindows, &querySKey, sizeof(TSKEY))) {
     // TODO: mark this window as expired.
     tsdbDebug("vgId:%d skey %" PRIi64 " of window exists in expired window for index %" PRIi64, REPO_ID(pTsdb),
               querySKey, indexUid);
@@ -1588,7 +1590,7 @@ static int32_t tsdbGetTSmaDataImpl(STsdb *pTsdb, char *pData, int64_t indexUid,
 
   void   *result = NULL;
   int32_t valueSize = 0;
-  if ((result = tsdbGetSmaDataByKey(&tReadH.dFile, smaKey, SMA_KEY_LEN, &valueSize)) == NULL) {
+  if (!(result = tsdbGetSmaDataByKey(&tReadH.dFile, smaKey, SMA_KEY_LEN, &valueSize))) {
     tsdbWarn("vgId:%d get sma data failed from smaIndex %" PRIi64 ", smaKey %" PRIx64 "-%" PRIx64 " since %s",
              REPO_ID(pTsdb), indexUid, *(int64_t *)smaKey, *(int64_t *)POINTER_SHIFT(smaKey, 8), tstrerror(terrno));
     tsdbCloseDBF(&tReadH.dFile);
@@ -1632,7 +1634,7 @@ static int32_t tsdbGetTSmaDataImpl(STsdb *pTsdb, char *pData, int64_t indexUid,
 
 int32_t tsdbCreateTSma(STsdb *pTsdb, char *pMsg) {
   SSmaCfg vCreateSmaReq = {0};
-  if (tDeserializeSVCreateTSmaReq(pMsg, &vCreateSmaReq) == NULL) {
+  if (!tDeserializeSVCreateTSmaReq(pMsg, &vCreateSmaReq)) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     tsdbWarn("vgId:%d TDMT_VND_CREATE_SMA received but deserialize failed since %s", REPO_ID(pTsdb), terrstr(terrno));
     return -1;
@@ -1658,7 +1660,7 @@ int32_t tsdbCreateTSma(STsdb *pTsdb, char *pMsg) {
 
 int32_t tsdbDropTSma(STsdb *pTsdb, char *pMsg) {
   SVDropTSmaReq vDropSmaReq = {0};
-  if (tDeserializeSVDropTSmaReq(pMsg, &vDropSmaReq) == NULL) {
+  if (!tDeserializeSVDropTSmaReq(pMsg, &vDropSmaReq)) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
   }
@@ -1697,7 +1699,7 @@ int32_t tsdbDropTSma(STsdb *pTsdb, char *pMsg) {
 int32_t tsdbRegisterRSma(STsdb *pTsdb, SMeta *pMeta, SVCreateTbReq *pReq) {
   SRSmaParam *param = pReq->stbCfg.pRSmaParam;
 
-  if (param == NULL) {
+  if (!param) {
     tsdbDebug("vgId:%d return directly since no rollup for stable %s %" PRIi64, REPO_ID(pTsdb), pReq->name,
               pReq->stbCfg.suid);
     return TSDB_CODE_SUCCESS;
@@ -1716,23 +1718,21 @@ int32_t tsdbRegisterRSma(STsdb *pTsdb, SMeta *pMeta, SVCreateTbReq *pReq) {
   SSmaEnv   *pEnv = REPO_RSMA_ENV(pTsdb);
   SSmaStat  *pStat = SMA_ENV_STAT(pEnv);
   SRSmaInfo *pRSmaInfo = NULL;
-  SRSmaInfo *tRSmaInfo = &pStat->rsmaInfo;
 
-  TASSERT(pEnv != NULL && pStat != NULL);
-
-  pRSmaInfo = taosHashGet(pStat->rsmaInfoHash, &pReq->stbCfg.suid, sizeof(tb_uid_t));
-  if (pRSmaInfo != NULL) {
-    pRSmaInfo = tsdbFreeRSmaInfo(pRSmaInfo);
+  pRSmaInfo = taosHashGet(SMA_STAT_INFO_HASH(pStat), &pReq->stbCfg.suid, sizeof(tb_uid_t));
+  if (pRSmaInfo) {
+    tsdbWarn("vgId:%d rsma info already exists for stb: %s, %" PRIi64, REPO_ID(pTsdb), pReq->name, pReq->stbCfg.suid);
+    return TSDB_CODE_SUCCESS;
   }
 
   pRSmaInfo = (SRSmaInfo *)taosMemoryCalloc(1, sizeof(SRSmaInfo));
-  if (pRSmaInfo == NULL) {
+  if (!pRSmaInfo) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return TSDB_CODE_FAILED;
   }
 
   STqReadHandle *pReadHandle = tqInitSubmitMsgScanner(pMeta);
-  if (pReadHandle == NULL) {
+  if (!pReadHandle) {
     taosMemoryFree(pRSmaInfo);
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return TSDB_CODE_FAILED;
@@ -1745,65 +1745,83 @@ int32_t tsdbRegisterRSma(STsdb *pTsdb, SMeta *pMeta, SVCreateTbReq *pReq) {
 
   if (param->qmsg1) {
     pRSmaInfo->taskInfo[0] = qCreateStreamExecTaskInfo(param->qmsg1, &handle);
-    if (pRSmaInfo->taskInfo[0] == NULL) {
+    if (!pRSmaInfo->taskInfo[0]) {
       taosMemoryFree(pRSmaInfo);
       taosMemoryFree(pReadHandle);
       return TSDB_CODE_FAILED;
     }
-    tRSmaInfo->taskInfo[0] = pRSmaInfo->taskInfo[0];
   }
 
   if (param->qmsg2) {
     pRSmaInfo->taskInfo[1] = qCreateStreamExecTaskInfo(param->qmsg2, &handle);
-    if (pRSmaInfo->taskInfo[1] == NULL) {
+    if (!pRSmaInfo->taskInfo[1]) {
       taosMemoryFree(pRSmaInfo);
       taosMemoryFree(pReadHandle);
       return TSDB_CODE_FAILED;
     }
-    tRSmaInfo->taskInfo[1] = pRSmaInfo->taskInfo[1];
   }
 
   if (taosHashPut(SMA_STAT_INFO_HASH(pStat), &pReq->stbCfg.suid, sizeof(tb_uid_t), &pRSmaInfo, sizeof(pRSmaInfo)) !=
-      0) {
+      TSDB_CODE_SUCCESS) {
     return TSDB_CODE_FAILED;
   }
 
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t tsdbUidStorePut(STbUidStore *pStore, tb_uid_t suid, tb_uid_t uid) {
+/**
+ * @brief store suid/[uids], prefer to use array and then hash
+ *
+ * @param pStore
+ * @param suid
+ * @param uid
+ * @return int32_t
+ */
+int32_t tsdbUidStorePut(STbUidStore *pStore, tb_uid_t suid, tb_uid_t *uid) {
+  // prefer to store suid/uids in array
   if ((suid == pStore->suid) || (pStore->suid == 0)) {
-    if (pStore->tbUids == NULL) {
-      if ((pStore->tbUids = taosArrayInit(1, sizeof(tb_uid_t))) == NULL) {
-        terrno = TSDB_CODE_OUT_OF_MEMORY;
-        return TSDB_CODE_FAILED;
-      }
+    if (pStore->suid == 0) {
       pStore->suid = suid;
     }
-    if (taosArrayPush(pStore->tbUids, &uid) == NULL) {
-      return TSDB_CODE_FAILED;
+    if (uid) {
+      if (!pStore->tbUids) {
+        if (!(pStore->tbUids = taosArrayInit(1, sizeof(tb_uid_t)))) {
+          terrno = TSDB_CODE_OUT_OF_MEMORY;
+          return TSDB_CODE_FAILED;
+        }
+      }
+      if (!taosArrayPush(pStore->tbUids, &uid)) {
+        return TSDB_CODE_FAILED;
+      }
     }
   } else {
-    if (pStore->uidHash == NULL) {
+    // store other suid/uids in hash when multiple stable/table included in 1 batch of request
+    if (!pStore->uidHash) {
       pStore->uidHash = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK);
-      if (pStore->uidHash == NULL) {
+      if (!pStore->uidHash) {
         return TSDB_CODE_FAILED;
       }
     }
-    SArray *hashVal = taosHashGet(pStore->uidHash, &suid, sizeof(tb_uid_t));
-    if (hashVal && ((hashVal = *(SArray **)hashVal) != NULL)) {
-      taosArrayPush(hashVal, &uid);
+    if (uid) {
+      SArray *uidArray = taosHashGet(pStore->uidHash, &suid, sizeof(tb_uid_t));
+      if (uidArray && ((uidArray = *(SArray **)uidArray))) {
+        taosArrayPush(uidArray, &uid);
+      } else {
+        SArray *pUidArray = taosArrayInit(1, sizeof(tb_uid_t));
+        if (!pUidArray) {
+          terrno = TSDB_CODE_OUT_OF_MEMORY;
+          return TSDB_CODE_FAILED;
+        }
+        if (!taosArrayPush(pUidArray, &uid)) {
+          terrno = TSDB_CODE_OUT_OF_MEMORY;
+          return TSDB_CODE_FAILED;
+        }
+        if (taosHashPut(pStore->uidHash, &suid, sizeof(suid), &pUidArray, sizeof(pUidArray)) != 0) {
+          return TSDB_CODE_FAILED;
+        }
+      }
     } else {
-      SArray *pItem = taosArrayInit(1, sizeof(tb_uid_t));
-      if (pItem == NULL) {
-        terrno = TSDB_CODE_OUT_OF_MEMORY;
-        return TSDB_CODE_FAILED;
-      }
-      if (taosArrayPush(pItem, &uid) == NULL) {
-        terrno = TSDB_CODE_OUT_OF_MEMORY;
-        return TSDB_CODE_FAILED;
-      }
-      if (taosHashPut(pStore->uidHash, &suid, sizeof(suid), &pItem, sizeof(pItem)) != 0) {
+      if (taosHashPut(pStore->uidHash, &suid, sizeof(suid), NULL, 0) != 0) {
         return TSDB_CODE_FAILED;
       }
     }
@@ -1811,8 +1829,42 @@ int32_t tsdbUidStorePut(STbUidStore *pStore, tb_uid_t suid, tb_uid_t uid) {
   return TSDB_CODE_SUCCESS;
 }
 
+void tsdbUidStoreDestory(STbUidStore *pStore) {
+  if (pStore) {
+    if (pStore->uidHash) {
+      if (pStore->tbUids) {
+        void *pIter = taosHashIterate(pStore->uidHash, NULL);
+        while (pIter) {
+          SArray *arr = *(SArray **)pIter;
+          taosArrayDestroy(arr);
+          pIter = taosHashIterate(pStore->uidHash, pIter);
+        }
+      }
+      taosHashCleanup(pStore->uidHash);
+    }
+    taosArrayDestroy(pStore->tbUids);
+  }
+}
+
+void *tsdbUidStoreFree(STbUidStore *pStore) {
+  tsdbUidStoreDestory(pStore);
+  taosMemoryFree(pStore);
+  return NULL;
+}
+
+/**
+ * @brief fetch suid/uids when create child tables of rollup SMA
+ *
+ * @param pTsdb
+ * @param ppStore
+ * @param suid
+ * @param uid
+ * @return int32_t
+ */
 int32_t tsdbFetchTbUidList(void *pTsdb, void **ppStore, void *suid, void *uid) {
   SSmaEnv *pEnv = REPO_RSMA_ENV((STsdb *)pTsdb);
+
+  // only applicable to rollup SMA ctables
   if (!pEnv) {
     return TSDB_CODE_SUCCESS;
   }
@@ -1824,97 +1876,194 @@ int32_t tsdbFetchTbUidList(void *pTsdb, void **ppStore, void *suid, void *uid) {
     return TSDB_CODE_FAILED;
   }
 
-  // info cached when create rsma stable
-  if (!taosHashGet(infoHash, suid, sizeof(suid))) {
+  // info cached when create rsma stable and return directly for non-rsma ctables
+  if (!taosHashGet(infoHash, suid, sizeof(tb_uid_t))) {
     return TSDB_CODE_SUCCESS;
   }
 
-  if (*ppStore == NULL) {
+  if (!(*ppStore)) {
     if (tsdbUidStoreInit((STbUidStore **)ppStore) != 0) {
       return TSDB_CODE_FAILED;
     }
   }
-  if (tsdbUidStorePut(*ppStore, *(tb_uid_t *)suid, *(tb_uid_t *)uid) != 0) {
+
+  if (tsdbUidStorePut(*ppStore, *(tb_uid_t *)suid, (tb_uid_t *)uid) != 0) {
     *ppStore = tsdbUidStoreFree(*ppStore);
     return TSDB_CODE_FAILED;
   }
+
   return TSDB_CODE_SUCCESS;
 }
 
-void *tsdbUidStoreFree(STbUidStore *pStore) {
-  if (pStore) {
-    taosArrayDestroy(pStore->tbUids);
-    if (pStore->uidHash) {
-      void *pIter = taosHashIterate(pStore->uidHash, NULL);
-      while (pIter != NULL) {
-        SArray *arr = *(SArray **)pIter;
-        taosArrayDestroy(arr);
-        pIter = taosHashIterate(pStore->uidHash, pIter);
-      }
-    }
-    taosMemoryFree(pStore);
-  }
-  return NULL;
-}
-
-int32_t tsdbUpdateTbUidList(STsdb *pTsdb, STbUidStore *pUidStore) {
-  if (!pUidStore || (taosArrayGetSize(pUidStore->tbUids) == 0)) {
-    tsdbDebug("vgId:%d empty uidStore and no need to update", REPO_ID(pTsdb));
-    return TSDB_CODE_SUCCESS;
-  }
+static FORCE_INLINE int32_t tsdbUpdateTbUidListImpl(STsdb *pTsdb, tb_uid_t *suid, SArray *tbUids) {
   SSmaEnv   *pEnv = REPO_RSMA_ENV(pTsdb);
   SSmaStat  *pStat = SMA_ENV_STAT(pEnv);
-  SRSmaInfo *pRSmaInfo = &pStat->rsmaInfo;
+  SRSmaInfo *pRSmaInfo = NULL;
 
-  if (qUpdateQualifiedTableId(pRSmaInfo->taskInfo[0], pUidStore->tbUids, true) != 0) {
-    tsdbUidStoreFree(pUidStore);
-    tsdbError("vgId:%d update tbUidList failed since %s", REPO_ID(pTsdb), terrstr(terrno));
+  if (!suid || !tbUids) {
+    terrno = TSDB_CODE_INVALID_PTR;
+    tsdbError("vgId:%d failed to get rsma info for uid:%" PRIi64 " since %s", REPO_ID(pTsdb), *suid, terrstr(terrno));
+    return TSDB_CODE_FAILED;
+  }
+
+  pRSmaInfo = taosHashGet(SMA_STAT_INFO_HASH(pStat), suid, sizeof(tb_uid_t));
+  if (!pRSmaInfo || !(pRSmaInfo = *(SRSmaInfo **)pRSmaInfo)) {
+    tsdbError("vgId:%d failed to get rsma info for uid:%" PRIi64, REPO_ID(pTsdb), *suid);
+    terrno = TSDB_CODE_TDB_INVALID_SMA_STAT;
+    return TSDB_CODE_FAILED;
+  }
+
+  if (pRSmaInfo->taskInfo[0] && (qUpdateQualifiedTableId(pRSmaInfo->taskInfo[0], tbUids, true) != 0)) {
+    tsdbError("vgId:%d update tbUidList failed for uid:%" PRIi64 " since %s", REPO_ID(pTsdb), *suid, terrstr(terrno));
+    return TSDB_CODE_FAILED;
+  }
+  if (pRSmaInfo->taskInfo[1] && (qUpdateQualifiedTableId(pRSmaInfo->taskInfo[1], tbUids, true) != 0)) {
+    tsdbError("vgId:%d update tbUidList failed for uid:%" PRIi64 " since %s", REPO_ID(pTsdb), *suid, terrstr(terrno));
     return TSDB_CODE_FAILED;
   }
 
-  tsdbUidStoreFree(pUidStore);
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t tsdbTriggerRSma(STsdb *pTsdb, SMeta *pMeta, const void *pMsg, int32_t inputType) {
+int32_t tsdbUpdateTbUidList(STsdb *pTsdb, STbUidStore *pStore) {
+  if (!pStore || (taosArrayGetSize(pStore->tbUids) == 0)) {
+    tsdbDebug("vgId:%d no need to update tbUids since empty uidStore", REPO_ID(pTsdb));
+    tsdbUidStoreFree(pStore);
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if (tsdbUpdateTbUidListImpl(pTsdb, &pStore->suid, pStore->tbUids) != TSDB_CODE_SUCCESS) {
+    tsdbUidStoreFree(pStore);
+    return TSDB_CODE_FAILED;
+  }
+
+  void *pIter = taosHashIterate(pStore->uidHash, NULL);
+  while (pIter) {
+    tb_uid_t *pTbSuid = (tb_uid_t *)taosHashGetKey(pIter, NULL);
+    SArray   *pTbUids = *(SArray **)pIter;
+
+    if (tsdbUpdateTbUidListImpl(pTsdb, pTbSuid, pTbUids) != TSDB_CODE_SUCCESS) {
+      taosHashCancelIterate(pStore->uidHash, pIter);
+      tsdbUidStoreFree(pStore);
+      return TSDB_CODE_FAILED;
+    }
+
+    pIter = taosHashIterate(pStore->uidHash, pIter);
+  }
+
+  tsdbUidStoreFree(pStore);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t tsdbFetchSubmitReqSuids(const SSubmitReq *pMsg, STbUidStore *pStore) {
+  ASSERT(pMsg != NULL);
+  SSubmitMsgIter msgIter = {0};
+  SSubmitBlk    *pBlock = NULL;
+  SSubmitBlkIter blkIter = {0};
+  STSRow        *row = NULL;
+
+  terrno = TSDB_CODE_SUCCESS;
+  // pMsg->length = htonl(pMsg->length);
+  // pMsg->numOfBlocks = htonl(pMsg->numOfBlocks);
+
+  if (tInitSubmitMsgIterEx(pMsg, &msgIter) < 0) return -1;
+  while (true) {
+    if (tGetSubmitMsgNextEx(&msgIter, &pBlock) < 0) return -1;
+    if (!pBlock) break;
+    tsdbUidStorePut(pStore, msgIter.suid, NULL);
+  }
+
+  if (terrno != TSDB_CODE_SUCCESS) return -1;
+  return 0;
+}
+
+int32_t tsdbExecuteRSma(STsdb *pTsdb, SMeta *pMeta, const void *pMsg, int32_t inputType, tb_uid_t *suid) {
   SSmaEnv *pEnv = REPO_RSMA_ENV(pTsdb);
   if (!pEnv) {
+    // only applicable when rsma env exists
     return TSDB_CODE_SUCCESS;
   }
 
   SSmaStat  *pStat = SMA_ENV_STAT(pEnv);
   SRSmaInfo *pRSmaInfo = NULL;
 
+  pRSmaInfo = taosHashGet(SMA_STAT_INFO_HASH(pStat), suid, sizeof(tb_uid_t));
+
+  if (!pRSmaInfo || !(pRSmaInfo = *(SRSmaInfo **)pRSmaInfo)) {
+    tsdbDebug("vgId:%d no rsma info for suid:%" PRIu64, REPO_ID(pTsdb), *suid);
+    return TSDB_CODE_SUCCESS;
+  }
+
   SArray *pResult = NULL;
 
   pResult = taosArrayInit(0, sizeof(SSDataBlock));
-  if (pResult == NULL) {
+  if (!pResult) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
   }
 
   if (inputType == STREAM_DATA_TYPE_SUBMIT_BLOCK) {
-    // pRSmaInfo = taosHashGet(pStat->rsmaInfoHash, &pReq->stbCfg.suid, sizeof(tb_uid_t));
-    // if (pRSmaInfo != NULL) {
-    //   pRSmaInfo = tsdbFreeRSmaInfo(pRSmaInfo);
+    if (pRSmaInfo->taskInfo[0]) {
+      qSetStreamInput(pRSmaInfo->taskInfo[0], pMsg, inputType);
+      while (1) {
+        SSDataBlock *output;
+        uint64_t     ts;
+        if (qExecTask(pRSmaInfo->taskInfo[0], &output, &ts) < 0) {
+          ASSERT(false);
+        }
+        if (!output) {
+          break;
+        }
+        taosArrayPush(pResult, output);
+      }
+      blockDebugShowData(pResult);
+    }
+
+    // if (pRSmaInfo->taskInfo[1]) {
+    //   qSetStreamInput(pRSmaInfo->taskInfo[1], pMsg, inputType);
+    //   while (1) {
+    //     SSDataBlock *output;
+    //     uint64_t     ts;
+    //     if (qExecTask(pRSmaInfo->taskInfo[1], &output, &ts) < 0) {
+    //       ASSERT(false);
+    //     }
+    //     if (!output) {
+    //       break;
+    //     }
+    //     taosArrayPush(pResult, output);
+    //   }
+    //   blockDebugShowData(pResult);
     // }
+  }
 
-    SRSmaInfo *tRSmaInfo = &pStat->rsmaInfo;
+  return TSDB_CODE_SUCCESS;
+}
 
-    qSetStreamInput(tRSmaInfo->taskInfo[0], pMsg, inputType, true);
-    while (1) {
-      SSDataBlock *output;
-      uint64_t     ts;
-      if (qExecTask(tRSmaInfo->taskInfo[0], &output, &ts) < 0) {
-        ASSERT(false);
+int32_t tsdbTriggerRSma(STsdb *pTsdb, SMeta *pMeta, const void *pMsg, int32_t inputType) {
+  SSmaEnv *pEnv = REPO_RSMA_ENV(pTsdb);
+  if (!pEnv) {
+    // only applicable when rsma env exists
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if (inputType == STREAM_DATA_TYPE_SUBMIT_BLOCK) {
+    STbUidStore uidStore = {0};
+    tsdbFetchSubmitReqSuids(pMsg, &uidStore);
+
+    if (uidStore.suid != 0) {
+      tsdbExecuteRSma(pTsdb, pMeta, pMsg, inputType, &uidStore.suid);
+
+      void *pIter = taosHashIterate(uidStore.uidHash, NULL);
+      while (pIter) {
+        tb_uid_t *pTbSuid = (tb_uid_t *)taosHashGetKey(pIter, NULL);
+        tsdbExecuteRSma(pTsdb, pMeta, pMsg, inputType, pTbSuid);
+        pIter = taosHashIterate(uidStore.uidHash, pIter);
       }
-      if (output == NULL) {
-        break;
-      }
-      taosArrayPush(pResult, output);
+
+      tsdbUidStoreDestory(&uidStore);
     }
   }
-  blockDebugShowData(pResult);
   return TSDB_CODE_SUCCESS;
 }
 
@@ -1960,6 +2109,7 @@ int32_t tsdbInsertTSmaData(STsdb *pTsdb, int64_t indexUid, const char *msg) {
   if ((code = tsdbInsertTSmaDataImpl(pTsdb, indexUid, msg)) < 0) {
     tsdbWarn("vgId:%d insert tSma data failed since %s", REPO_ID(pTsdb), tstrerror(terrno));
   }
+  // TODO: destroy SSDataBlocks(msg)
   return code;
 }
 
diff --git a/source/dnode/vnode/src/vnd/vnodeSvr.c b/source/dnode/vnode/src/vnd/vnodeSvr.c
index 0417acf290..6c82edbadc 100644
--- a/source/dnode/vnode/src/vnd/vnodeSvr.c
+++ b/source/dnode/vnode/src/vnd/vnodeSvr.c
@@ -83,7 +83,7 @@ int vnodeProcessWriteReq(SVnode *pVnode, SRpcMsg *pMsg, int64_t version, SRpcMsg
     case TDMT_VND_SUBMIT:
       pRsp->msgType = TDMT_VND_SUBMIT_RSP;
       vnodeProcessSubmitReq(pVnode, ptr, pRsp);
-      tsdbTriggerRSma(pVnode->pTsdb, pVnode->pMeta, ptr, STREAM_DATA_TYPE_SUBMIT_BLOCK);
+      tsdbTriggerRSma(pVnode->pTsdb, pVnode->pMeta, pMsg->pCont, STREAM_DATA_TYPE_SUBMIT_BLOCK);
       break;
     case TDMT_VND_MQ_VG_CHANGE:
       if (tqProcessVgChangeReq(pVnode->pTq, POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead)),
@@ -348,6 +348,8 @@ static int vnodeProcessCreateTbReq(SVnode *pVnode, SRpcMsg *pMsg, void *pReq, SR
     }
   }
 
+  tsdbUpdateTbUidList(pVnode->pTsdb, ddlHandle.result);
+
   vTrace("vgId:%d process create %" PRIzu " tables", TD_VID(pVnode), taosArrayGetSize(vCreateTbBatchReq.pArray));
   taosArrayDestroy(vCreateTbBatchReq.pArray);
   if (vCreateTbBatchRsp.rspList) {
@@ -360,8 +362,6 @@ static int vnodeProcessCreateTbReq(SVnode *pVnode, SRpcMsg *pMsg, void *pReq, SR
     pRsp->contLen = contLen;
   }
 
-  tsdbUpdateTbUidList(pVnode->pTsdb, ddlHandle.result);
-
   return 0;
 }
 
diff --git a/source/dnode/vnode/test/tsdbSmaTest.cpp b/source/dnode/vnode/test/tsdbSmaTest.cpp
index b0217a0462..ab617cb186 100644
--- a/source/dnode/vnode/test/tsdbSmaTest.cpp
+++ b/source/dnode/vnode/test/tsdbSmaTest.cpp
@@ -407,7 +407,7 @@ TEST(testCase, tSma_Data_Insert_Query_Test) {
     }
   }
 
-  EXPECT_EQ(tdScanAndConvertSubmitMsg(pMsg), TSDB_CODE_SUCCESS);
+  // EXPECT_EQ(tdScanAndConvertSubmitMsg(pMsg), TSDB_CODE_SUCCESS);
 
   EXPECT_EQ(tsdbUpdateSmaWindow(pTsdb, pMsg, 0), 0);
 
diff --git a/source/libs/executor/src/executor.c b/source/libs/executor/src/executor.c
index 8f7f55eb33..4863b03fb9 100644
--- a/source/libs/executor/src/executor.c
+++ b/source/libs/executor/src/executor.c
@@ -19,7 +19,7 @@
 #include "tdatablock.h"
 #include "vnode.h"
 
-static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void* input, size_t numOfBlocks, int32_t type, char* id, bool converted) {
+static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void* input, size_t numOfBlocks, int32_t type, char* id) {
   ASSERT(pOperator != NULL);
   if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN) {
     if (pOperator->numOfDownstream == 0) {
@@ -32,7 +32,7 @@ static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void* input, size_t nu
       return TSDB_CODE_QRY_APP_ERROR;
     }
     pOperator->status = OP_NOT_OPENED;
-    return doSetStreamBlock(pOperator->pDownstream[0], input, numOfBlocks, type, id, converted);
+    return doSetStreamBlock(pOperator->pDownstream[0], input, numOfBlocks, type, id);
   } else {
     pOperator->status = OP_NOT_OPENED;
 
@@ -46,13 +46,8 @@ static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void* input, size_t nu
     }
 
     if (type == STREAM_DATA_TYPE_SUBMIT_BLOCK) {
-      if (converted) {
-        if (tqReadHandleSetMsgEx(pInfo->readerHandle, input, 0) < 0) {
-          qError("converted: submit msg messed up when initing stream block, %s" PRIx64, id);
-          return TSDB_CODE_QRY_APP_ERROR;
-        }
-      } else if (tqReadHandleSetMsg(pInfo->readerHandle, input, 0) < 0) {
-        qError("raw msg: submit msg messed up when initing stream block, %s" PRIx64, id);
+      if (tqReadHandleSetMsg(pInfo->readerHandle, input, 0) < 0) {
+        qError("submit msg messed up when initing stream block, %s" PRIx64, id);
         return TSDB_CODE_QRY_APP_ERROR;
       }
     } else {
@@ -72,11 +67,11 @@ static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void* input, size_t nu
   }
 }
 
-int32_t qSetStreamInput(qTaskInfo_t tinfo, const void* input, int32_t type, bool converted) {
-  return qSetMultiStreamInput(tinfo, input, 1, type, converted);
+int32_t qSetStreamInput(qTaskInfo_t tinfo, const void* input, int32_t type) {
+  return qSetMultiStreamInput(tinfo, input, 1, type);
 }
 
-int32_t qSetMultiStreamInput(qTaskInfo_t tinfo, const void* pBlocks, size_t numOfBlocks, int32_t type, bool converted) {
+int32_t qSetMultiStreamInput(qTaskInfo_t tinfo, const void* pBlocks, size_t numOfBlocks, int32_t type) {
   if (tinfo == NULL) {
     return TSDB_CODE_QRY_APP_ERROR;
   }
@@ -87,7 +82,7 @@ int32_t qSetMultiStreamInput(qTaskInfo_t tinfo, const void* pBlocks, size_t numO
 
   SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo;
 
-  int32_t code = doSetStreamBlock(pTaskInfo->pRoot, (void**)pBlocks, numOfBlocks, type, GET_TASKID(pTaskInfo), converted);
+  int32_t code = doSetStreamBlock(pTaskInfo->pRoot, (void**)pBlocks, numOfBlocks, type, GET_TASKID(pTaskInfo));
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed to set the stream block data", GET_TASKID(pTaskInfo));
   } else {
diff --git a/source/libs/stream/src/tstream.c b/source/libs/stream/src/tstream.c
index 1f0c269ca1..8aaaa414ca 100644
--- a/source/libs/stream/src/tstream.c
+++ b/source/libs/stream/src/tstream.c
@@ -110,7 +110,7 @@ int32_t streamExecTask(SStreamTask* pTask, SMsgCb* pMsgCb, const void* input, in
       return -1;
     }
     if (inputType == STREAM_DATA_TYPE_SUBMIT_BLOCK) {
-      qSetStreamInput(exec, input, inputType, true);
+      qSetStreamInput(exec, input, inputType);
       while (1) {
         SSDataBlock* output;
         uint64_t     ts;
@@ -128,7 +128,7 @@ int32_t streamExecTask(SStreamTask* pTask, SMsgCb* pMsgCb, const void* input, in
       /*for (int32_t i = 0; i < sz; i++) {*/
       /*SSDataBlock* pBlock = taosArrayGet(blocks, i);*/
       /*qSetStreamInput(exec, pBlock, inputType);*/
-      qSetMultiStreamInput(exec, blocks->pData, blocks->size, STREAM_DATA_TYPE_SSDATA_BLOCK, true);
+      qSetMultiStreamInput(exec, blocks->pData, blocks->size, STREAM_DATA_TYPE_SSDATA_BLOCK);
       while (1) {
         SSDataBlock* output;
         uint64_t     ts;

From 6f29209464115ea4707e4a931787c30fcb5bda94 Mon Sep 17 00:00:00 2001
From: Cary Xu <klxu@taosdata.com>
Date: Mon, 25 Apr 2022 05:47:09 +0800
Subject: [PATCH 08/23] trigger CI


From ecf00f7f579b1ff45263bfd32b8864ca51fd81e9 Mon Sep 17 00:00:00 2001
From: Liu Jicong <liujicong@qq.com>
Date: Mon, 25 Apr 2022 11:41:42 +0800
Subject: [PATCH 09/23] enable hb

---
 example/src/tmq.c            |  1 -
 source/client/src/clientHb.c | 64 ++++++++++++++++++------------------
 2 files changed, 32 insertions(+), 33 deletions(-)

diff --git a/example/src/tmq.c b/example/src/tmq.c
index b2cbf856c0..32390f71c9 100644
--- a/example/src/tmq.c
+++ b/example/src/tmq.c
@@ -60,7 +60,6 @@ int32_t init_env() {
   pRes =
       taos_query(pConn, "create stable if not exists st1 (ts timestamp, c1 int, c2 float, c3 binary(10)) tags(t1 int)");
   if (taos_errno(pRes) != 0) {
-    assert(0);
     printf("failed to create super table st1, reason:%s\n", taos_errstr(pRes));
     return -1;
   }
diff --git a/source/client/src/clientHb.c b/source/client/src/clientHb.c
index 6159da9cb1..653f9a0634 100644
--- a/source/client/src/clientHb.c
+++ b/source/client/src/clientHb.c
@@ -14,9 +14,9 @@
  */
 
 #include "catalog.h"
-#include "scheduler.h"
 #include "clientInt.h"
 #include "clientLog.h"
+#include "scheduler.h"
 #include "trpc.h"
 
 static SClientHbMgr clientHbMgr = {0};
@@ -110,7 +110,8 @@ static int32_t hbProcessStbInfoRsp(void *value, int32_t valueLen, struct SCatalo
 static int32_t hbQueryHbRspHandle(SAppHbMgr *pAppHbMgr, SClientHbRsp *pRsp) {
   SHbConnInfo *info = taosHashGet(pAppHbMgr->connInfo, &pRsp->connKey, sizeof(SClientHbKey));
   if (NULL == info) {
-    tscWarn("fail to get connInfo, may be dropped, refId:%" PRIx64 ", type:%d", pRsp->connKey.tscRid, pRsp->connKey.connType);
+    tscWarn("fail to get connInfo, may be dropped, refId:%" PRIx64 ", type:%d", pRsp->connKey.tscRid,
+            pRsp->connKey.connType);
     return TSDB_CODE_SUCCESS;
   }
 
@@ -121,7 +122,7 @@ static int32_t hbQueryHbRspHandle(SAppHbMgr *pAppHbMgr, SClientHbRsp *pRsp) {
     } else {
       updateEpSet_s(&pTscObj->pAppInfo->mgmtEp, &pRsp->query->epSet);
       pTscObj->connId = pRsp->query->connId;
-      
+
       if (pRsp->query->killRid) {
         SRequestObj *pRequest = acquireRequest(pRsp->query->killRid);
         if (NULL == pRequest) {
@@ -131,7 +132,7 @@ static int32_t hbQueryHbRspHandle(SAppHbMgr *pAppHbMgr, SClientHbRsp *pRsp) {
           releaseRequest(pRsp->query->killRid);
         }
       }
-      
+
       if (pRsp->query->killConnection) {
         taos_close(pTscObj);
       }
@@ -139,7 +140,7 @@ static int32_t hbQueryHbRspHandle(SAppHbMgr *pAppHbMgr, SClientHbRsp *pRsp) {
       releaseTscObj(pRsp->connKey.tscRid);
     }
   }
-  
+
   int32_t kvNum = pRsp->info ? taosArrayGetSize(pRsp->info) : 0;
 
   tscDebug("hb got %d rsp kv", kvNum);
@@ -236,24 +237,24 @@ static int32_t hbAsyncCallBack(void *param, const SDataBuf *pMsg, int32_t code)
 }
 
 int32_t hbBuildQueryDesc(SQueryHbReqBasic *hbBasic, STscObj *pObj) {
-  int64_t now = taosGetTimestampUs();
+  int64_t    now = taosGetTimestampUs();
   SQueryDesc desc = {0};
-  int32_t code = 0;
+  int32_t    code = 0;
 
-  void   *pIter = taosHashIterate(pObj->pRequests, NULL);
+  void *pIter = taosHashIterate(pObj->pRequests, NULL);
   while (pIter != NULL) {
-    int64_t *rid = pIter;
+    int64_t     *rid = pIter;
     SRequestObj *pRequest = acquireRequest(*rid);
     if (NULL == pRequest) {
       continue;
     }
 
     tstrncpy(desc.sql, pRequest->sqlstr, sizeof(desc.sql));
-    desc.stime    = pRequest->metric.start;
-    desc.queryId  = pRequest->requestId;
+    desc.stime = pRequest->metric.start;
+    desc.queryId = pRequest->requestId;
     desc.useconds = now - pRequest->metric.start;
-    desc.reqRid   = pRequest->self;
-    desc.pid      = hbBasic->pid;
+    desc.reqRid = pRequest->self;
+    desc.pid = hbBasic->pid;
     taosGetFqdn(desc.fqdn);
     desc.subPlanNum = pRequest->body.pDag ? pRequest->body.pDag->numOfSubplans : 0;
 
@@ -271,9 +272,9 @@ int32_t hbBuildQueryDesc(SQueryHbReqBasic *hbBasic, STscObj *pObj) {
       }
     }
 
-    releaseRequest(*rid);    
+    releaseRequest(*rid);
     taosArrayPush(hbBasic->queryDesc, &desc);
-    
+
     pIter = taosHashIterate(pObj->pRequests, pIter);
   }
 
@@ -286,14 +287,14 @@ int32_t hbGetQueryBasicInfo(SClientHbKey *connKey, SClientHbReq *req) {
     tscWarn("tscObj rid %" PRIx64 " not exist", connKey->tscRid);
     return TSDB_CODE_QRY_APP_ERROR;
   }
-  
+
   int32_t numOfQueries = pTscObj->pRequests ? taosHashGetSize(pTscObj->pRequests) : 0;
   if (numOfQueries <= 0) {
     releaseTscObj(connKey->tscRid);
     tscDebug("no queries on connection");
     return TSDB_CODE_QRY_APP_ERROR;
   }
-  
+
   SQueryHbReqBasic *hbBasic = (SQueryHbReqBasic *)taosMemoryCalloc(1, sizeof(SQueryHbReqBasic));
   if (NULL == hbBasic) {
     tscError("calloc %d failed", (int32_t)sizeof(SQueryHbReqBasic));
@@ -308,7 +309,7 @@ int32_t hbGetQueryBasicInfo(SClientHbKey *connKey, SClientHbReq *req) {
     taosMemoryFree(hbBasic);
     return TSDB_CODE_QRY_OUT_OF_MEMORY;
   }
-  
+
   hbBasic->connId = pTscObj->connId;
   hbBasic->pid = taosGetPId();
   taosGetAppName(hbBasic->app, NULL);
@@ -405,7 +406,7 @@ int32_t hbQueryHbReqHandle(SClientHbKey *connKey, void *param, SClientHbReq *req
   }
 
   hbGetQueryBasicInfo(connKey, req);
-  
+
   code = hbGetExpiredDBInfo(connKey, pCatalog, req);
   if (TSDB_CODE_SUCCESS != code) {
     return code;
@@ -471,10 +472,10 @@ SClientHbBatchReq *hbGatherAllInfo(SAppHbMgr *pAppHbMgr) {
     pIter = taosHashIterate(pAppHbMgr->activeInfo, pIter);
   }
 
-//  if (code) {
-//    taosArrayDestroyEx(pBatchReq->reqs, hbFreeReq);
-//    taosMemoryFreeClear(pBatchReq);
-//  }
+  //  if (code) {
+  //    taosArrayDestroyEx(pBatchReq->reqs, hbFreeReq);
+  //    taosMemoryFreeClear(pBatchReq);
+  //  }
 
   return pBatchReq;
 }
@@ -630,24 +631,23 @@ void appHbMgrCleanup(void) {
   int sz = taosArrayGetSize(clientHbMgr.appHbMgrs);
   for (int i = 0; i < sz; i++) {
     SAppHbMgr *pTarget = taosArrayGetP(clientHbMgr.appHbMgrs, i);
-    
-    void   *pIter = taosHashIterate(pTarget->activeInfo, NULL);
+
+    void *pIter = taosHashIterate(pTarget->activeInfo, NULL);
     while (pIter != NULL) {
       SClientHbReq *pOneReq = pIter;
       hbFreeReq(pOneReq);
       taosHashCleanup(pOneReq->info);
       pIter = taosHashIterate(pTarget->activeInfo, pIter);
-    }    
+    }
     taosHashCleanup(pTarget->activeInfo);
     pTarget->activeInfo = NULL;
 
-
     pIter = taosHashIterate(pTarget->connInfo, NULL);
     while (pIter != NULL) {
       SHbConnInfo *info = pIter;
       taosMemoryFree(info->param);
       pIter = taosHashIterate(pTarget->connInfo, pIter);
-    }    
+    }
     taosHashCleanup(pTarget->connInfo);
     pTarget->connInfo = NULL;
 
@@ -668,13 +668,13 @@ int hbMgrInit() {
   hbMgrInitHandle();
 
   // init backgroud thread
-  //hbCreateThread();
+  hbCreateThread();
 
   return 0;
 }
 
 void hbMgrCleanUp() {
-  //hbStopThread();
+  // hbStopThread();
 
   // destroy all appHbMgr
   int8_t old = atomic_val_compare_exchange_8(&clientHbMgr.inited, 1, 0);
@@ -747,11 +747,11 @@ void hbDeregisterConn(SAppHbMgr *pAppHbMgr, SClientHbKey connKey) {
     taosMemoryFree(info->param);
     taosHashRemove(pAppHbMgr->connInfo, &connKey, sizeof(SClientHbKey));
   }
-  
+
   if (NULL == pReq || NULL == info) {
     return;
   }
-  
+
   atomic_sub_fetch_32(&pAppHbMgr->connKeyCnt, 1);
 }
 

From f966242047645e06fcd1bd086cc98181b4a310d3 Mon Sep 17 00:00:00 2001
From: afwerar <1296468573@qq.com>
Date: Mon, 25 Apr 2022 13:57:55 +0800
Subject: [PATCH 10/23] feature(dnode): mul parameter start.

---
 CMakeLists.txt                           |   2 +-
 examples/c/CMakeLists.txt                |   4 +-
 include/common/tglobal.h                 |   6 +-
 include/util/tconfig.h                   |   5 +-
 include/util/tenv.h                      |  33 +++
 include/util/tjson.h                     |   3 +
 source/client/src/clientEnv.c            |   4 +-
 source/common/src/tglobal.c              |  23 +-
 source/dnode/mgmt/exe/dmMain.c           |  26 +-
 source/dnode/mgmt/interface/src/dmFile.c |   2 +-
 source/libs/function/src/udfd.c          |   4 +-
 source/libs/function/test/runUdf.c       |   4 +-
 source/libs/sync/CMakeLists.txt          |   2 +-
 source/libs/sync/test/CMakeLists.txt     |  78 ++---
 source/util/src/tconfig.c                | 351 ++++++++++++++++++++++-
 source/util/src/tenv.c                   |  78 +++++
 source/util/src/tjson.c                  |  20 +-
 source/util/test/CMakeLists.txt          |   2 +-
 source/util/test/cfgTest.cpp             |   1 +
 tests/tsim/src/simSystem.c               |   4 +-
 tools/shell/CMakeLists.txt               |   2 +-
 21 files changed, 576 insertions(+), 78 deletions(-)
 create mode 100644 include/util/tenv.h
 create mode 100644 source/util/src/tenv.c

diff --git a/CMakeLists.txt b/CMakeLists.txt
index e1fbd54be3..0436f5b259 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -7,7 +7,7 @@ project(
 )
 
 if (NOT DEFINED TD_SOURCE_DIR)
-  set( TD_SOURCE_DIR ${CMAKE_SOURCE_DIR} )
+  set( TD_SOURCE_DIR ${PROJECT_SOURCE_DIR} )
 endif()
 
 set(TD_SUPPORT_DIR "${TD_SOURCE_DIR}/cmake")
diff --git a/examples/c/CMakeLists.txt b/examples/c/CMakeLists.txt
index e94de3cbca..17a9257c49 100644
--- a/examples/c/CMakeLists.txt
+++ b/examples/c/CMakeLists.txt
@@ -1,7 +1,7 @@
 PROJECT(TDengine)
 
 IF (TD_LINUX)
-  INCLUDE_DIRECTORIES(. ${TD_COMMUNITY_DIR}/src/inc ${TD_COMMUNITY_DIR}/src/client/inc  ${TD_COMMUNITY_DIR}/inc)
+  INCLUDE_DIRECTORIES(. ${TD_SOURCE_DIR}/src/inc ${TD_SOURCE_DIR}/src/client/inc  ${TD_SOURCE_DIR}/inc)
   AUX_SOURCE_DIRECTORY(. SRC)
   ADD_EXECUTABLE(demo apitest.c)
   TARGET_LINK_LIBRARIES(demo taos_static trpc tutil pthread )
@@ -13,7 +13,7 @@ IF (TD_LINUX)
   TARGET_LINK_LIBRARIES(epoll taos_static trpc tutil pthread lua)
 ENDIF ()
 IF (TD_DARWIN)
-  INCLUDE_DIRECTORIES(. ${TD_COMMUNITY_DIR}/src/inc ${TD_COMMUNITY_DIR}/src/client/inc  ${TD_COMMUNITY_DIR}/inc)
+  INCLUDE_DIRECTORIES(. ${TD_SOURCE_DIR}/src/inc ${TD_SOURCE_DIR}/src/client/inc  ${TD_SOURCE_DIR}/inc)
   AUX_SOURCE_DIRECTORY(. SRC)
   ADD_EXECUTABLE(demo demo.c)
   TARGET_LINK_LIBRARIES(demo taos_static trpc tutil pthread lua)
diff --git a/include/common/tglobal.h b/include/common/tglobal.h
index 72f67665ba..cde423c3cd 100644
--- a/include/common/tglobal.h
+++ b/include/common/tglobal.h
@@ -123,9 +123,9 @@ extern SDiskCfg tsDiskCfg[];
 
 #define NEEDTO_COMPRESSS_MSG(size) (tsCompressMsgSize != -1 && (size) > tsCompressMsgSize)
 
-int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char *cfgDir, const char *envFile,
-                      const char *apolloUrl, SArray *pArgs, bool tsc);
-int32_t taosInitCfg(const char *cfgDir, const char *envFile, const char *apolloUrl, SArray *pArgs, bool tsc);
+int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char **envCmd, const char *cfgDir, const char *envFile,
+                      char *apolloUrl, SArray *pArgs, bool tsc);
+int32_t taosInitCfg(const char **envCmd, const char *cfgDir, const char *envFile, char *apolloUrl, SArray *pArgs, bool tsc);
 void    taosCleanupCfg();
 void    taosCfgDynamicOptions(const char *option, const char *value);
 void    taosAddDataDir(int32_t index, char *v1, int32_t level, int32_t primary);
diff --git a/include/util/tconfig.h b/include/util/tconfig.h
index 012368d9cb..06fa9fd9aa 100644
--- a/include/util/tconfig.h
+++ b/include/util/tconfig.h
@@ -30,6 +30,7 @@ typedef enum {
   CFG_STYPE_CFG_FILE,
   CFG_STYPE_ENV_FILE,
   CFG_STYPE_ENV_VAR,
+  CFG_STYPE_ENV_CMD,
   CFG_STYPE_APOLLO_URL,
   CFG_STYPE_ARG_LIST,
   CFG_STYPE_TAOS_OPTIONS
@@ -82,7 +83,7 @@ typedef struct SConfig {
 } SConfig;
 
 SConfig *cfgInit();
-int32_t  cfgLoad(SConfig *pCfg, ECfgSrcType cfgType, const char *sourceStr);
+int32_t  cfgLoad(SConfig *pCfg, ECfgSrcType cfgType, const void *sourceStr);
 int32_t  cfgLoadFromArray(SConfig *pCfg, SArray *pArgs);  // SConfigPair
 void     cfgCleanup(SConfig *pCfg);
 
@@ -105,6 +106,8 @@ const char *cfgDtypeStr(ECfgDataType type);
 
 void cfgDumpCfg(SConfig *pCfg, bool tsc, bool dump);
 
+int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char* apolloUrl);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/util/tenv.h b/include/util/tenv.h
new file mode 100644
index 0000000000..1410e23f90
--- /dev/null
+++ b/include/util/tenv.h
@@ -0,0 +1,33 @@
+
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_ENV_H_
+#define _TD_ENV_H_
+
+#include "os.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int32_t taosEnvNameToCfgName(const char *envNameStr, char *cfgNameStr, int32_t cfgNameMaxLen);
+int32_t taosEnvToCfg(const char *envStr, char *cfgStr);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_ENV_H_*/
diff --git a/include/util/tjson.h b/include/util/tjson.h
index 286a7e65fc..d23f7b402e 100644
--- a/include/util/tjson.h
+++ b/include/util/tjson.h
@@ -49,6 +49,8 @@ int32_t tjsonAddItemToObject(SJson* pJson, const char* pName, SJson* pItem);
 int32_t tjsonAddItemToArray(SJson* pJson, SJson* pItem);
 
 SJson*  tjsonGetObjectItem(const SJson* pJson, const char* pName);
+int32_t tjsonGetObjectName(const SJson* pJson, char** pName);
+int32_t tjsonGetObjectValueString(const SJson* pJson, char** pStringValue);
 int32_t tjsonGetStringValue(const SJson* pJson, const char* pName, char* pVal);
 int32_t tjsonDupStringValue(const SJson* pJson, const char* pName, char** pVal);
 int32_t tjsonGetBigIntValue(const SJson* pJson, const char* pName, int64_t* pVal);
@@ -81,6 +83,7 @@ char* tjsonToUnformattedString(const SJson* pJson);
 
 SJson* tjsonParse(const char* pStr);
 bool   tjsonValidateJson(const char* pJson);
+const char* tjsonGetError();
 
 #ifdef __cplusplus
 }
diff --git a/source/client/src/clientEnv.c b/source/client/src/clientEnv.c
index 9a34334466..56eab18a55 100644
--- a/source/client/src/clientEnv.c
+++ b/source/client/src/clientEnv.c
@@ -254,12 +254,12 @@ void taos_init_imp(void) {
 
   deltaToUtcInitOnce();
 
-  if (taosCreateLog("taoslog", 10, configDir, NULL, NULL, NULL, 1) != 0) {
+  if (taosCreateLog("taoslog", 10, NULL, configDir, NULL, NULL, NULL, 1) != 0) {
     tscInitRes = -1;
     return;
   }
 
-  if (taosInitCfg(configDir, NULL, NULL, NULL, 1) != 0) {
+  if (taosInitCfg(NULL, configDir, NULL, NULL, NULL, 1) != 0) {
     tscInitRes = -1;
     return;
   }
diff --git a/source/common/src/tglobal.c b/source/common/src/tglobal.c
index 33999ea14c..c74f53f0a0 100644
--- a/source/common/src/tglobal.c
+++ b/source/common/src/tglobal.c
@@ -220,7 +220,7 @@ struct SConfig *taosGetCfg() {
   return tsCfg;
 }
 
-static int32_t taosLoadCfg(SConfig *pCfg, const char *inputCfgDir, const char *envFile, const char *apolloUrl) {
+static int32_t taosLoadCfg(SConfig *pCfg, const char **envCmd, const char *inputCfgDir, const char *envFile, char *apolloUrl) {
   char cfgDir[PATH_MAX] = {0};
   char cfgFile[PATH_MAX + 100] = {0};
 
@@ -231,6 +231,8 @@ static int32_t taosLoadCfg(SConfig *pCfg, const char *inputCfgDir, const char *e
     tstrncpy(cfgFile, cfgDir, sizeof(cfgDir));
   }
 
+  if (apolloUrl == NULL || apolloUrl[0] == '\0') cfgGetApollUrl(envCmd, envFile, apolloUrl);
+
   if (cfgLoad(pCfg, CFG_STYPE_APOLLO_URL, apolloUrl) != 0) {
     uError("failed to load from apollo url:%s since %s", apolloUrl, terrstr());
     return -1;
@@ -251,6 +253,11 @@ static int32_t taosLoadCfg(SConfig *pCfg, const char *inputCfgDir, const char *e
     return -1;
   }
 
+  if (cfgLoad(pCfg, CFG_STYPE_ENV_CMD, envCmd) != 0) {
+    uError("failed to load from cmd env variables since %s", terrstr());
+    return -1;
+  }
+
   return 0;
 }
 
@@ -325,8 +332,8 @@ static int32_t taosAddSystemCfg(SConfig *pCfg) {
   if (cfgAddFloat(pCfg, "numOfCores", tsNumOfCores, 0, 100000, 1) != 0) return -1;
   if (cfgAddInt64(pCfg, "openMax", tsOpenMax, 0, INT64_MAX, 1) != 0) return -1;
   if (cfgAddInt64(pCfg, "streamMax", tsStreamMax, 0, INT64_MAX, 1) != 0) return -1;
-  if (cfgAddInt32(pCfg, "pageSize(KB)", tsPageSizeKB, 0, INT64_MAX, 1) != 0) return -1;
-  if (cfgAddInt64(pCfg, "totalMemory(KB)", tsTotalMemoryKB, 0, INT64_MAX, 1) != 0) return -1;
+  if (cfgAddInt32(pCfg, "pageSizeKB", tsPageSizeKB, 0, INT64_MAX, 1) != 0) return -1;
+  if (cfgAddInt64(pCfg, "totalMemoryKB", tsTotalMemoryKB, 0, INT64_MAX, 1) != 0) return -1;
   if (cfgAddString(pCfg, "os sysname", info.sysname, 1) != 0) return -1;
   if (cfgAddString(pCfg, "os nodename", info.nodename, 1) != 0) return -1;
   if (cfgAddString(pCfg, "os release", info.release, 1) != 0) return -1;
@@ -572,8 +579,8 @@ static int32_t taosSetServerCfg(SConfig *pCfg) {
   return 0;
 }
 
-int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char *cfgDir, const char *envFile,
-                      const char *apolloUrl, SArray *pArgs, bool tsc) {
+int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char **envCmd, const char *cfgDir, const char *envFile,
+                      char *apolloUrl, SArray *pArgs, bool tsc) {
   osDefaultInit();
 
   SConfig *pCfg = cfgInit();
@@ -588,7 +595,7 @@ int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char *cfgDi
     if (taosAddServerLogCfg(pCfg) != 0) return -1;
   }
 
-  if (taosLoadCfg(pCfg, cfgDir, envFile, apolloUrl) != 0) {
+  if (taosLoadCfg(pCfg, envCmd, cfgDir, envFile, apolloUrl) != 0) {
     uError("failed to load cfg since %s", terrstr());
     cfgCleanup(pCfg);
     return -1;
@@ -625,7 +632,7 @@ int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char *cfgDi
   return 0;
 }
 
-int32_t taosInitCfg(const char *cfgDir, const char *envFile, const char *apolloUrl, SArray *pArgs, bool tsc) {
+int32_t taosInitCfg(const char **envCmd, const char *cfgDir, const char *envFile, char *apolloUrl, SArray *pArgs, bool tsc) {
   if (tsCfg != NULL) return 0;
   tsCfg = cfgInit();
 
@@ -640,7 +647,7 @@ int32_t taosInitCfg(const char *cfgDir, const char *envFile, const char *apolloU
   }
   taosAddSystemCfg(tsCfg);
 
-  if (taosLoadCfg(tsCfg, cfgDir, envFile, apolloUrl) != 0) {
+  if (taosLoadCfg(tsCfg, envCmd, cfgDir, envFile, apolloUrl) != 0) {
     uError("failed to load cfg since %s", terrstr());
     cfgCleanup(tsCfg);
     tsCfg = NULL;
diff --git a/source/dnode/mgmt/exe/dmMain.c b/source/dnode/mgmt/exe/dmMain.c
index 4b01c540f7..b85072faf6 100644
--- a/source/dnode/mgmt/exe/dmMain.c
+++ b/source/dnode/mgmt/exe/dmMain.c
@@ -24,6 +24,7 @@ static struct {
   bool         printVersion;
   char         envFile[PATH_MAX];
   char         apolloUrl[PATH_MAX];
+  const char **envCmd;
   SArray      *pArgs;  // SConfigPair
   SDnode      *pDnode;
   EDndNodeType ntype;
@@ -56,6 +57,9 @@ static void dmSetSignalHandle() {
 }
 
 static int32_t dmParseArgs(int32_t argc, char const *argv[]) {
+  int32_t cmdEnvIndex = 0;
+  global.envCmd = taosMemoryMalloc(argc-1);
+  memset(global.envCmd, 0, argc-1);
   for (int32_t i = 1; i < argc; ++i) {
     if (strcmp(argv[i], "-c") == 0) {
       if (i < argc - 1) {
@@ -70,7 +74,7 @@ static int32_t dmParseArgs(int32_t argc, char const *argv[]) {
       }
     } else if (strcmp(argv[i], "-a") == 0) {
       tstrncpy(global.apolloUrl, argv[++i], PATH_MAX);
-    } else if (strcmp(argv[i], "-e") == 0) {
+    } else if (strcmp(argv[i], "-E") == 0) {
       tstrncpy(global.envFile, argv[++i], PATH_MAX);
     } else if (strcmp(argv[i], "-n") == 0) {
       global.ntype = atoi(argv[++i]);
@@ -84,6 +88,9 @@ static int32_t dmParseArgs(int32_t argc, char const *argv[]) {
       global.dumpConfig = true;
     } else if (strcmp(argv[i], "-V") == 0) {
       global.printVersion = true;
+    } else if (strcmp(argv[i], "-e") == 0) {
+      global.envCmd[cmdEnvIndex] = argv[++i];
+      cmdEnvIndex++;
     } else {
     }
   }
@@ -129,7 +136,7 @@ static SDnodeOpt dmGetOpt() {
 static int32_t dmInitLog() {
   char logName[12] = {0};
   snprintf(logName, sizeof(logName), "%slog", dmLogName(global.ntype));
-  return taosCreateLog(logName, 1, configDir, global.envFile, global.apolloUrl, global.pArgs, 0);
+  return taosCreateLog(logName, 1, global.envCmd, configDir, global.envFile, global.apolloUrl, global.pArgs, 0);
 }
 
 static void dmSetProcInfo(int32_t argc, char **argv) {
@@ -168,6 +175,10 @@ static int32_t dmRunDnode() {
   return code;
 }
 
+static void taosCleanupArgs() {
+  if (global.envCmd != NULL) taosMemoryFree(global.envCmd);
+}
+
 int main(int argc, char const *argv[]) {
   if (!taosCheckSystemIsSmallEnd()) {
     printf("failed to start since on non-small-end machines\n");
@@ -176,26 +187,31 @@ int main(int argc, char const *argv[]) {
 
   if (dmParseArgs(argc, argv) != 0) {
     printf("failed to start since parse args error\n");
+    taosCleanupArgs();
     return -1;
   }
 
   if (global.generateGrant) {
     dmGenerateGrant();
+    taosCleanupArgs();
     return 0;
   }
 
   if (global.printVersion) {
     dmPrintVersion();
+    taosCleanupArgs();
     return 0;
   }
 
   if (dmInitLog() != 0) {
-    dError("failed to start since init log error");
+    printf("failed to start since init log error");
+    taosCleanupArgs();
     return -1;
   }
 
-  if (taosInitCfg(configDir, global.envFile, global.apolloUrl, global.pArgs, 0) != 0) {
+  if (taosInitCfg(global.envCmd, configDir, global.envFile, global.apolloUrl, global.pArgs, 0) != 0) {
     dError("failed to start since read config error");
+    taosCleanupArgs();
     return -1;
   }
 
@@ -203,9 +219,11 @@ int main(int argc, char const *argv[]) {
     dmDumpCfg();
     taosCleanupCfg();
     taosCloseLog();
+    taosCleanupArgs();
     return 0;
   }
 
   dmSetProcInfo(argc, (char **)argv);
+  taosCleanupArgs();
   return dmRunDnode();
 }
diff --git a/source/dnode/mgmt/interface/src/dmFile.c b/source/dnode/mgmt/interface/src/dmFile.c
index e9117939d7..38acf169be 100644
--- a/source/dnode/mgmt/interface/src/dmFile.c
+++ b/source/dnode/mgmt/interface/src/dmFile.c
@@ -124,7 +124,7 @@ TdFilePtr dmCheckRunning(const char *dataDir) {
   TdFilePtr pFile = taosOpenFile(filepath, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_TRUNC);
   if (pFile == NULL) {
     terrno = TAOS_SYSTEM_ERROR(errno);
-    dError("failed to lock file:%s since %s", filepath, terrstr());
+    dError("failed to open file:%s since %s", filepath, terrstr());
     return NULL;
   }
 
diff --git a/source/libs/function/src/udfd.c b/source/libs/function/src/udfd.c
index e4c4cb4893..faea595a42 100644
--- a/source/libs/function/src/udfd.c
+++ b/source/libs/function/src/udfd.c
@@ -548,7 +548,7 @@ static int32_t udfdParseArgs(int32_t argc, char *argv[]) {
 static int32_t udfdInitLog() {
   char logName[12] = {0};
   snprintf(logName, sizeof(logName), "%slog", "udfd");
-  return taosCreateLog(logName, 1, configDir, NULL, NULL, NULL, 0);
+  return taosCreateLog(logName, 1, NULL, configDir, NULL, NULL, NULL, 0);
 }
 
 void udfdCtrlAllocBufCb(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf) {
@@ -656,7 +656,7 @@ int main(int argc, char *argv[]) {
     return -1;
   }
 
-  if (taosInitCfg(configDir, NULL, NULL, NULL, 0) != 0) {
+  if (taosInitCfg(NULL, configDir, NULL, NULL, NULL, 0) != 0) {
     fnError("failed to start since read config error");
     return -1;
   }
diff --git a/source/libs/function/test/runUdf.c b/source/libs/function/test/runUdf.c
index 8e5eac538e..9184d3d6e0 100644
--- a/source/libs/function/test/runUdf.c
+++ b/source/libs/function/test/runUdf.c
@@ -31,13 +31,13 @@ static int32_t parseArgs(int32_t argc, char *argv[]) {
 static int32_t initLog() {
   char logName[12] = {0};
   snprintf(logName, sizeof(logName), "%slog", "udfc");
-  return taosCreateLog(logName, 1, configDir, NULL, NULL, NULL, 0);
+  return taosCreateLog(logName, 1, NULL, configDir, NULL, NULL, NULL, 0);
 }
 
 int main(int argc, char *argv[]) {
   parseArgs(argc, argv);
   initLog();
-  if (taosInitCfg(configDir, NULL, NULL, NULL, 0) != 0) {
+  if (taosInitCfg(NULL, configDir, NULL, NULL, NULL, 0) != 0) {
     fnError("failed to start since read config error");
     return -1;
   }
diff --git a/source/libs/sync/CMakeLists.txt b/source/libs/sync/CMakeLists.txt
index cb196acc02..551849c6f2 100644
--- a/source/libs/sync/CMakeLists.txt
+++ b/source/libs/sync/CMakeLists.txt
@@ -11,7 +11,7 @@ target_link_libraries(
 
 target_include_directories(
     sync
-    PUBLIC "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    PUBLIC "${TD_SOURCE_DIR}/include/libs/sync"
     PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
 
diff --git a/source/libs/sync/test/CMakeLists.txt b/source/libs/sync/test/CMakeLists.txt
index 3319a73fcf..8afe9ff2a7 100644
--- a/source/libs/sync/test/CMakeLists.txt
+++ b/source/libs/sync/test/CMakeLists.txt
@@ -199,197 +199,197 @@ target_sources(syncApplyMsgTest
 
 target_include_directories(syncTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncEnvTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncPingTimerTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncIOTickQTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncIOTickPingTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncIOSendMsgTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncIOClientTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncIOServerTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncRaftStoreTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncEnqTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncIndexTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncInitTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncUtilTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncVotesGrantedTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncVotesRespondTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncIndexMgrTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncLogStoreTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncEntryTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncRequestVoteTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncRequestVoteReplyTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncAppendEntriesTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncAppendEntriesReplyTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncClientRequestTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncTimeoutTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncPingTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncPingReplyTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncRpcMsgTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncPingTimerTest2
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncPingSelfTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncElectTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncEncodeTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncWriteTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncReplicateTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncRefTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncLogStoreCheck
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncRaftCfgTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncRespMgrTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncSnapshotTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 target_include_directories(syncApplyMsgTest
     PUBLIC
-    "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
 
diff --git a/source/util/src/tconfig.c b/source/util/src/tconfig.c
index 699a7aa080..5ab349be4c 100644
--- a/source/util/src/tconfig.c
+++ b/source/util/src/tconfig.c
@@ -18,6 +18,9 @@
 #include "taoserror.h"
 #include "tlog.h"
 #include "tutil.h"
+#include "tenv.h"
+#include "cJSON.h"
+#include "tjson.h"
 
 #define CFG_NAME_PRINT_LEN 24
 #define CFG_SRC_PRINT_LEN  12
@@ -25,6 +28,7 @@
 int32_t cfgLoadFromCfgFile(SConfig *pConfig, const char *filepath);
 int32_t cfgLoadFromEnvFile(SConfig *pConfig, const char *filepath);
 int32_t cfgLoadFromEnvVar(SConfig *pConfig);
+int32_t cfgLoadFromEnvCmd(SConfig *pConfig, const char **envCmd);
 int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url);
 int32_t cfgSetItem(SConfig *pConfig, const char *name, const char *value, ECfgSrcType stype);
 
@@ -45,7 +49,7 @@ SConfig *cfgInit() {
   return pCfg;
 }
 
-int32_t cfgLoad(SConfig *pCfg, ECfgSrcType cfgType, const char *sourceStr) {
+int32_t cfgLoad(SConfig *pCfg, ECfgSrcType cfgType, const void *sourceStr) {
   switch (cfgType) {
     case CFG_STYPE_CFG_FILE:
       return cfgLoadFromCfgFile(pCfg, sourceStr);
@@ -55,6 +59,8 @@ int32_t cfgLoad(SConfig *pCfg, ECfgSrcType cfgType, const char *sourceStr) {
       return cfgLoadFromEnvVar(pCfg);
     case CFG_STYPE_APOLLO_URL:
       return cfgLoadFromApollUrl(pCfg, sourceStr);
+    case CFG_STYPE_ENV_CMD:
+      return cfgLoadFromEnvCmd(pCfg, (const char **)sourceStr);
     default:
       return -1;
   }
@@ -463,6 +469,8 @@ const char *cfgStypeStr(ECfgSrcType type) {
       return "arg_list";
     case CFG_STYPE_TAOS_OPTIONS:
       return "taos_options";
+    case CFG_STYPE_ENV_CMD:
+      return "env_cmd";
     default:
       return "invalid";
   }
@@ -584,12 +592,154 @@ void cfgDumpCfg(SConfig *pCfg, bool tsc, bool dump) {
 }
 
 int32_t cfgLoadFromEnvVar(SConfig *pConfig) {
-  uDebug("load from env variables not implemented yet");
+  char   *line = NULL, *name, *value, *value2, *value3;
+  int32_t olen, vlen, vlen2, vlen3;
+  ssize_t _bytes = 0;
+  TdCmdPtr pCmd = taosOpenCmd("set");
+  if (pCmd == NULL) {
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    return -1;
+  }
+  while (!taosEOFCmd(pCmd)) {
+    name = value = value2 = value3 = NULL;
+    olen = vlen = vlen2 = vlen3 = 0;
+
+    _bytes = taosGetLineCmd(pCmd, &line);
+    if (_bytes < 0) {
+      break;
+    }
+    if(line[_bytes - 1] == '\n') line[_bytes - 1] = 0;
+    taosEnvToCfg(line, line);
+
+    paGetToken(line, &name, &olen);
+    if (olen == 0) continue;
+    name[olen] = 0;
+
+    paGetToken(name + olen + 1, &value, &vlen);
+    if (vlen == 0) continue;
+    value[vlen] = 0;
+
+    paGetToken(value + vlen + 1, &value2, &vlen2);
+    if (vlen2 != 0) {
+      value2[vlen2] = 0;
+      paGetToken(value2 + vlen2 + 1, &value3, &vlen3);
+      if (vlen3 != 0) value3[vlen3] = 0;
+    }
+
+    cfgSetItem(pConfig, name, value, CFG_STYPE_ENV_VAR);
+    if (value2 != NULL && value3 != NULL && value2[0] != 0 && value3[0] != 0 && strcasecmp(name, "dataDir") == 0) {
+      cfgSetTfsItem(pConfig, name, value, value2, value3, CFG_STYPE_ENV_VAR);
+    }
+  }
+
+  taosCloseCmd(&pCmd);
+  if (line != NULL) taosMemoryFreeClear(line);
+
+  uInfo("load from env variables cfg success");
   return 0;
 }
 
-int32_t cfgLoadFromEnvFile(SConfig *pConfig, const char *filepath) {
-  uDebug("load from env file not implemented yet");
+int32_t cfgLoadFromEnvCmd(SConfig *pConfig, const char **envCmd) {
+  char   *buf, *name, *value, *value2, *value3;
+  int32_t olen, vlen, vlen2, vlen3;
+  int32_t index = 0;
+  if (envCmd == NULL) return 0;
+  while (envCmd[index]!=NULL) {
+    buf = taosMemoryMalloc(strlen(envCmd[index]));
+    taosEnvToCfg(envCmd[index], buf);
+    index++;
+    
+    name = value = value2 = value3 = NULL;
+    olen = vlen = vlen2 = vlen3 = 0;
+
+    paGetToken(buf, &name, &olen);
+    if (olen == 0) continue;
+    name[olen] = 0;
+
+    paGetToken(name + olen + 1, &value, &vlen);
+    if (vlen == 0) continue;
+    value[vlen] = 0;
+
+    paGetToken(value + vlen + 1, &value2, &vlen2);
+    if (vlen2 != 0) {
+      value2[vlen2] = 0;
+      paGetToken(value2 + vlen2 + 1, &value3, &vlen3);
+      if (vlen3 != 0) value3[vlen3] = 0;
+    }
+
+    cfgSetItem(pConfig, name, value, CFG_STYPE_ENV_CMD);
+    if (value2 != NULL && value3 != NULL && value2[0] != 0 && value3[0] != 0 && strcasecmp(name, "dataDir") == 0) {
+      cfgSetTfsItem(pConfig, name, value, value2, value3, CFG_STYPE_ENV_CMD);
+    }
+
+    taosMemoryFree(buf);
+  }
+
+  uInfo("load from env cmd cfg success");
+  return 0;
+}
+
+int32_t cfgLoadFromEnvFile(SConfig *pConfig, const char *envFile) {
+  char   *line = NULL, *name, *value, *value2, *value3;
+  int32_t olen, vlen, vlen2, vlen3;
+  ssize_t _bytes = 0;
+
+  const char *filepath = ".env";
+  if (envFile != NULL && strlen(envFile)>0) {
+    if (!taosCheckExistFile(envFile)) {
+      uError("fial to load env file: %s", envFile);
+      return -1;
+    }
+    filepath = envFile;
+  }else {
+    if (!taosCheckExistFile(filepath)) {
+      uInfo("fial to load env file: %s", filepath);
+      return 0;
+    }
+  }
+
+  TdFilePtr pFile = taosOpenFile(filepath, TD_FILE_READ | TD_FILE_STREAM);
+  if (pFile == NULL) {
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    return -1;
+  }
+
+  while (!taosEOFFile(pFile)) {
+    name = value = value2 = value3 = NULL;
+    olen = vlen = vlen2 = vlen3 = 0;
+
+    _bytes = taosGetLineFile(pFile, &line);
+    if (_bytes <= 0) {
+      break;
+    }
+    if(line[_bytes - 1] == '\n') line[_bytes - 1] = 0;
+    taosEnvToCfg(line, line);
+
+    paGetToken(line, &name, &olen);
+    if (olen == 0) continue;
+    name[olen] = 0;
+
+    paGetToken(name + olen + 1, &value, &vlen);
+    if (vlen == 0) continue;
+    value[vlen] = 0;
+
+    paGetToken(value + vlen + 1, &value2, &vlen2);
+    if (vlen2 != 0) {
+      value2[vlen2] = 0;
+      paGetToken(value2 + vlen2 + 1, &value3, &vlen3);
+      if (vlen3 != 0) value3[vlen3] = 0;
+    }
+
+    cfgSetItem(pConfig, name, value, CFG_STYPE_ENV_FILE);
+    if (value2 != NULL && value3 != NULL && value2[0] != 0 && value3[0] != 0 && strcasecmp(name, "dataDir") == 0) {
+      cfgSetTfsItem(pConfig, name, value, value2, value3, CFG_STYPE_ENV_FILE);
+    }
+  }
+
+  taosCloseFile(&pFile);
+  if (line != NULL) taosMemoryFreeClear(line);
+
+  uInfo("load from env cfg file %s success", filepath);
   return 0;
 }
 
@@ -617,11 +767,11 @@ int32_t cfgLoadFromCfgFile(SConfig *pConfig, const char *filepath) {
     olen = vlen = vlen2 = vlen3 = 0;
 
     _bytes = taosGetLineFile(pFile, &line);
-    if (_bytes < 0) {
+    if (_bytes <= 0) {
       break;
     }
 
-    line[_bytes - 1] = 0;
+    if(line[_bytes - 1] == '\n') line[_bytes - 1] = 0;
 
     paGetToken(line, &name, &olen);
     if (olen == 0) continue;
@@ -659,6 +809,193 @@ int32_t cfgLoadFromCfgFile(SConfig *pConfig, const char *filepath) {
 }
 
 int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url) {
-  uDebug("load from apoll url not implemented yet");
+  char   *cfgLineBuf = NULL, *name, *value, *value2, *value3;
+  int32_t olen, vlen, vlen2, vlen3;
+  if (url == NULL || strlen(url) == 0) {
+    uInfo("fail to load apoll url");
+    return 0;
+  }
+  
+  char *p = strchr(url, ':');
+  if (p == NULL) {
+    uError("fail to load apoll url: %s, unknown format", url);
+    return -1;
+  }
+  p++;
+
+  if (bcmp(url, "jsonFile", 8) == 0) {
+    char *filepath = p;
+    if (!taosCheckExistFile(filepath)) {
+      uError("fial to load json file: %s", filepath);
+      return -1;
+    }
+
+    TdFilePtr pFile = taosOpenFile(filepath, TD_FILE_READ);
+    if (pFile == NULL) {
+      terrno = TAOS_SYSTEM_ERROR(errno);
+      return -1;
+    }
+    size_t fileSize = taosLSeekFile(pFile, 0, SEEK_END);
+    char *buf = taosMemoryMalloc(fileSize);
+    taosLSeekFile(pFile, 0, SEEK_SET);
+    if(taosReadFile(pFile, buf, fileSize) <= 0) {
+      taosCloseFile(&pFile);
+      uError("load json file error: %s", filepath);
+      return -1;
+    }
+    taosCloseFile(&pFile);
+    SJson* pJson = tjsonParse(buf);
+    if (NULL == pJson) {
+      const char *jsonParseError = tjsonGetError();
+      if (jsonParseError != NULL) {
+        uError("load json file parse error: %s", jsonParseError);
+      }
+      return -1;
+    }
+    taosMemoryFreeClear(buf);
+
+    int32_t jsonArraySize = tjsonGetArraySize(pJson);
+    for(int32_t i = 0; i < jsonArraySize; i++) {
+      cJSON* item = tjsonGetArrayItem(pJson, i);
+      if (item == NULL) break;
+      char *itemName = NULL, *itemValueString = NULL;
+      tjsonGetObjectName(item, &itemName);
+      tjsonGetObjectName(item, &itemName);
+      tjsonGetObjectValueString(item, &itemValueString);
+      if (itemValueString != NULL && itemName != NULL) {
+        size_t itemNameLen = strlen(itemName);
+        size_t itemValueStringLen = strlen(itemValueString);
+        cfgLineBuf = taosMemoryMalloc(itemNameLen + itemValueStringLen + 2);
+        memcpy(cfgLineBuf, itemName, itemNameLen);
+        cfgLineBuf[itemNameLen] = ' ';
+        memcpy(&cfgLineBuf[itemNameLen+1], itemValueString, itemValueStringLen);
+        cfgLineBuf[itemNameLen + itemValueStringLen + 1] = '\0';
+
+        paGetToken(cfgLineBuf, &name, &olen);
+        if (olen == 0) continue;
+        name[olen] = 0;
+
+        paGetToken(name + olen + 1, &value, &vlen);
+        if (vlen == 0) continue;
+        value[vlen] = 0;
+
+        paGetToken(value + vlen + 1, &value2, &vlen2);
+        if (vlen2 != 0) {
+          value2[vlen2] = 0;
+          paGetToken(value2 + vlen2 + 1, &value3, &vlen3);
+          if (vlen3 != 0) value3[vlen3] = 0;
+        }
+        printf("%s(%d) %s name=%s, value=%s\n", __FILE__, __LINE__,__func__,name, value);
+        cfgSetItem(pConfig, name, value, CFG_STYPE_APOLLO_URL);
+        if (value2 != NULL && value3 != NULL && value2[0] != 0 && value3[0] != 0 && strcasecmp(name, "dataDir") == 0) {
+          cfgSetTfsItem(pConfig, name, value, value2, value3, CFG_STYPE_APOLLO_URL);
+        }
+      }
+    }
+    tjsonDelete(pJson);
+
+  // } else if (bcmp(url, "jsonUrl", 7) == 0) {
+  // } else if (bcmp(url, "etcdUrl", 7) == 0) {
+  } else {
+    uError("Unsupported url: %s", url);
+    return -1;
+  }
+
+  uInfo("load from apoll url not implemented yet");
   return 0;
 }
+
+int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char* apolloUrl) {
+  int32_t index = 0;
+  if (envCmd == NULL) return 0;
+  while (envCmd[index]!=NULL) {
+    if (bcmp(envCmd[index], "TAOS_APOLL_URL", 14) == 0) {
+      char *p = strchr(envCmd[index], '=');
+      if (p != NULL) {
+        p++;
+        if (*p == '\'') {
+          p++;
+          p[strlen(p)-1] = '\0';
+        }
+        memcpy(apolloUrl, p, TMIN(strlen(p)+1,PATH_MAX));
+        uInfo("get apollo url from env cmd success");
+        return 0;
+      }
+    }
+    index++;
+  }
+
+  char   *line = NULL;
+  ssize_t _bytes = 0;
+  TdCmdPtr pCmd = taosOpenCmd("set");
+  if (pCmd != NULL) {
+    while (!taosEOFCmd(pCmd)) {
+      _bytes = taosGetLineCmd(pCmd, &line);
+      if (_bytes < 0) {
+        break;
+      }
+      if(line[_bytes - 1] == '\n') line[_bytes - 1] = 0;
+      if (bcmp(line, "TAOS_APOLL_URL", 14) == 0) {
+        char *p = strchr(line, '=');
+        if (p != NULL) {
+          p++;
+          if (*p == '\'') {
+            p++;
+            p[strlen(p)-1] = '\0';
+          }
+          memcpy(apolloUrl, p, TMIN(strlen(p)+1,PATH_MAX));
+          uInfo("get apollo url from env variables success, apolloUrl=%s",apolloUrl);
+          taosCloseCmd(&pCmd);
+          if (line != NULL) taosMemoryFreeClear(line);
+          return 0;
+        }
+      }
+    }
+    taosCloseCmd(&pCmd);
+    if (line != NULL) taosMemoryFreeClear(line);
+  }
+
+  const char *filepath = ".env";
+  if (envFile != NULL && strlen(envFile)>0) {
+    if (!taosCheckExistFile(envFile)) {
+      uError("fial to load env file: %s", envFile);
+      return -1;
+    }
+    filepath = envFile;
+  }else {
+    if (!taosCheckExistFile(filepath)) {
+      uInfo("fial to load env file: %s", filepath);
+      return 0;
+    }
+  }
+  TdFilePtr pFile = taosOpenFile(filepath, TD_FILE_READ | TD_FILE_STREAM);
+  if (pFile != NULL) {
+    while (!taosEOFFile(pFile)) {
+      _bytes = taosGetLineFile(pFile, &line);
+      if (_bytes <= 0) {
+        break;
+      }
+      if(line[_bytes - 1] == '\n') line[_bytes - 1] = 0;
+      if (bcmp(line, "TAOS_APOLL_URL", 14) == 0) {
+        char *p = strchr(line, '=');
+        if (p != NULL) {
+          p++;
+          if (*p == '\'') {
+            p++;
+            p[strlen(p)-1] = '\0';
+          }
+          memcpy(apolloUrl, p, TMIN(strlen(p)+1,PATH_MAX));
+          taosCloseFile(&pFile);
+          if (line != NULL) taosMemoryFreeClear(line);
+          uInfo("get apollo url from env file success");
+          return 0;
+        }
+      }
+    }
+    taosCloseFile(&pFile);
+    if (line != NULL) taosMemoryFreeClear(line);
+  }
+
+  uInfo("fail get apollo url from cmd env file");
+  return -1;
+}
\ No newline at end of file
diff --git a/source/util/src/tenv.c b/source/util/src/tenv.c
new file mode 100644
index 0000000000..e717e82c5b
--- /dev/null
+++ b/source/util/src/tenv.c
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "tenv.h"
+#include "tconfig.h"
+
+static char toLowChar(char c) { return (c > 'Z' || c < 'A' ? c : (c - 'A' + 'a')); }
+
+int32_t taosEnvNameToCfgName(const char *envNameStr, char *cfgNameStr, int32_t cfgNameMaxLen) {
+  if (envNameStr == NULL || cfgNameStr == NULL) return -1;
+  char *p = cfgNameStr;
+  if (envNameStr[0] != 'T' || envNameStr[1] != 'A' || envNameStr[2] != 'O' || envNameStr[3] != 'S' ||
+      envNameStr[4] != '_') {
+    // if(p != envNameStr) strncpy(p, envNameStr, cfgNameMaxLen - 1);
+    // p[cfgNameMaxLen - 1] = '\0';
+    // return strlen(cfgNameStr);
+    cfgNameStr[0] = '\0';
+    return -1;
+  }
+  envNameStr += 5;
+  if (*envNameStr != '\0') {
+    *p = toLowChar(*envNameStr);
+    p++;
+    envNameStr++;
+  }
+
+  for (size_t i = 1; i < cfgNameMaxLen && *envNameStr != '\0'; i++) {
+    if (*envNameStr == '_') {
+      envNameStr++;
+      *p = *envNameStr;
+      if (*envNameStr == '\0') break;
+    } else {
+      *p = toLowChar(*envNameStr);
+    }
+    p++;
+    envNameStr++;
+  }
+
+  *p = '\0';
+  return strlen(cfgNameStr);
+}
+
+int32_t taosEnvToCfg(const char *envStr, char *cfgStr) {
+  if (envStr == NULL && cfgStr == NULL) {
+    return -1;
+  }
+  if (cfgStr != envStr) strcpy(cfgStr, envStr);
+  char *p = strchr(cfgStr, '=');
+  
+  if (p != NULL) {
+    char buf[CFG_NAME_MAX_LEN];
+    if (*(p+1) == '\'') {
+      *(p+1)= ' ';
+      char *pEnd = &cfgStr[strlen(cfgStr)-1];
+      if (*pEnd == '\'') *pEnd = '\0';
+    }
+    *p = '\0';
+    int32_t cfgNameLen = taosEnvNameToCfgName(cfgStr, buf, CFG_NAME_MAX_LEN);
+    if (cfgNameLen > 0) {
+      memcpy(cfgStr, buf, cfgNameLen);
+      memset(&cfgStr[cfgNameLen], ' ', p - cfgStr - cfgNameLen + 1);
+    }
+  }
+  return strlen(cfgStr);
+}
\ No newline at end of file
diff --git a/source/util/src/tjson.c b/source/util/src/tjson.c
index 0b9727e0bf..558c2258f4 100644
--- a/source/util/src/tjson.c
+++ b/source/util/src/tjson.c
@@ -144,6 +144,22 @@ char* tjsonToUnformattedString(const SJson* pJson) { return cJSON_PrintUnformatt
 
 SJson* tjsonGetObjectItem(const SJson* pJson, const char* pName) { return cJSON_GetObjectItem(pJson, pName); }
 
+int32_t tjsonGetObjectName(const SJson* pJson, char** pName) {
+  *pName = ((cJSON*)pJson)->string;
+  if (NULL == *pName) {
+    return TSDB_CODE_FAILED;
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t tjsonGetObjectValueString(const SJson* pJson, char** pValueString) {
+  *pValueString = ((cJSON*)pJson)->valuestring;
+  if (NULL == *pValueString) {
+    return TSDB_CODE_FAILED;
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
 int32_t tjsonGetStringValue(const SJson* pJson, const char* pName, char* pVal) {
   char* p = cJSON_GetStringValue(tjsonGetObjectItem((cJSON*)pJson, pName));
   if (NULL == p) {
@@ -309,4 +325,6 @@ bool tjsonValidateJson(const char *jIn) {
     }
   }
   return true;
-}
\ No newline at end of file
+}
+
+const char* tjsonGetError() { return cJSON_GetErrorPtr(); }
\ No newline at end of file
diff --git a/source/util/test/CMakeLists.txt b/source/util/test/CMakeLists.txt
index d98f9f677d..3c52d52d50 100644
--- a/source/util/test/CMakeLists.txt
+++ b/source/util/test/CMakeLists.txt
@@ -31,7 +31,7 @@ ENDIF()
 #    TARGET_LINK_LIBRARIES(trefTest util common)
 #ENDIF ()
 
-INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
+INCLUDE_DIRECTORIES(${TD_SOURCE_DIR}/src/util/inc)
 
 # freelistTest
 add_executable(freelistTest "")
diff --git a/source/util/test/cfgTest.cpp b/source/util/test/cfgTest.cpp
index 712fb2d09a..cd13ebe8ae 100644
--- a/source/util/test/cfgTest.cpp
+++ b/source/util/test/cfgTest.cpp
@@ -32,6 +32,7 @@ TEST_F(CfgTest, 01_Str) {
   EXPECT_STREQ(cfgStypeStr(CFG_STYPE_CFG_FILE), "cfg_file");
   EXPECT_STREQ(cfgStypeStr(CFG_STYPE_ENV_FILE), "env_file");
   EXPECT_STREQ(cfgStypeStr(CFG_STYPE_ENV_VAR), "env_var");
+  EXPECT_STREQ(cfgStypeStr(CFG_STYPE_ENV_CMD), "env_cmd");
   EXPECT_STREQ(cfgStypeStr(CFG_STYPE_APOLLO_URL), "apollo_url");
   EXPECT_STREQ(cfgStypeStr(CFG_STYPE_ARG_LIST), "arg_list");
   EXPECT_STREQ(cfgStypeStr(ECfgSrcType(1024)), "invalid");
diff --git a/tests/tsim/src/simSystem.c b/tests/tsim/src/simSystem.c
index 5bbcceada5..57fc7717f5 100644
--- a/tests/tsim/src/simSystem.c
+++ b/tests/tsim/src/simSystem.c
@@ -28,8 +28,8 @@ char     simScriptDir[PATH_MAX] = {0};
 extern bool simExecSuccess;
 
 int32_t simInitCfg() {
-  taosCreateLog("simlog", 1, configDir, NULL, NULL, NULL, 1);
-  taosInitCfg(configDir, NULL, NULL, NULL, 1);
+  taosCreateLog("simlog", 1, NULL, configDir, NULL, NULL, NULL, 1);
+  taosInitCfg(NULL, configDir, NULL, NULL, NULL, 1);
 
   SConfig *pCfg = taosGetCfg();
   simDebugFlag = cfgGetItem(pCfg, "simDebugFlag")->i32;
diff --git a/tools/shell/CMakeLists.txt b/tools/shell/CMakeLists.txt
index 3b22b30852..284693795e 100644
--- a/tools/shell/CMakeLists.txt
+++ b/tools/shell/CMakeLists.txt
@@ -3,7 +3,7 @@ aux_source_directory(src SHELL_SRC)
 add_executable(shell ${SHELL_SRC})
 target_link_libraries(
     shell
-    PUBLIC taos_static
+    PUBLIC taos
     PRIVATE os common transport util
 )
 target_include_directories(

From 276eb84746dba3ae8e0d157e6daa77fe47b91927 Mon Sep 17 00:00:00 2001
From: afwerar <1296468573@qq.com>
Date: Mon, 25 Apr 2022 14:05:09 +0800
Subject: [PATCH 11/23] feature(dnode): mul parameter start.

---
 include/common/tglobal.h           | 4 ++--
 source/client/src/clientEnv.c      | 4 ++--
 source/common/src/tglobal.c        | 4 ++--
 source/dnode/mgmt/exe/dmMain.c     | 4 ++--
 source/libs/function/src/udfd.c    | 4 ++--
 source/libs/function/test/runUdf.c | 4 ++--
 tests/tsim/src/simSystem.c         | 4 ++--
 7 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/include/common/tglobal.h b/include/common/tglobal.h
index cde423c3cd..fc3d575317 100644
--- a/include/common/tglobal.h
+++ b/include/common/tglobal.h
@@ -123,9 +123,9 @@ extern SDiskCfg tsDiskCfg[];
 
 #define NEEDTO_COMPRESSS_MSG(size) (tsCompressMsgSize != -1 && (size) > tsCompressMsgSize)
 
-int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char **envCmd, const char *cfgDir, const char *envFile,
+int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char *cfgDir, const char **envCmd, const char *envFile,
                       char *apolloUrl, SArray *pArgs, bool tsc);
-int32_t taosInitCfg(const char **envCmd, const char *cfgDir, const char *envFile, char *apolloUrl, SArray *pArgs, bool tsc);
+int32_t taosInitCfg(const char *cfgDir, const char **envCmd, const char *envFile, char *apolloUrl, SArray *pArgs, bool tsc);
 void    taosCleanupCfg();
 void    taosCfgDynamicOptions(const char *option, const char *value);
 void    taosAddDataDir(int32_t index, char *v1, int32_t level, int32_t primary);
diff --git a/source/client/src/clientEnv.c b/source/client/src/clientEnv.c
index 56eab18a55..596c3d3fbf 100644
--- a/source/client/src/clientEnv.c
+++ b/source/client/src/clientEnv.c
@@ -254,12 +254,12 @@ void taos_init_imp(void) {
 
   deltaToUtcInitOnce();
 
-  if (taosCreateLog("taoslog", 10, NULL, configDir, NULL, NULL, NULL, 1) != 0) {
+  if (taosCreateLog("taoslog", 10, configDir, NULL, NULL, NULL, NULL, 1) != 0) {
     tscInitRes = -1;
     return;
   }
 
-  if (taosInitCfg(NULL, configDir, NULL, NULL, NULL, 1) != 0) {
+  if (taosInitCfg(configDir, NULL, NULL, NULL, NULL, 1) != 0) {
     tscInitRes = -1;
     return;
   }
diff --git a/source/common/src/tglobal.c b/source/common/src/tglobal.c
index c74f53f0a0..bbf14b2fdc 100644
--- a/source/common/src/tglobal.c
+++ b/source/common/src/tglobal.c
@@ -579,7 +579,7 @@ static int32_t taosSetServerCfg(SConfig *pCfg) {
   return 0;
 }
 
-int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char **envCmd, const char *cfgDir, const char *envFile,
+int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char *cfgDir, const char **envCmd, const char *envFile,
                       char *apolloUrl, SArray *pArgs, bool tsc) {
   osDefaultInit();
 
@@ -632,7 +632,7 @@ int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char **envC
   return 0;
 }
 
-int32_t taosInitCfg(const char **envCmd, const char *cfgDir, const char *envFile, char *apolloUrl, SArray *pArgs, bool tsc) {
+int32_t taosInitCfg(const char *cfgDir, const char **envCmd, const char *envFile, char *apolloUrl, SArray *pArgs, bool tsc) {
   if (tsCfg != NULL) return 0;
   tsCfg = cfgInit();
 
diff --git a/source/dnode/mgmt/exe/dmMain.c b/source/dnode/mgmt/exe/dmMain.c
index b85072faf6..43237e6e6c 100644
--- a/source/dnode/mgmt/exe/dmMain.c
+++ b/source/dnode/mgmt/exe/dmMain.c
@@ -136,7 +136,7 @@ static SDnodeOpt dmGetOpt() {
 static int32_t dmInitLog() {
   char logName[12] = {0};
   snprintf(logName, sizeof(logName), "%slog", dmLogName(global.ntype));
-  return taosCreateLog(logName, 1, global.envCmd, configDir, global.envFile, global.apolloUrl, global.pArgs, 0);
+  return taosCreateLog(logName, 1, configDir, global.envCmd, global.envFile, global.apolloUrl, global.pArgs, 0);
 }
 
 static void dmSetProcInfo(int32_t argc, char **argv) {
@@ -209,7 +209,7 @@ int main(int argc, char const *argv[]) {
     return -1;
   }
 
-  if (taosInitCfg(global.envCmd, configDir, global.envFile, global.apolloUrl, global.pArgs, 0) != 0) {
+  if (taosInitCfg(configDir, global.envCmd, global.envFile, global.apolloUrl, global.pArgs, 0) != 0) {
     dError("failed to start since read config error");
     taosCleanupArgs();
     return -1;
diff --git a/source/libs/function/src/udfd.c b/source/libs/function/src/udfd.c
index faea595a42..11bbd6442c 100644
--- a/source/libs/function/src/udfd.c
+++ b/source/libs/function/src/udfd.c
@@ -548,7 +548,7 @@ static int32_t udfdParseArgs(int32_t argc, char *argv[]) {
 static int32_t udfdInitLog() {
   char logName[12] = {0};
   snprintf(logName, sizeof(logName), "%slog", "udfd");
-  return taosCreateLog(logName, 1, NULL, configDir, NULL, NULL, NULL, 0);
+  return taosCreateLog(logName, 1, configDir, NULL, NULL, NULL, NULL, 0);
 }
 
 void udfdCtrlAllocBufCb(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf) {
@@ -656,7 +656,7 @@ int main(int argc, char *argv[]) {
     return -1;
   }
 
-  if (taosInitCfg(NULL, configDir, NULL, NULL, NULL, 0) != 0) {
+  if (taosInitCfg(configDir, NULL, NULL, NULL, NULL, 0) != 0) {
     fnError("failed to start since read config error");
     return -1;
   }
diff --git a/source/libs/function/test/runUdf.c b/source/libs/function/test/runUdf.c
index 9184d3d6e0..a8d6fbd715 100644
--- a/source/libs/function/test/runUdf.c
+++ b/source/libs/function/test/runUdf.c
@@ -31,13 +31,13 @@ static int32_t parseArgs(int32_t argc, char *argv[]) {
 static int32_t initLog() {
   char logName[12] = {0};
   snprintf(logName, sizeof(logName), "%slog", "udfc");
-  return taosCreateLog(logName, 1, NULL, configDir, NULL, NULL, NULL, 0);
+  return taosCreateLog(logName, 1, configDir, NULL, NULL, NULL, NULL, 0);
 }
 
 int main(int argc, char *argv[]) {
   parseArgs(argc, argv);
   initLog();
-  if (taosInitCfg(NULL, configDir, NULL, NULL, NULL, 0) != 0) {
+  if (taosInitCfg(configDir, NULL, NULL, NULL, NULL, 0) != 0) {
     fnError("failed to start since read config error");
     return -1;
   }
diff --git a/tests/tsim/src/simSystem.c b/tests/tsim/src/simSystem.c
index 57fc7717f5..69f15a164e 100644
--- a/tests/tsim/src/simSystem.c
+++ b/tests/tsim/src/simSystem.c
@@ -28,8 +28,8 @@ char     simScriptDir[PATH_MAX] = {0};
 extern bool simExecSuccess;
 
 int32_t simInitCfg() {
-  taosCreateLog("simlog", 1, NULL, configDir, NULL, NULL, NULL, 1);
-  taosInitCfg(NULL, configDir, NULL, NULL, NULL, 1);
+  taosCreateLog("simlog", 1, configDir, NULL, NULL, NULL, NULL, 1);
+  taosInitCfg(configDir, NULL, NULL, NULL, NULL, 1);
 
   SConfig *pCfg = taosGetCfg();
   simDebugFlag = cfgGetItem(pCfg, "simDebugFlag")->i32;

From 758a155c92c111658e815b44f96f69cb9057ded7 Mon Sep 17 00:00:00 2001
From: plum-lihui <huili@taosdata.com>
Date: Mon, 25 Apr 2022 14:13:46 +0800
Subject: [PATCH 12/23] [test: modify deploy scripte]

---
 tests/script/sh/massiveTable/compileVersion.sh | 18 ++----------------
 1 file changed, 2 insertions(+), 16 deletions(-)

diff --git a/tests/script/sh/massiveTable/compileVersion.sh b/tests/script/sh/massiveTable/compileVersion.sh
index dcd1f8aeea..6b45e98ea3 100755
--- a/tests/script/sh/massiveTable/compileVersion.sh
+++ b/tests/script/sh/massiveTable/compileVersion.sh
@@ -57,7 +57,8 @@ function compileTDengineVersion() {
     
     cd ${debugDir}
     cmake ..
-    make -j24    
+    make -j24   
+    make install
 }
 ########################################################################################
 ###############################  main process ##########################################
@@ -67,20 +68,5 @@ cd ${projectDir}
 gitPullBranchInfo $TDengineBrVer
 compileTDengineVersion
 
-taos_dir=${projectDir}/debug/build/bin
-taosd_dir=${projectDir}/debug/build/bin
-exec_process_dir=${projectDir}/debug/build/bin
-
-rm -f /usr/bin/taos
-rm -f /usr/bin/taosd
-rm -f /usr/bin/create_table
-rm -f /usr/bin/tmq_demo
-rm -f /usr/bin/tmq_sim
-
-ln -s $taos_dir/taos /usr/bin/taos
-ln -s $taosd_dir/taosd /usr/bin/taosd
-ln -s $exec_process_dir/create_table /usr/bin/create_table
-ln -s $exec_process_dir/tmq_demo /usr/bin/tmq_demo
-ln -s $exec_process_dir/tmq_sim /usr/bin/tmq_sim
 
 

From 970f2d788e37ebc63f9c703572eece199d91dcc7 Mon Sep 17 00:00:00 2001
From: Ganlin Zhao <ganlinzhao@hotmail.com>
Date: Mon, 25 Apr 2022 14:47:54 +0800
Subject: [PATCH 13/23] fix(query): count function result on stable
 inconsistant with normal table

TD-15116
---
 source/libs/executor/src/executorimpl.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/source/libs/executor/src/executorimpl.c b/source/libs/executor/src/executorimpl.c
index 32c3a60b0f..41122ab7b1 100644
--- a/source/libs/executor/src/executorimpl.c
+++ b/source/libs/executor/src/executorimpl.c
@@ -3828,6 +3828,9 @@ int32_t setSDataBlockFromFetchRsp(SSDataBlock* pRes, SLoadRemoteDataInfo* pLoadI
       }
 
       memcpy(pColInfoData->pData, pStart, colLen[i]);
+      //TODO setting this flag to true temporarily so aggregate function on stable will
+      //examine NULL value for non-primary key column
+      pColInfoData->hasNull = true;
       pStart += colLen[i];
     }
   } else {  // extract data according to pColList

From 50cd7bfe4a67abc5c86ca07201b75b466160677e Mon Sep 17 00:00:00 2001
From: afwerar <1296468573@qq.com>
Date: Mon, 25 Apr 2022 15:33:36 +0800
Subject: [PATCH 14/23] feature(dnode): param name error.

---
 source/util/src/tconfig.c | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/source/util/src/tconfig.c b/source/util/src/tconfig.c
index 5ab349be4c..ee4236dce5 100644
--- a/source/util/src/tconfig.c
+++ b/source/util/src/tconfig.c
@@ -885,7 +885,6 @@ int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url) {
           paGetToken(value2 + vlen2 + 1, &value3, &vlen3);
           if (vlen3 != 0) value3[vlen3] = 0;
         }
-        printf("%s(%d) %s name=%s, value=%s\n", __FILE__, __LINE__,__func__,name, value);
         cfgSetItem(pConfig, name, value, CFG_STYPE_APOLLO_URL);
         if (value2 != NULL && value3 != NULL && value2[0] != 0 && value3[0] != 0 && strcasecmp(name, "dataDir") == 0) {
           cfgSetTfsItem(pConfig, name, value, value2, value3, CFG_STYPE_APOLLO_URL);
@@ -909,7 +908,7 @@ int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char* apolloUrl
   int32_t index = 0;
   if (envCmd == NULL) return 0;
   while (envCmd[index]!=NULL) {
-    if (bcmp(envCmd[index], "TAOS_APOLL_URL", 14) == 0) {
+    if (bcmp(envCmd[index], "TAOS_APOLLO_URL", 14) == 0) {
       char *p = strchr(envCmd[index], '=');
       if (p != NULL) {
         p++;
@@ -935,7 +934,7 @@ int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char* apolloUrl
         break;
       }
       if(line[_bytes - 1] == '\n') line[_bytes - 1] = 0;
-      if (bcmp(line, "TAOS_APOLL_URL", 14) == 0) {
+      if (bcmp(line, "TAOS_APOLLO_URL", 14) == 0) {
         char *p = strchr(line, '=');
         if (p != NULL) {
           p++;
@@ -976,7 +975,7 @@ int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char* apolloUrl
         break;
       }
       if(line[_bytes - 1] == '\n') line[_bytes - 1] = 0;
-      if (bcmp(line, "TAOS_APOLL_URL", 14) == 0) {
+      if (bcmp(line, "TAOS_APOLLO_URL", 14) == 0) {
         char *p = strchr(line, '=');
         if (p != NULL) {
           p++;

From 609b21647bb771bbb4487c18fc6f68103de33e9e Mon Sep 17 00:00:00 2001
From: Liu Jicong <liujicong@qq.com>
Date: Mon, 25 Apr 2022 15:40:25 +0800
Subject: [PATCH 15/23] fix: msg with schema

---
 example/src/tmq.c                          |   7 +-
 include/common/tmsg.h                      | 110 ++++++---------------
 source/client/inc/clientInt.h              |   4 +
 source/client/src/clientImpl.c             |  29 +++---
 source/client/src/tmq.c                    |   6 +-
 source/dnode/mnode/impl/src/mndScheduler.c |  91 ++++++++---------
 source/dnode/mnode/impl/src/mndTopic.c     |   7 +-
 source/dnode/vnode/src/tq/tq.c             |  30 ++++--
 source/dnode/vnode/src/tq/tqRead.c         |  66 +++++++++----
 9 files changed, 178 insertions(+), 172 deletions(-)

diff --git a/example/src/tmq.c b/example/src/tmq.c
index 32390f71c9..56f210081b 100644
--- a/example/src/tmq.c
+++ b/example/src/tmq.c
@@ -103,8 +103,8 @@ int32_t create_topic() {
   }
   taos_free_result(pRes);
 
-  /*pRes = taos_query(pConn, "create topic topic_ctb_column as abc1");*/
-  pRes = taos_query(pConn, "create topic topic_ctb_column as select ts, c1, c2, c3 from ct1");
+  pRes = taos_query(pConn, "create topic topic_ctb_column as abc1");
+  /*pRes = taos_query(pConn, "create topic topic_ctb_column as select ts, c1, c2, c3 from ct1");*/
   if (taos_errno(pRes) != 0) {
     printf("failed to create topic topic_ctb_column, reason:%s\n", taos_errstr(pRes));
     return -1;
@@ -162,9 +162,10 @@ tmq_t* build_consumer() {
   tmq_conf_set(conf, "group.id", "tg2");
   tmq_conf_set(conf, "td.connect.user", "root");
   tmq_conf_set(conf, "td.connect.pass", "taosdata");
-  tmq_conf_set(conf, "td.connect.db", "abc1");
+  /*tmq_conf_set(conf, "td.connect.db", "abc1");*/
   tmq_conf_set_offset_commit_cb(conf, tmq_commit_cb_print);
   tmq_t* tmq = tmq_consumer_new(conf, NULL, 0);
+  assert(tmq);
   return tmq;
 }
 
diff --git a/include/common/tmsg.h b/include/common/tmsg.h
index 5a2dd502c1..a07101f404 100644
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@@ -2052,80 +2052,6 @@ static FORCE_INLINE void* tDecodeSMqSetCVgReq(void* buf, SMqSetCVgReq* pReq) {
   return buf;
 }
 
-typedef struct {
-  int64_t leftForVer;
-  int32_t vgId;
-  int32_t epoch;
-  int64_t consumerId;
-  char    topicName[TSDB_TOPIC_FNAME_LEN];
-} SMqCancelConnReq;
-
-static FORCE_INLINE int32_t tEncodeSMqCancelConnReq(void** buf, const SMqCancelConnReq* pReq) {
-  int32_t tlen = 0;
-  tlen += taosEncodeFixedI64(buf, pReq->leftForVer);
-  tlen += taosEncodeFixedI32(buf, pReq->vgId);
-  tlen += taosEncodeFixedI32(buf, pReq->epoch);
-  tlen += taosEncodeFixedI64(buf, pReq->consumerId);
-  tlen += taosEncodeString(buf, pReq->topicName);
-  return tlen;
-}
-
-static FORCE_INLINE void* tDecodeSMqCancelConnReq(void* buf, SMqCancelConnReq* pReq) {
-  buf = taosDecodeFixedI64(buf, &pReq->leftForVer);
-  buf = taosDecodeFixedI32(buf, &pReq->vgId);
-  buf = taosDecodeFixedI32(buf, &pReq->epoch);
-  buf = taosDecodeFixedI64(buf, &pReq->consumerId);
-  buf = taosDecodeStringTo(buf, pReq->topicName);
-  return buf;
-}
-
-typedef struct {
-  int8_t reserved;
-} SMqCancelConnRsp;
-
-typedef struct {
-  int64_t leftForVer;
-  int32_t vgId;
-  int64_t oldConsumerId;
-  int64_t newConsumerId;
-  char*   topic;
-} SMqMVRebReq;
-
-static FORCE_INLINE int32_t tEncodeSMqMVRebReq(void** buf, const SMqMVRebReq* pReq) {
-  int32_t tlen = 0;
-  tlen += taosEncodeFixedI64(buf, pReq->leftForVer);
-  tlen += taosEncodeFixedI32(buf, pReq->vgId);
-  tlen += taosEncodeFixedI64(buf, pReq->oldConsumerId);
-  tlen += taosEncodeFixedI64(buf, pReq->newConsumerId);
-  tlen += taosEncodeString(buf, pReq->topic);
-  return tlen;
-}
-
-static FORCE_INLINE void* tDecodeSMqMVRebReq(void* buf, SMqMVRebReq* pReq) {
-  buf = taosDecodeFixedI64(buf, &pReq->leftForVer);
-  buf = taosDecodeFixedI32(buf, &pReq->vgId);
-  buf = taosDecodeFixedI64(buf, &pReq->oldConsumerId);
-  buf = taosDecodeFixedI64(buf, &pReq->newConsumerId);
-  buf = taosDecodeString(buf, &pReq->topic);
-  return buf;
-}
-
-typedef struct {
-  SMsgHead header;
-  int32_t  vgId;
-  int64_t  consumerId;
-  char     topicName[TSDB_TOPIC_FNAME_LEN];
-  char     cgroup[TSDB_CGROUP_LEN];
-} SMqSetCVgRsp;
-
-typedef struct {
-  SMsgHead header;
-  int32_t  vgId;
-  int64_t  consumerId;
-  char     topicName[TSDB_TOPIC_FNAME_LEN];
-  char     cgroup[TSDB_CGROUP_LEN];
-} SMqMVRebRsp;
-
 typedef struct {
   int32_t vgId;
   int64_t offset;
@@ -2152,6 +2078,24 @@ typedef struct {
   SSchema* pSchema;
 } SSchemaWrapper;
 
+static FORCE_INLINE SSchemaWrapper* tCloneSSchemaWrapper(const SSchemaWrapper* pSchemaWrapper) {
+  SSchemaWrapper* pSW = (SSchemaWrapper*)taosMemoryMalloc(sizeof(SSchemaWrapper));
+  if (pSW == NULL) return pSW;
+  pSW->nCols = pSchemaWrapper->nCols;
+  pSW->pSchema = (SSchema*)taosMemoryCalloc(pSW->nCols, sizeof(SSchema));
+  if (pSW->pSchema == NULL) {
+    taosMemoryFree(pSW);
+    return NULL;
+  }
+  memcpy(pSW->pSchema, pSchemaWrapper->pSchema, pSW->nCols * sizeof(SSchema));
+  return pSW;
+}
+
+static FORCE_INLINE void tDeleteSSchemaWrapper(SSchemaWrapper* pSchemaWrapper) {
+  taosMemoryFree(pSchemaWrapper->pSchema);
+  taosMemoryFree(pSchemaWrapper);
+}
+
 static FORCE_INLINE int32_t taosEncodeSSchema(void** buf, const SSchema* pSchema) {
   int32_t tlen = 0;
   tlen += taosEncodeFixedI8(buf, pSchema->type);
@@ -2162,13 +2106,13 @@ static FORCE_INLINE int32_t taosEncodeSSchema(void** buf, const SSchema* pSchema
   return tlen;
 }
 
-static FORCE_INLINE void* taosDecodeSSchema(void* buf, SSchema* pSchema) {
+static FORCE_INLINE void* taosDecodeSSchema(const void* buf, SSchema* pSchema) {
   buf = taosDecodeFixedI8(buf, &pSchema->type);
   buf = taosDecodeFixedI8(buf, &pSchema->flags);
   buf = taosDecodeFixedI32(buf, &pSchema->bytes);
   buf = taosDecodeFixedI16(buf, &pSchema->colId);
   buf = taosDecodeStringTo(buf, pSchema->name);
-  return buf;
+  return (void*)buf;
 }
 
 static FORCE_INLINE int32_t tEncodeSSchema(SCoder* pEncoder, const SSchema* pSchema) {
@@ -2198,7 +2142,7 @@ static FORCE_INLINE int32_t taosEncodeSSchemaWrapper(void** buf, const SSchemaWr
   return tlen;
 }
 
-static FORCE_INLINE void* taosDecodeSSchemaWrapper(void* buf, SSchemaWrapper* pSW) {
+static FORCE_INLINE void* taosDecodeSSchemaWrapper(const void* buf, SSchemaWrapper* pSW) {
   buf = taosDecodeFixedU32(buf, &pSW->nCols);
   pSW->pSchema = (SSchema*)taosMemoryCalloc(pSW->nCols, sizeof(SSchema));
   if (pSW->pSchema == NULL) {
@@ -2208,7 +2152,7 @@ static FORCE_INLINE void* taosDecodeSSchemaWrapper(void* buf, SSchemaWrapper* pS
   for (int32_t i = 0; i < pSW->nCols; i++) {
     buf = taosDecodeSSchema(buf, &pSW->pSchema[i]);
   }
-  return buf;
+  return (void*)buf;
 }
 
 static FORCE_INLINE int32_t tEncodeSSchemaWrapper(SCoder* pEncoder, const SSchemaWrapper* pSW) {
@@ -2615,6 +2559,10 @@ static FORCE_INLINE int32_t tEncodeSMqDataBlkRsp(void** buf, const SMqDataBlkRsp
       void*   data = taosArrayGetP(pRsp->blockData, i);
       tlen += taosEncodeFixedI32(buf, bLen);
       tlen += taosEncodeBinary(buf, data, bLen);
+      if (pRsp->withSchema) {
+        SSchemaWrapper* pSW = (SSchemaWrapper*)taosArrayGetP(pRsp->blockSchema, i);
+        tlen += taosEncodeSSchemaWrapper(buf, pSW);
+      }
     }
   }
   return tlen;
@@ -2627,6 +2575,7 @@ static FORCE_INLINE void* tDecodeSMqDataBlkRsp(const void* buf, SMqDataBlkRsp* p
   buf = taosDecodeFixedI32(buf, &pRsp->blockNum);
   pRsp->blockData = taosArrayInit(pRsp->blockNum, sizeof(void*));
   pRsp->blockDataLen = taosArrayInit(pRsp->blockNum, sizeof(void*));
+  pRsp->blockSchema = taosArrayInit(pRsp->blockNum, sizeof(void*));
   if (pRsp->blockNum != 0) {
     buf = taosDecodeFixedI8(buf, &pRsp->withTbName);
     buf = taosDecodeFixedI8(buf, &pRsp->withSchema);
@@ -2639,6 +2588,11 @@ static FORCE_INLINE void* tDecodeSMqDataBlkRsp(const void* buf, SMqDataBlkRsp* p
       buf = taosDecodeBinary(buf, &data, bLen);
       taosArrayPush(pRsp->blockDataLen, &bLen);
       taosArrayPush(pRsp->blockData, &data);
+      if (pRsp->withSchema) {
+        SSchemaWrapper* pSW = (SSchemaWrapper*)taosMemoryMalloc(sizeof(SSchemaWrapper));
+        buf = taosDecodeSSchemaWrapper(buf, pSW);
+        taosArrayPush(pRsp->blockSchema, &pSW);
+      }
     }
   }
   return (void*)buf;
diff --git a/source/client/inc/clientInt.h b/source/client/inc/clientInt.h
index 814caf330a..c0237a184a 100644
--- a/source/client/inc/clientInt.h
+++ b/source/client/inc/clientInt.h
@@ -231,6 +231,10 @@ static FORCE_INLINE SReqResultInfo* tmqGetNextResInfo(TAOS_RES* res, bool conver
   msg->resIter++;
   if (msg->resIter < msg->rsp.blockNum) {
     SRetrieveTableRsp* pRetrieve = (SRetrieveTableRsp*)taosArrayGetP(msg->rsp.blockData, msg->resIter);
+    if (msg->rsp.withSchema) {
+      SSchemaWrapper* pSW = (SSchemaWrapper*)taosArrayGetP(msg->rsp.blockSchema, msg->resIter);
+      setResSchemaInfo(&msg->resInfo, pSW->pSchema, pSW->nCols);
+    }
     setQueryResultFromRsp(&msg->resInfo, pRetrieve, convertUcs4);
     return &msg->resInfo;
   }
diff --git a/source/client/src/clientImpl.c b/source/client/src/clientImpl.c
index 2ae9a11803..a40edbb65a 100644
--- a/source/client/src/clientImpl.c
+++ b/source/client/src/clientImpl.c
@@ -226,17 +226,15 @@ int32_t execDdlQuery(SRequestObj* pRequest, SQuery* pQuery) {
 
 int32_t getPlan(SRequestObj* pRequest, SQuery* pQuery, SQueryPlan** pPlan, SArray* pNodeList) {
   pRequest->type = pQuery->msgType;
-  SPlanContext cxt = {
-    .queryId = pRequest->requestId,
-    .acctId = pRequest->pTscObj->acctId,
-    .mgmtEpSet = getEpSet_s(&pRequest->pTscObj->pAppInfo->mgmtEp),
-    .pAstRoot = pQuery->pRoot,
-    .showRewrite = pQuery->showRewrite,
-    .pTransporter = pRequest->pTscObj->pAppInfo->pTransporter,
-    .pMsg = pRequest->msgBuf,
-    .msgLen = ERROR_MSG_BUF_DEFAULT_SIZE
-  };
-  int32_t code = catalogGetHandle(pRequest->pTscObj->pAppInfo->clusterId, &cxt.pCatalog);
+  SPlanContext cxt = {.queryId = pRequest->requestId,
+                      .acctId = pRequest->pTscObj->acctId,
+                      .mgmtEpSet = getEpSet_s(&pRequest->pTscObj->pAppInfo->mgmtEp),
+                      .pAstRoot = pQuery->pRoot,
+                      .showRewrite = pQuery->showRewrite,
+                      .pTransporter = pRequest->pTscObj->pAppInfo->pTransporter,
+                      .pMsg = pRequest->msgBuf,
+                      .msgLen = ERROR_MSG_BUF_DEFAULT_SIZE};
+  int32_t      code = catalogGetHandle(pRequest->pTscObj->pAppInfo->clusterId, &cxt.pCatalog);
   if (TSDB_CODE_SUCCESS == code) {
     code = qCreateQueryPlan(&cxt, pPlan, pNodeList);
   }
@@ -247,6 +245,7 @@ void setResSchemaInfo(SReqResultInfo* pResInfo, const SSchema* pSchema, int32_t
   ASSERT(pSchema != NULL && numOfCols > 0);
 
   pResInfo->numOfCols = numOfCols;
+  // TODO handle memory leak
   pResInfo->fields = taosMemoryCalloc(numOfCols, sizeof(TAOS_FIELD));
   pResInfo->userFields = taosMemoryCalloc(numOfCols, sizeof(TAOS_FIELD));
 
@@ -282,7 +281,7 @@ int32_t scheduleQuery(SRequestObj* pRequest, SQueryPlan* pDag, SArray* pNodeList
 
   SQueryResult res = {.code = 0, .numOfRows = 0, .msgSize = ERROR_MSG_BUF_DEFAULT_SIZE, .msg = pRequest->msgBuf};
   int32_t      code = schedulerExecJob(pTransporter, pNodeList, pDag, &pRequest->body.queryJob, pRequest->sqlstr,
-                                  pRequest->metric.start, &res);
+                                       pRequest->metric.start, &res);
   if (code != TSDB_CODE_SUCCESS) {
     if (pRequest->body.queryJob != 0) {
       schedulerFreeJob(pRequest->body.queryJob);
@@ -840,12 +839,12 @@ int32_t setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32
     return code;
   }
 
-  char* p = (char*) pResultInfo->pData;
+  char* p = (char*)pResultInfo->pData;
 
-  int32_t dataLen = *(int32_t*) p;
+  int32_t dataLen = *(int32_t*)p;
   p += sizeof(int32_t);
 
-  uint64_t groupId = *(uint64_t*) p;
+  uint64_t groupId = *(uint64_t*)p;
   p += sizeof(uint64_t);
 
   int32_t* colLength = (int32_t*)p;
diff --git a/source/client/src/tmq.c b/source/client/src/tmq.c
index d576f28cb4..988406c84d 100644
--- a/source/client/src/tmq.c
+++ b/source/client/src/tmq.c
@@ -376,7 +376,7 @@ tmq_t* tmq_consumer_new(tmq_conf_t* conf, char* errstr, int32_t errstrLen) {
 
   ASSERT(user);
   ASSERT(pass);
-  ASSERT(conf->db);
+  /*ASSERT(conf->db);*/
   ASSERT(conf->groupId[0]);
 
   pTmq->pTscObj = taos_connect_internal(conf->ip, user, pass, NULL, conf->db, conf->port, CONN_TYPE__TMQ);
@@ -1118,7 +1118,9 @@ SMqRspObj* tmqBuildRspFromWrapper(SMqPollRspWrapper* pWrapper) {
 
   pRspObj->resInfo.totalRows = 0;
   pRspObj->resInfo.precision = TSDB_TIME_PRECISION_MILLI;
-  setResSchemaInfo(&pRspObj->resInfo, pWrapper->topicHandle->schema.pSchema, pWrapper->topicHandle->schema.nCols);
+  if (!pWrapper->msg.withSchema) {
+    setResSchemaInfo(&pRspObj->resInfo, pWrapper->topicHandle->schema.pSchema, pWrapper->topicHandle->schema.nCols);
+  }
 
   taosFreeQitem(pWrapper);
   return pRspObj;
diff --git a/source/dnode/mnode/impl/src/mndScheduler.c b/source/dnode/mnode/impl/src/mndScheduler.c
index 73583058f1..3dff65866c 100644
--- a/source/dnode/mnode/impl/src/mndScheduler.c
+++ b/source/dnode/mnode/impl/src/mndScheduler.c
@@ -476,33 +476,37 @@ int32_t mndScheduleStream(SMnode* pMnode, STrans* pTrans, SStreamObj* pStream) {
 int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscribeObj* pSub) {
   SSdb*       pSdb = pMnode->pSdb;
   SVgObj*     pVgroup = NULL;
-  SQueryPlan* pPlan = qStringToQueryPlan(pTopic->physicalPlan);
-  if (pPlan == NULL) {
-    terrno = TSDB_CODE_QRY_INVALID_INPUT;
-    return -1;
+  SQueryPlan* pPlan = NULL;
+  SSubplan*   plan = NULL;
+  if (pTopic->subType == TOPIC_SUB_TYPE__TABLE) {
+    pPlan = qStringToQueryPlan(pTopic->physicalPlan);
+    if (pPlan == NULL) {
+      terrno = TSDB_CODE_QRY_INVALID_INPUT;
+      return -1;
+    }
+
+    ASSERT(pSub->vgNum == -1);
+
+    pSub->vgNum = 0;
+
+    int32_t levelNum = LIST_LENGTH(pPlan->pSubplans);
+    if (levelNum != 1) {
+      qDestroyQueryPlan(pPlan);
+      terrno = TSDB_CODE_MND_UNSUPPORTED_TOPIC;
+      return -1;
+    }
+
+    SNodeListNode* inner = nodesListGetNode(pPlan->pSubplans, 0);
+
+    int32_t opNum = LIST_LENGTH(inner->pNodeList);
+    if (opNum != 1) {
+      qDestroyQueryPlan(pPlan);
+      terrno = TSDB_CODE_MND_UNSUPPORTED_TOPIC;
+      return -1;
+    }
+    plan = nodesListGetNode(inner->pNodeList, 0);
   }
 
-  ASSERT(pSub->vgNum == -1);
-
-  pSub->vgNum = 0;
-
-  int32_t levelNum = LIST_LENGTH(pPlan->pSubplans);
-  if (levelNum != 1) {
-    qDestroyQueryPlan(pPlan);
-    terrno = TSDB_CODE_MND_UNSUPPORTED_TOPIC;
-    return -1;
-  }
-
-  SNodeListNode* inner = nodesListGetNode(pPlan->pSubplans, 0);
-
-  int32_t opNum = LIST_LENGTH(inner->pNodeList);
-  if (opNum != 1) {
-    qDestroyQueryPlan(pPlan);
-    terrno = TSDB_CODE_MND_UNSUPPORTED_TOPIC;
-    return -1;
-  }
-  SSubplan* plan = nodesListGetNode(inner->pNodeList, 0);
-
   int64_t             unexistKey = -1;
   SMqConsumerEpInSub* pEpInSub = taosHashGet(pSub->consumerHash, &unexistKey, sizeof(int64_t));
   ASSERT(pEpInSub);
@@ -519,38 +523,35 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib
     }
 
     pSub->vgNum++;
-    plan->execNode.nodeId = pVgroup->vgId;
-    plan->execNode.epSet = mndGetVgroupEpset(pMnode, pVgroup);
 
     SMqVgEp* pVgEp = taosMemoryMalloc(sizeof(SMqVgEp));
-    pVgEp->epSet = plan->execNode.epSet;
-    pVgEp->vgId = plan->execNode.nodeId;
-
-#if 0
-    SMqConsumerEp consumerEp = {0};
-    consumerEp.status = 0;
-    consumerEp.consumerId = -1;
-    consumerEp.epSet = plan->execNode.epSet;
-    consumerEp.vgId = plan->execNode.nodeId;
-#endif
+    pVgEp->epSet = mndGetVgroupEpset(pMnode, pVgroup);
+    pVgEp->vgId = pVgroup->vgId;
+    taosArrayPush(pEpInSub->vgs, &pVgEp);
 
     mDebug("init subscribption %s, assign vg: %d", pSub->key, pVgEp->vgId);
 
-    int32_t msgLen;
-    if (qSubPlanToString(plan, &pVgEp->qmsg, &msgLen) < 0) {
-      sdbRelease(pSdb, pVgroup);
-      qDestroyQueryPlan(pPlan);
-      terrno = TSDB_CODE_QRY_INVALID_INPUT;
-      return -1;
+    if (pTopic->subType == TOPIC_SUB_TYPE__TABLE) {
+      int32_t msgLen;
+
+      plan->execNode.epSet = pVgEp->epSet;
+      plan->execNode.nodeId = pVgEp->vgId;
+
+      if (qSubPlanToString(plan, &pVgEp->qmsg, &msgLen) < 0) {
+        sdbRelease(pSdb, pVgroup);
+        qDestroyQueryPlan(pPlan);
+        terrno = TSDB_CODE_QRY_INVALID_INPUT;
+        return -1;
+      }
+    } else {
+      pVgEp->qmsg = strdup("");
     }
-    taosArrayPush(pEpInSub->vgs, &pVgEp);
 
     ASSERT(taosHashGetSize(pSub->consumerHash) == 1);
 
     /*taosArrayPush(pSub->unassignedVg, &consumerEp);*/
   }
 
-  ASSERT(pEpInSub->vgs->size > 0);
   pEpInSub = taosHashGet(pSub->consumerHash, &unexistKey, sizeof(int64_t));
 
   ASSERT(pEpInSub->vgs->size > 0);
diff --git a/source/dnode/mnode/impl/src/mndTopic.c b/source/dnode/mnode/impl/src/mndTopic.c
index faddc3a1c5..e7a37658dc 100644
--- a/source/dnode/mnode/impl/src/mndTopic.c
+++ b/source/dnode/mnode/impl/src/mndTopic.c
@@ -282,10 +282,10 @@ static int32_t mndCreateTopic(SMnode *pMnode, SNodeMsg *pReq, SCMCreateTopicReq
   topicObj.version = 1;
   topicObj.sql = strdup(pCreate->sql);
   topicObj.sqlLen = strlen(pCreate->sql) + 1;
-  topicObj.ast = strdup(pCreate->ast);
-  topicObj.astLen = strlen(pCreate->ast) + 1;
 
   if (pCreate->ast && pCreate->ast[0]) {
+    topicObj.ast = strdup(pCreate->ast);
+    topicObj.astLen = strlen(pCreate->ast) + 1;
     topicObj.subType = TOPIC_SUB_TYPE__TABLE;
     topicObj.withTbName = 0;
     topicObj.withSchema = 0;
@@ -314,6 +314,9 @@ static int32_t mndCreateTopic(SMnode *pMnode, SNodeMsg *pReq, SCMCreateTopicReq
       return -1;
     }
   } else {
+    topicObj.ast = strdup("");
+    topicObj.astLen = 1;
+    topicObj.physicalPlan = strdup("");
     topicObj.subType = TOPIC_SUB_TYPE__DB;
     topicObj.withTbName = 1;
     topicObj.withSchema = 1;
diff --git a/source/dnode/vnode/src/tq/tq.c b/source/dnode/vnode/src/tq/tq.c
index 434c5bc5bb..fdb43a761b 100644
--- a/source/dnode/vnode/src/tq/tq.c
+++ b/source/dnode/vnode/src/tq/tq.c
@@ -411,8 +411,10 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
 
   SMqDataBlkRsp rsp = {0};
   rsp.reqOffset = pReq->currentOffset;
+  rsp.withSchema = pExec->withSchema;
   rsp.blockData = taosArrayInit(0, sizeof(void*));
   rsp.blockDataLen = taosArrayInit(0, sizeof(int32_t));
+  rsp.blockSchema = taosArrayInit(0, sizeof(void*));
 
   while (1) {
     consumerEpoch = atomic_load_32(&pExec->epoch);
@@ -512,6 +514,12 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
           ASSERT(actualLen <= dataStrLen);
           taosArrayPush(rsp.blockDataLen, &actualLen);
           taosArrayPush(rsp.blockData, &buf);
+
+          if (pExec->withSchema) {
+            SSchemaWrapper* pSW = tCloneSSchemaWrapper(pExec->pExecReader[workerId]->pSchemaWrapper);
+            taosArrayPush(rsp.blockSchema, &pSW);
+          }
+
           rsp.blockNum++;
         }
         // db subscribe
@@ -540,6 +548,10 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
           ASSERT(actualLen <= dataStrLen);
           taosArrayPush(rsp.blockDataLen, &actualLen);
           taosArrayPush(rsp.blockData, &buf);
+
+          SSchemaWrapper* pSW = tCloneSSchemaWrapper(pExec->pExecReader[workerId]->pSchemaWrapper);
+          taosArrayPush(rsp.blockSchema, &pSW);
+
           rsp.blockNum++;
         }
       } else {
@@ -586,6 +598,8 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
   // TODO destroy
   taosArrayDestroy(rsp.blockData);
   taosArrayDestroy(rsp.blockDataLen);
+  taosArrayDestroyP(rsp.blockSchema, (FDelete)tDeleteSSchemaWrapper);
+
   return 0;
 }
 
@@ -827,12 +841,16 @@ int32_t tqProcessVgChangeReq(STQ* pTq, char* msg, int32_t msgLen) {
     pExec->pWalReader = walOpenReadHandle(pTq->pVnode->pWal);
     for (int32_t i = 0; i < 5; i++) {
       pExec->pExecReader[i] = tqInitSubmitMsgScanner(pTq->pVnode->pMeta);
-      SReadHandle handle = {
-          .reader = pExec->pExecReader[i],
-          .meta = pTq->pVnode->pMeta,
-      };
-      pExec->task[i] = qCreateStreamExecTaskInfo(pExec->qmsg, &handle);
-      ASSERT(pExec->task[i]);
+      if (pExec->subType == TOPIC_SUB_TYPE__TABLE) {
+        SReadHandle handle = {
+            .reader = pExec->pExecReader[i],
+            .meta = pTq->pVnode->pMeta,
+        };
+        pExec->task[i] = qCreateStreamExecTaskInfo(pExec->qmsg, &handle);
+        ASSERT(pExec->task[i]);
+      } else {
+        pExec->task[i] = NULL;
+      }
     }
     taosHashPut(pTq->execs, req.subKey, strlen(req.subKey), pExec, sizeof(STqExec));
     return 0;
diff --git a/source/dnode/vnode/src/tq/tqRead.c b/source/dnode/vnode/src/tq/tqRead.c
index eb45577e0a..ef7e346867 100644
--- a/source/dnode/vnode/src/tq/tqRead.c
+++ b/source/dnode/vnode/src/tq/tqRead.c
@@ -65,7 +65,9 @@ bool tqNextDataBlock(STqReadHandle* pHandle) {
 
     /*pHandle->pBlock->uid = htobe64(pHandle->pBlock->uid);*/
     /*if (pHandle->tbUid == pHandle->pBlock->uid) {*/
-    ASSERT(pHandle->tbIdHash);
+    if (pHandle->tbIdHash == NULL) {
+      return true;
+    }
     void* ret = taosHashGet(pHandle->tbIdHash, &pHandle->pBlock->uid, sizeof(int64_t));
     if (ret != NULL) {
       /*printf("retrieve one tb %ld\n", pHandle->pBlock->uid);*/
@@ -107,26 +109,15 @@ int32_t tqRetrieveDataBlock(SArray** ppCols, STqReadHandle* pHandle, uint64_t* p
   *pNumOfRows = pHandle->pBlock->numOfRows;
   int32_t colNumNeed = taosArrayGetSize(pHandle->pColIdList);
 
-  if (colNumNeed > pSchemaWrapper->nCols) {
-    colNumNeed = pSchemaWrapper->nCols;
-  }
+  if (colNumNeed == 0) {
+    *ppCols = taosArrayInit(pSchemaWrapper->nCols, sizeof(SColumnInfoData));
+    if (*ppCols == NULL) {
+      return -1;
+    }
 
-  *ppCols = taosArrayInit(colNumNeed, sizeof(SColumnInfoData));
-  if (*ppCols == NULL) {
-    return -1;
-  }
-
-  int32_t colMeta = 0;
-  int32_t colNeed = 0;
-  while (colMeta < pSchemaWrapper->nCols && colNeed < colNumNeed) {
-    SSchema* pColSchema = &pSchemaWrapper->pSchema[colMeta];
-    col_id_t colIdSchema = pColSchema->colId;
-    col_id_t colIdNeed = *(col_id_t*)taosArrayGet(pHandle->pColIdList, colNeed);
-    if (colIdSchema < colIdNeed) {
-      colMeta++;
-    } else if (colIdSchema > colIdNeed) {
-      colNeed++;
-    } else {
+    int32_t colMeta = 0;
+    while (colMeta < pSchemaWrapper->nCols) {
+      SSchema*        pColSchema = &pSchemaWrapper->pSchema[colMeta];
       SColumnInfoData colInfo = {0};
       colInfo.info.bytes = pColSchema->bytes;
       colInfo.info.colId = pColSchema->colId;
@@ -137,7 +128,40 @@ int32_t tqRetrieveDataBlock(SArray** ppCols, STqReadHandle* pHandle, uint64_t* p
       }
       taosArrayPush(*ppCols, &colInfo);
       colMeta++;
-      colNeed++;
+    }
+  } else {
+    if (colNumNeed > pSchemaWrapper->nCols) {
+      colNumNeed = pSchemaWrapper->nCols;
+    }
+
+    *ppCols = taosArrayInit(colNumNeed, sizeof(SColumnInfoData));
+    if (*ppCols == NULL) {
+      return -1;
+    }
+
+    int32_t colMeta = 0;
+    int32_t colNeed = 0;
+    while (colMeta < pSchemaWrapper->nCols && colNeed < colNumNeed) {
+      SSchema* pColSchema = &pSchemaWrapper->pSchema[colMeta];
+      col_id_t colIdSchema = pColSchema->colId;
+      col_id_t colIdNeed = *(col_id_t*)taosArrayGet(pHandle->pColIdList, colNeed);
+      if (colIdSchema < colIdNeed) {
+        colMeta++;
+      } else if (colIdSchema > colIdNeed) {
+        colNeed++;
+      } else {
+        SColumnInfoData colInfo = {0};
+        colInfo.info.bytes = pColSchema->bytes;
+        colInfo.info.colId = pColSchema->colId;
+        colInfo.info.type = pColSchema->type;
+
+        if (colInfoDataEnsureCapacity(&colInfo, 0, *pNumOfRows) < 0) {
+          goto FAIL;
+        }
+        taosArrayPush(*ppCols, &colInfo);
+        colMeta++;
+        colNeed++;
+      }
     }
   }
 

From d44611e2204e419dd9ae9357431e0aa81d4f2eac Mon Sep 17 00:00:00 2001
From: Cary Xu <klxu@taosdata.com>
Date: Mon, 25 Apr 2022 15:58:44 +0800
Subject: [PATCH 16/23] feat: block wise sma aggr query

---
 source/libs/executor/src/executorimpl.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/source/libs/executor/src/executorimpl.c b/source/libs/executor/src/executorimpl.c
index 0a246d573c..ca88bea71c 100644
--- a/source/libs/executor/src/executorimpl.c
+++ b/source/libs/executor/src/executorimpl.c
@@ -1091,6 +1091,7 @@ static int32_t doSetInputDataBlock(SOperatorInfo* pOperator, SqlFunctionCtx* pCt
 
     SInputColumnInfoData* pInput = &pCtx[i].input;
     pInput->uid = pBlock->info.uid;
+    pInput->colDataAggIsSet = false;
 
     SExprInfo* pOneExpr = &pOperator->pExpr[i];
     for (int32_t j = 0; j < pOneExpr->base.numOfParams; ++j) {

From 834e6b5711d9e1a6144d94f9644bb6c9ffd9fb3b Mon Sep 17 00:00:00 2001
From: Cary Xu <klxu@taosdata.com>
Date: Mon, 25 Apr 2022 16:41:22 +0800
Subject: [PATCH 17/23] feat: rollup refactor

---
 include/common/tmsg.h                      | 20 ++++++-------
 source/common/src/tmsg.c                   |  4 +--
 source/dnode/vnode/src/inc/tsdb.h          |  2 +-
 source/dnode/vnode/src/inc/tsdbSma.h       |  2 +-
 source/dnode/vnode/src/tq/tqRead.c         | 34 +++++++++++++---------
 source/dnode/vnode/src/tsdb/tsdbMemTable.c | 28 ++++++++++++++++++
 source/dnode/vnode/src/tsdb/tsdbRead.c     |  2 ++
 source/dnode/vnode/src/tsdb/tsdbSma.c      | 34 ++++++++++++++--------
 8 files changed, 87 insertions(+), 39 deletions(-)

diff --git a/include/common/tmsg.h b/include/common/tmsg.h
index 335d20d096..d0926948dc 100644
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@@ -230,12 +230,12 @@ typedef struct {
   int32_t totalLen;
   int32_t len;
   // head of SSubmitBlk
-  int64_t uid;        // table unique id
-  int64_t suid;       // stable id
-  int32_t sversion;   // data schema version
-  int32_t dataLen;    // data part length, not including the SSubmitBlk head
-  int32_t schemaLen;  // schema length, if length is 0, no schema exists
-  int16_t numOfRows;  // total number of rows in current submit block
+  // int64_t uid;        // table unique id
+  // int64_t suid;       // stable id
+  // int32_t sversion;   // data schema version
+  // int32_t dataLen;    // data part length, not including the SSubmitBlk head
+  // int32_t schemaLen;  // schema length, if length is 0, no schema exists
+  // int16_t numOfRows;  // total number of rows in current submit block
   // head of SSubmitBlk
   const void* pMsg;
 } SSubmitMsgIter;
@@ -249,10 +249,10 @@ STSRow* tGetSubmitBlkNext(SSubmitBlkIter* pIter);
 // 1) use tInitSubmitMsgIterEx firstly as not decrease the merge conflicts
 // 2) replace tInitSubmitMsgIterEx with tInitSubmitMsgIter later
 // 3) finally, rename tInitSubmitMsgIterEx to tInitSubmitMsgIter
-int32_t tInitSubmitMsgIterEx(const SSubmitReq* pMsg, SSubmitMsgIter* pIter);
-int32_t tGetSubmitMsgNextEx(SSubmitMsgIter* pIter, SSubmitBlk** pPBlock);
-int32_t tInitSubmitBlkIterEx(SSubmitMsgIter* pMsgIter, SSubmitBlk* pBlock, SSubmitBlkIter* pIter);
-STSRow* tGetSubmitBlkNextEx(SSubmitBlkIter* pIter);
+// int32_t tInitSubmitMsgIterEx(const SSubmitReq* pMsg, SSubmitMsgIter* pIter);
+// int32_t tGetSubmitMsgNextEx(SSubmitMsgIter* pIter, SSubmitBlk** pPBlock);
+// int32_t tInitSubmitBlkIterEx(SSubmitMsgIter* pMsgIter, SSubmitBlk* pBlock, SSubmitBlkIter* pIter);
+// STSRow* tGetSubmitBlkNextEx(SSubmitBlkIter* pIter);
 
 typedef struct {
   int32_t index;  // index of failed block in submit blocks
diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c
index e03850ef00..05fd9e301b 100644
--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@@ -93,7 +93,7 @@ STSRow *tGetSubmitBlkNext(SSubmitBlkIter *pIter) {
     return row;
   }
 }
-
+#if 0
 // TODO: KEEP one suite of iterator API finally.
 // 1) use tInitSubmitMsgIterEx firstly as not decrease the merge conflicts
 // 2) replace tInitSubmitMsgIterEx with tInitSubmitMsgIter later
@@ -173,7 +173,7 @@ STSRow *tGetSubmitBlkNextEx(SSubmitBlkIter *pIter) {
     return row;
   }
 }
-
+#endif
 int32_t tEncodeSEpSet(SCoder *pEncoder, const SEpSet *pEp) {
   if (tEncodeI8(pEncoder, pEp->inUse) < 0) return -1;
   if (tEncodeI8(pEncoder, pEp->numOfEps) < 0) return -1;
diff --git a/source/dnode/vnode/src/inc/tsdb.h b/source/dnode/vnode/src/inc/tsdb.h
index 8cfbffc962..f751c860bd 100644
--- a/source/dnode/vnode/src/inc/tsdb.h
+++ b/source/dnode/vnode/src/inc/tsdb.h
@@ -56,7 +56,7 @@ int32_t tsdbInsertTSmaData(STsdb *pTsdb, int64_t indexUid, const char *msg);
 int32_t tsdbDropTSmaData(STsdb *pTsdb, int64_t indexUid);
 int32_t tsdbInsertRSmaData(STsdb *pTsdb, char *msg);
 void    tsdbCleanupReadHandle(tsdbReaderT queryHandle);
-
+int     tdScanAndConvertSubmitMsg(SSubmitReq *pMsg);
 typedef enum {
   TSDB_FILE_HEAD = 0,  // .head
   TSDB_FILE_DATA,      // .data
diff --git a/source/dnode/vnode/src/inc/tsdbSma.h b/source/dnode/vnode/src/inc/tsdbSma.h
index 3a865ddc51..e20d2989b9 100644
--- a/source/dnode/vnode/src/inc/tsdbSma.h
+++ b/source/dnode/vnode/src/inc/tsdbSma.h
@@ -55,7 +55,7 @@ void   *tsdbUidStoreFree(STbUidStore *pStore);
 int32_t tsdbRegisterRSma(STsdb *pTsdb, SMeta *pMeta, SVCreateTbReq *pReq);
 int32_t tsdbFetchTbUidList(void *pTsdb, void **result, void *suid, void *uid);
 int32_t tsdbUpdateTbUidList(STsdb *pTsdb, STbUidStore *pUidStore);
-int32_t tsdbTriggerRSma(STsdb *pTsdb, SMeta *pMeta, const void *pMsg, int32_t inputType);
+int32_t tsdbTriggerRSma(STsdb *pTsdb, SMeta *pMeta, void *pMsg, int32_t inputType);
 
 #ifdef __cplusplus
 }
diff --git a/source/dnode/vnode/src/tq/tqRead.c b/source/dnode/vnode/src/tq/tqRead.c
index ada2460d97..eb45577e0a 100644
--- a/source/dnode/vnode/src/tq/tqRead.c
+++ b/source/dnode/vnode/src/tq/tqRead.c
@@ -33,15 +33,24 @@ STqReadHandle* tqInitSubmitMsgScanner(SMeta* pMeta) {
 
 int32_t tqReadHandleSetMsg(STqReadHandle* pReadHandle, SSubmitReq* pMsg, int64_t ver) {
   pReadHandle->pMsg = pMsg;
+  pMsg->length = htonl(pMsg->length);
+  pMsg->numOfBlocks = htonl(pMsg->numOfBlocks);
 
-  // iterate
-  if (tInitSubmitMsgIterEx(pMsg, &pReadHandle->msgIter) < 0) return -1;
+  // iterate and convert
+  if (tInitSubmitMsgIter(pMsg, &pReadHandle->msgIter) < 0) return -1;
   while (true) {
-    if (tGetSubmitMsgNextEx(&pReadHandle->msgIter, &pReadHandle->pBlock) < 0) return -1;
+    if (tGetSubmitMsgNext(&pReadHandle->msgIter, &pReadHandle->pBlock) < 0) return -1;
     if (pReadHandle->pBlock == NULL) break;
+
+    pReadHandle->pBlock->uid = htobe64(pReadHandle->pBlock->uid);
+    pReadHandle->pBlock->suid = htobe64(pReadHandle->pBlock->suid);
+    pReadHandle->pBlock->sversion = htonl(pReadHandle->pBlock->sversion);
+    pReadHandle->pBlock->dataLen = htonl(pReadHandle->pBlock->dataLen);
+    pReadHandle->pBlock->schemaLen = htonl(pReadHandle->pBlock->schemaLen);
+    pReadHandle->pBlock->numOfRows = htons(pReadHandle->pBlock->numOfRows);
   }
 
-  if (tInitSubmitMsgIterEx(pMsg, &pReadHandle->msgIter) < 0) return -1;
+  if (tInitSubmitMsgIter(pMsg, &pReadHandle->msgIter) < 0) return -1;
   pReadHandle->ver = ver;
   memset(&pReadHandle->blkIter, 0, sizeof(SSubmitBlkIter));
   return 0;
@@ -49,7 +58,7 @@ int32_t tqReadHandleSetMsg(STqReadHandle* pReadHandle, SSubmitReq* pMsg, int64_t
 
 bool tqNextDataBlock(STqReadHandle* pHandle) {
   while (1) {
-    if (tGetSubmitMsgNextEx(&pHandle->msgIter, &pHandle->pBlock) < 0) {
+    if (tGetSubmitMsgNext(&pHandle->msgIter, &pHandle->pBlock) < 0) {
       return false;
     }
     if (pHandle->pBlock == NULL) return false;
@@ -57,8 +66,7 @@ bool tqNextDataBlock(STqReadHandle* pHandle) {
     /*pHandle->pBlock->uid = htobe64(pHandle->pBlock->uid);*/
     /*if (pHandle->tbUid == pHandle->pBlock->uid) {*/
     ASSERT(pHandle->tbIdHash);
-    // void* ret = taosHashGet(pHandle->tbIdHash, &pHandle->pBlock->uid, sizeof(int64_t));
-    void* ret = taosHashGet(pHandle->tbIdHash, &pHandle->msgIter.uid, sizeof(int64_t));
+    void* ret = taosHashGet(pHandle->tbIdHash, &pHandle->pBlock->uid, sizeof(int64_t));
     if (ret != NULL) {
       /*printf("retrieve one tb %ld\n", pHandle->pBlock->uid);*/
       /*pHandle->pBlock->tid = htonl(pHandle->pBlock->tid);*/
@@ -80,14 +88,14 @@ int32_t tqRetrieveDataBlock(SArray** ppCols, STqReadHandle* pHandle, uint64_t* p
   // TODO set to real sversion
   int32_t sversion = 0;
   if (pHandle->sver != sversion) {
-    pHandle->pSchema = metaGetTbTSchema(pHandle->pVnodeMeta, pHandle->msgIter.uid, sversion);
+    pHandle->pSchema = metaGetTbTSchema(pHandle->pVnodeMeta, pHandle->pBlock->uid, sversion);
 
     tb_uid_t quid;
-    STbCfg*  pTbCfg = metaGetTbInfoByUid(pHandle->pVnodeMeta, pHandle->msgIter.uid);
+    STbCfg*  pTbCfg = metaGetTbInfoByUid(pHandle->pVnodeMeta, pHandle->pBlock->uid);
     if (pTbCfg->type == META_CHILD_TABLE) {
       quid = pTbCfg->ctbCfg.suid;
     } else {
-      quid = pHandle->msgIter.uid;
+      quid = pHandle->pBlock->uid;
     }
     pHandle->pSchemaWrapper = metaGetTableSchema(pHandle->pVnodeMeta, quid, sversion, true);
     pHandle->sver = sversion;
@@ -96,7 +104,7 @@ int32_t tqRetrieveDataBlock(SArray** ppCols, STqReadHandle* pHandle, uint64_t* p
   STSchema*       pTschema = pHandle->pSchema;
   SSchemaWrapper* pSchemaWrapper = pHandle->pSchemaWrapper;
 
-  *pNumOfRows = pHandle->msgIter.numOfRows;
+  *pNumOfRows = pHandle->pBlock->numOfRows;
   int32_t colNumNeed = taosArrayGetSize(pHandle->pColIdList);
 
   if (colNumNeed > pSchemaWrapper->nCols) {
@@ -143,8 +151,8 @@ int32_t tqRetrieveDataBlock(SArray** ppCols, STqReadHandle* pHandle, uint64_t* p
   tdSTSRowIterInit(&iter, pTschema);
   STSRow* row;
   int32_t curRow = 0;
-  tInitSubmitBlkIterEx(&pHandle->msgIter, pHandle->pBlock, &pHandle->blkIter);
-  while ((row = tGetSubmitBlkNextEx(&pHandle->blkIter)) != NULL) {
+  tInitSubmitBlkIter(pHandle->pBlock, &pHandle->blkIter);
+  while ((row = tGetSubmitBlkNext(&pHandle->blkIter)) != NULL) {
     tdSTSRowIterReset(&iter, row);
     // get all wanted col of that block
     for (int32_t i = 0; i < colActual; i++) {
diff --git a/source/dnode/vnode/src/tsdb/tsdbMemTable.c b/source/dnode/vnode/src/tsdb/tsdbMemTable.c
index 3082ee6f2b..bea2b66af8 100644
--- a/source/dnode/vnode/src/tsdb/tsdbMemTable.c
+++ b/source/dnode/vnode/src/tsdb/tsdbMemTable.c
@@ -227,6 +227,34 @@ int tsdbLoadDataFromCache(STable *pTable, SSkipListIterator *pIter, TSKEY maxKey
   return 0;
 }
 
+int32_t tdScanAndConvertSubmitMsg(SSubmitReq *pMsg) {
+  ASSERT(pMsg != NULL);
+  SSubmitMsgIter msgIter = {0};
+  SSubmitBlk    *pBlock = NULL;
+  SSubmitBlkIter blkIter = {0};
+  STSRow        *row = NULL;
+
+  terrno = TSDB_CODE_SUCCESS;
+  pMsg->length = htonl(pMsg->length);
+  pMsg->numOfBlocks = htonl(pMsg->numOfBlocks);
+
+  if (tInitSubmitMsgIter(pMsg, &msgIter) < 0) return -1;
+  while (true) {
+    if (tGetSubmitMsgNext(&msgIter, &pBlock) < 0) return -1;
+    if (pBlock == NULL) break;
+
+    pBlock->uid = htobe64(pBlock->uid);
+    pBlock->suid = htobe64(pBlock->suid);
+    pBlock->sversion = htonl(pBlock->sversion);
+    pBlock->dataLen = htonl(pBlock->dataLen);
+    pBlock->schemaLen = htonl(pBlock->schemaLen);
+    pBlock->numOfRows = htons(pBlock->numOfRows);
+  }
+
+  if (terrno != TSDB_CODE_SUCCESS) return -1;
+  return 0;
+}
+
 static int tsdbScanAndConvertSubmitMsg(STsdb *pTsdb, SSubmitReq *pMsg) {
   ASSERT(pMsg != NULL);
   // STsdbMeta *    pMeta = pTsdb->tsdbMeta;
diff --git a/source/dnode/vnode/src/tsdb/tsdbRead.c b/source/dnode/vnode/src/tsdb/tsdbRead.c
index 098b86975b..483475601b 100644
--- a/source/dnode/vnode/src/tsdb/tsdbRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbRead.c
@@ -3636,6 +3636,8 @@ int32_t tsdbQuerySTableByTagCond(void* pMeta, uint64_t uid, TSKEY skey, const ch
     tsdbError("%p failed to get stable, uid:%" PRIu64 ", TID:0x%" PRIx64 " QID:0x%" PRIx64, pMeta, uid, taskId, reqId);
     terrno = TSDB_CODE_TDB_INVALID_TABLE_ID;
     goto _error;
+  } else {
+    tsdbDebug("%p succeed to get stable, uid:%" PRIu64 ", TID:0x%" PRIx64 " QID:0x%" PRIx64, pMeta, uid, taskId, reqId);
   }
 
   if (pTbCfg->type != META_SUPER_TABLE) {
diff --git a/source/dnode/vnode/src/tsdb/tsdbSma.c b/source/dnode/vnode/src/tsdb/tsdbSma.c
index f3b47c91ef..9143e8ed12 100644
--- a/source/dnode/vnode/src/tsdb/tsdbSma.c
+++ b/source/dnode/vnode/src/tsdb/tsdbSma.c
@@ -678,9 +678,9 @@ int32_t tsdbUpdateExpiredWindowImpl(STsdb *pTsdb, SSubmitReq *pMsg, int64_t vers
     return TSDB_CODE_FAILED;
   }
 
-  // if (tdScanAndConvertSubmitMsg(pMsg) != TSDB_CODE_SUCCESS) {
-  //   return TSDB_CODE_FAILED;
-  // }
+  if (tdScanAndConvertSubmitMsg(pMsg) != TSDB_CODE_SUCCESS) {
+    return TSDB_CODE_FAILED;
+  }
 
   if (tsdbCheckAndInitSmaEnv(pTsdb, TSDB_SMA_TYPE_TIME_RANGE) != TSDB_CODE_SUCCESS) {
     terrno = TSDB_CODE_TDB_INIT_FAILED;
@@ -705,25 +705,25 @@ int32_t tsdbUpdateExpiredWindowImpl(STsdb *pTsdb, SSubmitReq *pMsg, int64_t vers
   SInterval      interval = {0};
   TSKEY          lastWinSKey = INT64_MIN;
 
-  if (tInitSubmitMsgIterEx(pMsg, &msgIter) != TSDB_CODE_SUCCESS) {
+  if (tInitSubmitMsgIter(pMsg, &msgIter) != TSDB_CODE_SUCCESS) {
     return TSDB_CODE_FAILED;
   }
 
   while (true) {
-    tGetSubmitMsgNextEx(&msgIter, &pBlock);
+    tGetSubmitMsgNext(&msgIter, &pBlock);
     if (!pBlock) break;
 
     STSmaWrapper *pSW = NULL;
     STSma        *pTSma = NULL;
 
     SSubmitBlkIter blkIter = {0};
-    if (tInitSubmitBlkIterEx(&msgIter, pBlock, &blkIter) != TSDB_CODE_SUCCESS) {
+    if (tInitSubmitBlkIter(pBlock, &blkIter) != TSDB_CODE_SUCCESS) {
       pSW = tdFreeTSmaWrapper(pSW);
       break;
     }
 
     while (true) {
-      STSRow *row = tGetSubmitBlkNextEx(&blkIter);
+      STSRow *row = tGetSubmitBlkNext(&blkIter);
       if (!row) {
         tdFreeTSmaWrapper(pSW);
         break;
@@ -1763,6 +1763,8 @@ int32_t tsdbRegisterRSma(STsdb *pTsdb, SMeta *pMeta, SVCreateTbReq *pReq) {
   if (taosHashPut(SMA_STAT_INFO_HASH(pStat), &pReq->stbCfg.suid, sizeof(tb_uid_t), &pRSmaInfo, sizeof(pRSmaInfo)) !=
       TSDB_CODE_SUCCESS) {
     return TSDB_CODE_FAILED;
+  } else {
+    tsdbDebug("vgId:%d register rsma info succeed for suid:%" PRIi64, REPO_ID(pTsdb), pReq->stbCfg.suid);
   }
 
   return TSDB_CODE_SUCCESS;
@@ -1915,10 +1917,17 @@ static FORCE_INLINE int32_t tsdbUpdateTbUidListImpl(STsdb *pTsdb, tb_uid_t *suid
   if (pRSmaInfo->taskInfo[0] && (qUpdateQualifiedTableId(pRSmaInfo->taskInfo[0], tbUids, true) != 0)) {
     tsdbError("vgId:%d update tbUidList failed for uid:%" PRIi64 " since %s", REPO_ID(pTsdb), *suid, terrstr(terrno));
     return TSDB_CODE_FAILED;
+  } else {
+    tsdbDebug("vgId:%d update tbUidList succeed for qTaskInfo:%p with suid:%" PRIi64 ", uid:%" PRIi64, REPO_ID(pTsdb),
+              pRSmaInfo->taskInfo[0], *suid, *(int64_t *)taosArrayGet(tbUids, 0));
   }
+
   if (pRSmaInfo->taskInfo[1] && (qUpdateQualifiedTableId(pRSmaInfo->taskInfo[1], tbUids, true) != 0)) {
     tsdbError("vgId:%d update tbUidList failed for uid:%" PRIi64 " since %s", REPO_ID(pTsdb), *suid, terrstr(terrno));
     return TSDB_CODE_FAILED;
+  } else {
+    tsdbDebug("vgId:%d update tbUidList succeed for qTaskInfo:%p with suid:%" PRIi64 ", uid:%" PRIi64, REPO_ID(pTsdb),
+              pRSmaInfo->taskInfo[1], *suid, *(int64_t *)taosArrayGet(tbUids, 0));
   }
 
   return TSDB_CODE_SUCCESS;
@@ -1955,7 +1964,7 @@ int32_t tsdbUpdateTbUidList(STsdb *pTsdb, STbUidStore *pStore) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t tsdbFetchSubmitReqSuids(const SSubmitReq *pMsg, STbUidStore *pStore) {
+static int32_t tsdbFetchSubmitReqSuids(SSubmitReq *pMsg, STbUidStore *pStore) {
   ASSERT(pMsg != NULL);
   SSubmitMsgIter msgIter = {0};
   SSubmitBlk    *pBlock = NULL;
@@ -1966,11 +1975,12 @@ static int32_t tsdbFetchSubmitReqSuids(const SSubmitReq *pMsg, STbUidStore *pSto
   // pMsg->length = htonl(pMsg->length);
   // pMsg->numOfBlocks = htonl(pMsg->numOfBlocks);
 
-  if (tInitSubmitMsgIterEx(pMsg, &msgIter) < 0) return -1;
+  if (tInitSubmitMsgIter(pMsg, &msgIter) < 0) return -1;
   while (true) {
-    if (tGetSubmitMsgNextEx(&msgIter, &pBlock) < 0) return -1;
+    if (tGetSubmitMsgNext(&msgIter, &pBlock) < 0) return -1;
+
     if (!pBlock) break;
-    tsdbUidStorePut(pStore, msgIter.suid, NULL);
+    tsdbUidStorePut(pStore, pBlock->suid, NULL);
   }
 
   if (terrno != TSDB_CODE_SUCCESS) return -1;
@@ -2039,7 +2049,7 @@ int32_t tsdbExecuteRSma(STsdb *pTsdb, SMeta *pMeta, const void *pMsg, int32_t in
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t tsdbTriggerRSma(STsdb *pTsdb, SMeta *pMeta, const void *pMsg, int32_t inputType) {
+int32_t tsdbTriggerRSma(STsdb *pTsdb, SMeta *pMeta, void *pMsg, int32_t inputType) {
   SSmaEnv *pEnv = REPO_RSMA_ENV(pTsdb);
   if (!pEnv) {
     // only applicable when rsma env exists

From 57b492624b890ab184399b18f49018596e0562cf Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Mon, 25 Apr 2022 16:44:48 +0800
Subject: [PATCH 18/23] refactor(query): do some internal refactor.

---
 source/libs/executor/inc/executorimpl.h |   4 +-
 source/libs/executor/src/executorimpl.c | 129 ++++++++++--------------
 2 files changed, 53 insertions(+), 80 deletions(-)

diff --git a/source/libs/executor/inc/executorimpl.h b/source/libs/executor/inc/executorimpl.h
index db0dd1ffbb..363824f2e2 100644
--- a/source/libs/executor/inc/executorimpl.h
+++ b/source/libs/executor/inc/executorimpl.h
@@ -399,8 +399,8 @@ typedef struct SOptrBasicInfo {
 // TODO move the resultrowsiz together with SOptrBasicInfo:rowCellInfoOffset
 typedef struct SAggSupporter {
   SHashObj*      pResultRowHashTable;  // quick locate the window object for each result
-  SHashObj*      pResultRowListSet;    // used to check if current ResultRowInfo has ResultRow object or not
-  SArray*        pResultRowArrayList;  // The array list that contains the Result rows
+//  SHashObj*      pResultRowListSet;    // used to check if current ResultRowInfo has ResultRow object or not
+//  SArray*        pResultRowArrayList;  // The array list that contains the Result rows
   char*          keyBuf;               // window key buffer
   SDiskbasedBuf* pResultBuf;           // query result buffer based on blocked-wised disk file
   int32_t        resultRowSize;        // the result buffer size for each result row, with the meta data size for each row
diff --git a/source/libs/executor/src/executorimpl.c b/source/libs/executor/src/executorimpl.c
index 6a5f5b2dc3..321e613f82 100644
--- a/source/libs/executor/src/executorimpl.c
+++ b/source/libs/executor/src/executorimpl.c
@@ -324,11 +324,16 @@ static void prepareResultListBuffer(SResultRowInfo* pResultRowInfo, jmp_buf env)
     newCapacity = (int64_t)(pResultRowInfo->capacity * 1.5);
   }
 
-  if (newCapacity == pResultRowInfo->capacity) {
+  if (newCapacity <= pResultRowInfo->capacity) {
     newCapacity += 4;
   }
 
-  pResultRowInfo->pPosition = taosMemoryRealloc(pResultRowInfo->pPosition, newCapacity * sizeof(SResultRowPosition));
+  char* p = taosMemoryRealloc(pResultRowInfo->pPosition, newCapacity * sizeof(SResultRowPosition));
+  if (p == NULL) {
+    longjmp(env, TSDB_CODE_OUT_OF_MEMORY);
+  }
+
+  pResultRowInfo->pPosition = (SResultRowPosition*)p;
 
   int32_t inc = (int32_t)newCapacity - pResultRowInfo->capacity;
   memset(&pResultRowInfo->pPosition[pResultRowInfo->capacity], 0, sizeof(SResultRowPosition) * inc);
@@ -419,88 +424,56 @@ SResultRow* getNewResultRow_rv(SDiskbasedBuf* pResultBuf, int64_t tableGroupId,
  * | 8 bytes  | actual length |
  * +----------+---------------+
  */
-static SResultRow* doSetResultOutBufByKey_rv(SDiskbasedBuf* pResultBuf, SResultRowInfo* pResultRowInfo, int64_t uid,
+static SResultRow* doSetResultOutBufByKey(SDiskbasedBuf* pResultBuf, SResultRowInfo* pResultRowInfo, int64_t uid,
                                              char* pData, int16_t bytes, bool masterscan, uint64_t groupId,
                                              SExecTaskInfo* pTaskInfo, bool isIntervalQuery, SAggSupporter* pSup) {
-  bool existInCurrentResusltRowInfo = false;
   SET_RES_WINDOW_KEY(pSup->keyBuf, pData, bytes, groupId);
 
   SResultRowPosition* p1 =
       (SResultRowPosition*)taosHashGet(pSup->pResultRowHashTable, pSup->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes));
 
+  SResultRow* pResult = NULL;
+
   // in case of repeat scan/reverse scan, no new time window added.
   if (isIntervalQuery) {
-    if (!masterscan) {  // the *p1 may be NULL in case of sliding+offset exists.
-      if (p1 != NULL) {
-        return getResultRowByPos(pResultBuf, p1);
-      } else {
-        return NULL;
-      }
-    }
-
-    if (p1 != NULL) {
-      if (pResultRowInfo->size == 0) {
-        existInCurrentResusltRowInfo =
-            false;  // this time window created by other timestamp that does not belongs to current table.
-      } else if (pResultRowInfo->size == 1) {
-        SResultRowPosition* p = &pResultRowInfo->pPosition[0];
-        existInCurrentResusltRowInfo = (p->pageId == p1->pageId && p->offset == p1->offset);
-      } else {  // check if current pResultRowInfo contains the existInCurrentResusltRowInfo pResultRow
-        SET_RES_EXT_WINDOW_KEY(pSup->keyBuf, pData, bytes, uid, pResultRowInfo);
-        int64_t* index = taosHashGet(pSup->pResultRowListSet, pSup->keyBuf, GET_RES_EXT_WINDOW_KEY_LEN(bytes));
-        if (index != NULL) {
-          // TODO check the scan order for current opened time window
-          existInCurrentResusltRowInfo = true;
-        } else {
-          existInCurrentResusltRowInfo = false;
-        }
-      }
+    if (masterscan && p1 != NULL) {  // the *p1 may be NULL in case of sliding+offset exists.
+      pResult = getResultRowByPos(pResultBuf, p1);
     }
   } else {
     // In case of group by column query, the required SResultRow object must be existInCurrentResusltRowInfo in the
     // pResultRowInfo object.
     if (p1 != NULL) {
-      return getResultRowByPos(pResultBuf, p1);
-    }
-  }
-
-  SResultRow* pResult = NULL;
-  if (!existInCurrentResusltRowInfo) {
-    // 1. close current opened time window
-    if (pResultRowInfo->cur.pageId != -1) {  // todo extract function
-      SResultRowPosition pos = pResultRowInfo->cur;
-      SFilePage*         pPage = getBufPage(pResultBuf, pos.pageId);
-      SResultRow*        pRow = (SResultRow*)((char*)pPage + pos.offset);
-      closeResultRow(pRow);
-      releaseBufPage(pResultBuf, pPage);
-    }
-
-    prepareResultListBuffer(pResultRowInfo, pTaskInfo->env);
-    if (p1 == NULL) {
-      pResult = getNewResultRow_rv(pResultBuf, groupId, pSup->resultRowSize);
-      initResultRow(pResult);
-
-      // add a new result set for a new group
-      SResultRowPosition pos = {.pageId = pResult->pageId, .offset = pResult->offset};
-      taosHashPut(pSup->pResultRowHashTable, pSup->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes), &pos,
-                  sizeof(SResultRowPosition));
-      SResultRowCell cell = {.groupId = groupId, .pos = pos};
-      taosArrayPush(pSup->pResultRowArrayList, &cell);
-    } else {
       pResult = getResultRowByPos(pResultBuf, p1);
     }
-
-    // 2. set the new time window to be the new active time window
-    pResultRowInfo->pPosition[pResultRowInfo->size++] =
-        (SResultRowPosition){.pageId = pResult->pageId, .offset = pResult->offset};
-    pResultRowInfo->cur = (SResultRowPosition){.pageId = pResult->pageId, .offset = pResult->offset};
-    SET_RES_EXT_WINDOW_KEY(pSup->keyBuf, pData, bytes, uid, pResultRowInfo);
-    taosHashPut(pSup->pResultRowListSet, pSup->keyBuf, GET_RES_EXT_WINDOW_KEY_LEN(bytes), &pResultRowInfo->cur,
-                POINTER_BYTES);
-  } else {
-    pResult = getResultRowByPos(pResultBuf, p1);
   }
 
+    // 1. close current opened time window
+  if (pResultRowInfo->cur.pageId != -1 && ((pResult == NULL) || (pResult->pageId != pResultRowInfo->cur.pageId &&
+                                            pResult->offset != pResultRowInfo->cur.offset))) {
+    // todo extract function
+    SResultRowPosition pos = pResultRowInfo->cur;
+    SFilePage*         pPage = getBufPage(pResultBuf, pos.pageId);
+    SResultRow*        pRow = (SResultRow*)((char*)pPage + pos.offset);
+    closeResultRow(pRow);
+    releaseBufPage(pResultBuf, pPage);
+  }
+
+  // allocate a new buffer page
+  prepareResultListBuffer(pResultRowInfo, pTaskInfo->env);
+  if (pResult == NULL) {
+    pResult = getNewResultRow_rv(pResultBuf, groupId, pSup->resultRowSize);
+    initResultRow(pResult);
+
+    // add a new result set for a new group
+    SResultRowPosition pos = {.pageId = pResult->pageId, .offset = pResult->offset};
+    taosHashPut(pSup->pResultRowHashTable, pSup->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes), &pos, sizeof(SResultRowPosition));
+  }
+
+  // 2. set the new time window to be the new active time window
+  pResultRowInfo->pPosition[pResultRowInfo->size++] =
+      (SResultRowPosition){.pageId = pResult->pageId, .offset = pResult->offset};
+  pResultRowInfo->cur = (SResultRowPosition){.pageId = pResult->pageId, .offset = pResult->offset};
+
   // too many time window in query
   if (pResultRowInfo->size > MAX_INTERVAL_TIME_WINDOW) {
     longjmp(pTaskInfo->env, TSDB_CODE_QRY_TOO_MANY_TIMEWINDOW);
@@ -656,7 +629,7 @@ static int32_t setResultOutputBufByKey_rv(SResultRowInfo* pResultRowInfo, int64_
                                           int32_t numOfOutput, int32_t* rowCellInfoOffset, SAggSupporter* pAggSup,
                                           SExecTaskInfo* pTaskInfo) {
   assert(win->skey <= win->ekey);
-  SResultRow* pResultRow = doSetResultOutBufByKey_rv(pAggSup->pResultBuf, pResultRowInfo, id, (char*)&win->skey,
+  SResultRow* pResultRow = doSetResultOutBufByKey(pAggSup->pResultBuf, pResultRowInfo, id, (char*)&win->skey,
                                                      TSDB_KEYSIZE, masterscan, tableGroupId, pTaskInfo, true, pAggSup);
 
   if (pResultRow == NULL) {
@@ -1707,7 +1680,7 @@ int32_t setGroupResultOutputBuf(SOptrBasicInfo* binfo, int32_t numOfCols, char*
   SResultRowInfo* pResultRowInfo = &binfo->resultRowInfo;
   SqlFunctionCtx* pCtx = binfo->pCtx;
 
-  SResultRow* pResultRow = doSetResultOutBufByKey_rv(pBuf, pResultRowInfo, groupId, (char*)pData, bytes, true, groupId,
+  SResultRow* pResultRow = doSetResultOutBufByKey(pBuf, pResultRowInfo, groupId, (char*)pData, bytes, true, groupId,
                                                      pTaskInfo, false, pAggSup);
   assert(pResultRow != NULL);
 
@@ -2713,7 +2686,7 @@ void setFunctionResultOutput(SOptrBasicInfo* pInfo, SAggSupporter* pSup, int32_t
 
   int64_t     tid = 0;
   int64_t     groupId = 0;
-  SResultRow* pRow = doSetResultOutBufByKey_rv(pSup->pResultBuf, pResultRowInfo, tid, (char*)&tid, sizeof(tid), true,
+  SResultRow* pRow = doSetResultOutBufByKey(pSup->pResultBuf, pResultRowInfo, tid, (char*)&tid, sizeof(tid), true,
                                                groupId, pTaskInfo, false, pSup);
 
   for (int32_t i = 0; i < pDataBlock->info.numOfCols; ++i) {
@@ -3001,7 +2974,7 @@ void doSetTableGroupOutputBuf(SAggOperatorInfo* pAggInfo, int32_t numOfOutput, u
   int32_t*        rowCellInfoOffset = pAggInfo->binfo.rowCellInfoOffset;
 
   SResultRow* pResultRow =
-      doSetResultOutBufByKey_rv(pAggInfo->aggSup.pResultBuf, pResultRowInfo, uid, (char*)&groupId, sizeof(groupId),
+      doSetResultOutBufByKey(pAggInfo->aggSup.pResultBuf, pResultRowInfo, uid, (char*)&groupId, sizeof(groupId),
                                 true, groupId, pTaskInfo, false, &pAggInfo->aggSup);
   assert(pResultRow != NULL);
 
@@ -4895,8 +4868,8 @@ bool aggDecodeResultRow(SOperatorInfo* pOperator, SAggSupporter* pSup, SOptrBasi
     initResultRow(resultRow);
     prepareResultListBuffer(&pInfo->resultRowInfo, pOperator->pTaskInfo->env);
     //    pInfo->resultRowInfo.cur = pInfo->resultRowInfo.size;
-    pInfo->resultRowInfo.pPosition[pInfo->resultRowInfo.size++] =
-        (SResultRowPosition){.pageId = resultRow->pageId, .offset = resultRow->offset};
+//    pInfo->resultRowInfo.pPosition[pInfo->resultRowInfo.size++] =
+//        (SResultRowPosition){.pageId = resultRow->pageId, .offset = resultRow->offset};
     pInfo->resultRowInfo.cur = (SResultRowPosition){.pageId = resultRow->pageId, .offset = resultRow->offset};
   }
 
@@ -5609,10 +5582,10 @@ int32_t doInitAggInfoSup(SAggSupporter* pAggSup, SqlFunctionCtx* pCtx, int32_t n
   pAggSup->resultRowSize = getResultRowSize(pCtx, numOfOutput);
   pAggSup->keyBuf = taosMemoryCalloc(1, keyBufSize + POINTER_BYTES + sizeof(int64_t));
   pAggSup->pResultRowHashTable = taosHashInit(10, hashFn, true, HASH_NO_LOCK);
-  pAggSup->pResultRowListSet = taosHashInit(100, hashFn, false, HASH_NO_LOCK);
-  pAggSup->pResultRowArrayList = taosArrayInit(10, sizeof(SResultRowCell));
+//  pAggSup->pResultRowListSet = taosHashInit(100, hashFn, false, HASH_NO_LOCK);
+//  pAggSup->pResultRowArrayList = taosArrayInit(10, sizeof(SResultRowCell));
 
-  if (pAggSup->keyBuf == NULL || pAggSup->pResultRowArrayList == NULL || pAggSup->pResultRowListSet == NULL ||
+  if (pAggSup->keyBuf == NULL /*|| pAggSup->pResultRowArrayList == NULL || pAggSup->pResultRowListSet == NULL*/ ||
       pAggSup->pResultRowHashTable == NULL) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }
@@ -5628,8 +5601,8 @@ int32_t doInitAggInfoSup(SAggSupporter* pAggSup, SqlFunctionCtx* pCtx, int32_t n
 static void cleanupAggSup(SAggSupporter* pAggSup) {
   taosMemoryFreeClear(pAggSup->keyBuf);
   taosHashCleanup(pAggSup->pResultRowHashTable);
-  taosHashCleanup(pAggSup->pResultRowListSet);
-  taosArrayDestroy(pAggSup->pResultRowArrayList);
+//  taosHashCleanup(pAggSup->pResultRowListSet);
+//  taosArrayDestroy(pAggSup->pResultRowArrayList);
   destroyDiskbasedBuf(pAggSup->pResultBuf);
 }
 
@@ -6352,7 +6325,7 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
 
       int32_t     numOfCols = 0;
       tsdbReaderT pDataReader = doCreateDataReader(pTableScanNode, pHandle, pTableGroupInfo, (uint64_t)queryId, taskId);
-      if (pDataReader == NULL) {
+      if (pDataReader == NULL && terrno != 0) {
         return NULL;
       }
 

From e3e5f8d113b26ee54ef1c5ebf17b0c5870803fd9 Mon Sep 17 00:00:00 2001
From: Cary Xu <klxu@taosdata.com>
Date: Mon, 25 Apr 2022 16:46:32 +0800
Subject: [PATCH 19/23] refactor

---
 source/dnode/vnode/src/inc/tsdb.h     | 2 +-
 source/dnode/vnode/src/vnd/vnodeSvr.c | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/dnode/vnode/src/inc/tsdb.h b/source/dnode/vnode/src/inc/tsdb.h
index f751c860bd..dddc170813 100644
--- a/source/dnode/vnode/src/inc/tsdb.h
+++ b/source/dnode/vnode/src/inc/tsdb.h
@@ -56,7 +56,7 @@ int32_t tsdbInsertTSmaData(STsdb *pTsdb, int64_t indexUid, const char *msg);
 int32_t tsdbDropTSmaData(STsdb *pTsdb, int64_t indexUid);
 int32_t tsdbInsertRSmaData(STsdb *pTsdb, char *msg);
 void    tsdbCleanupReadHandle(tsdbReaderT queryHandle);
-int     tdScanAndConvertSubmitMsg(SSubmitReq *pMsg);
+int32_t tdScanAndConvertSubmitMsg(SSubmitReq *pMsg);
 typedef enum {
   TSDB_FILE_HEAD = 0,  // .head
   TSDB_FILE_DATA,      // .data
diff --git a/source/dnode/vnode/src/vnd/vnodeSvr.c b/source/dnode/vnode/src/vnd/vnodeSvr.c
index 17bdcdf964..66cc928c12 100644
--- a/source/dnode/vnode/src/vnd/vnodeSvr.c
+++ b/source/dnode/vnode/src/vnd/vnodeSvr.c
@@ -83,7 +83,7 @@ int vnodeProcessWriteReq(SVnode *pVnode, SRpcMsg *pMsg, int64_t version, SRpcMsg
     case TDMT_VND_SUBMIT:
       pRsp->msgType = TDMT_VND_SUBMIT_RSP;
       vnodeProcessSubmitReq(pVnode, ptr, pRsp);
-      tsdbTriggerRSma(pVnode->pTsdb, pVnode->pMeta, pMsg->pCont, STREAM_DATA_TYPE_SUBMIT_BLOCK);
+      tsdbTriggerRSma(pVnode->pTsdb, pVnode->pMeta, ptr, STREAM_DATA_TYPE_SUBMIT_BLOCK);
       break;
     case TDMT_VND_MQ_VG_CHANGE:
       if (tqProcessVgChangeReq(pVnode->pTq, POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead)),

From 56f3c9bf612f8a3c1b0bf3413f6ec2c6bceb7b0e Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Mon, 25 Apr 2022 17:12:28 +0800
Subject: [PATCH 20/23] fix(query): get the correct data block column number.

---
 source/libs/executor/src/executorimpl.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/source/libs/executor/src/executorimpl.c b/source/libs/executor/src/executorimpl.c
index 321e613f82..d0da970b2c 100644
--- a/source/libs/executor/src/executorimpl.c
+++ b/source/libs/executor/src/executorimpl.c
@@ -268,7 +268,6 @@ SSDataBlock* createResDataBlock(SDataBlockDescNode* pNode) {
   int32_t numOfCols = LIST_LENGTH(pNode->pSlots);
 
   SSDataBlock* pBlock = taosMemoryCalloc(1, sizeof(SSDataBlock));
-  pBlock->info.numOfCols = numOfCols;
   pBlock->pDataBlock = taosArrayInit(numOfCols, sizeof(SColumnInfoData));
 
   pBlock->info.blockId = pNode->dataBlockId;
@@ -294,6 +293,7 @@ SSDataBlock* createResDataBlock(SDataBlockDescNode* pNode) {
     taosArrayPush(pBlock->pDataBlock, &idata);
   }
 
+  pBlock->info.numOfCols = taosArrayGetSize(pBlock->pDataBlock);
   return pBlock;
 }
 
@@ -1032,6 +1032,8 @@ static int32_t doCreateConstantValColumnInfo(SInputColumnInfoData* pInput, SFunc
     pColInfo->info.bytes = tDataTypes[type].bytes;
 
     pInput->pData[paramIndex] = pColInfo;
+  } else {
+    pColInfo = pInput->pData[paramIndex];
   }
 
   ASSERT(!IS_VAR_DATA_TYPE(type));

From 1d22c07188c102a7e55b15803ad2a9f8df02fe21 Mon Sep 17 00:00:00 2001
From: Liu Jicong <liujicong@qq.com>
Date: Mon, 25 Apr 2022 17:16:28 +0800
Subject: [PATCH 21/23] remove hb

---
 source/client/src/clientHb.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/client/src/clientHb.c b/source/client/src/clientHb.c
index 653f9a0634..b11a49fa1a 100644
--- a/source/client/src/clientHb.c
+++ b/source/client/src/clientHb.c
@@ -668,7 +668,7 @@ int hbMgrInit() {
   hbMgrInitHandle();
 
   // init backgroud thread
-  hbCreateThread();
+  /*hbCreateThread();*/
 
   return 0;
 }

From 8c36142a9c63b7180764be1b642ac6f04fc6d001 Mon Sep 17 00:00:00 2001
From: Ganlin Zhao <ganlinzhao@hotmail.com>
Date: Mon, 25 Apr 2022 17:16:47 +0800
Subject: [PATCH 22/23] fix(query): fix scalar function input is constant
 return var type value contains illegal characters.

TD-15116
---
 source/libs/function/src/builtins.c | 2 +-
 source/libs/scalar/src/scalar.c     | 8 +++++---
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/source/libs/function/src/builtins.c b/source/libs/function/src/builtins.c
index a52e39bd4f..70087ee46b 100644
--- a/source/libs/function/src/builtins.c
+++ b/source/libs/function/src/builtins.c
@@ -355,7 +355,7 @@ static int32_t translateToIso8601(SFunctionNode* pFunc, char* pErrBuf, int32_t l
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  pFunc->node.resType = (SDataType) { .bytes = 24, .type = TSDB_DATA_TYPE_BINARY};
+  pFunc->node.resType = (SDataType) { .bytes = 64, .type = TSDB_DATA_TYPE_BINARY};
   return TSDB_CODE_SUCCESS;
 }
 
diff --git a/source/libs/scalar/src/scalar.c b/source/libs/scalar/src/scalar.c
index 820a4894b5..d6c0989f19 100644
--- a/source/libs/scalar/src/scalar.c
+++ b/source/libs/scalar/src/scalar.c
@@ -489,7 +489,7 @@ EDealRes sclRewriteFunction(SNode** pNode, SScalarCtx *ctx) {
   if (fmIsUserDefinedFunc(node->funcId)) {
     return DEAL_RES_CONTINUE;
   }
-  
+
   FOREACH(tnode, node->pParameterList) {
     if (!SCL_IS_CONST_NODE(tnode)) {
       return DEAL_RES_CONTINUE;
@@ -517,8 +517,10 @@ EDealRes sclRewriteFunction(SNode** pNode, SScalarCtx *ctx) {
     res->node.resType = node->node.resType;
     int32_t type = output.columnData->info.type;
     if (IS_VAR_DATA_TYPE(type)) {
-      res->datum.p = output.columnData->pData;
-      output.columnData->pData = NULL;
+      size_t tLen = varDataLen(output.columnData->pData);
+      ASSERT(tLen <= res->node.resType.bytes);
+      res->datum.p = taosMemoryCalloc(res->node.resType.bytes + VARSTR_HEADER_SIZE + 1, 1);
+      memcpy(res->datum.p, output.columnData->pData, tLen);
     } else {
       memcpy(nodesGetValueFromNode(res), output.columnData->pData, tDataTypes[type].bytes);
     }

From 28855b81b1e3b96ec15967f05b9eda0cc8b625b1 Mon Sep 17 00:00:00 2001
From: Ganlin Zhao <ganlinzhao@hotmail.com>
Date: Mon, 25 Apr 2022 17:16:47 +0800
Subject: [PATCH 23/23] fix(query): fix scalar function input is constant
 return var type value contains illegal characters.

TD-15116
---
 source/libs/scalar/src/scalar.c | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/source/libs/scalar/src/scalar.c b/source/libs/scalar/src/scalar.c
index d6c0989f19..6773f8192b 100644
--- a/source/libs/scalar/src/scalar.c
+++ b/source/libs/scalar/src/scalar.c
@@ -517,10 +517,8 @@ EDealRes sclRewriteFunction(SNode** pNode, SScalarCtx *ctx) {
     res->node.resType = node->node.resType;
     int32_t type = output.columnData->info.type;
     if (IS_VAR_DATA_TYPE(type)) {
-      size_t tLen = varDataLen(output.columnData->pData);
-      ASSERT(tLen <= res->node.resType.bytes);
       res->datum.p = taosMemoryCalloc(res->node.resType.bytes + VARSTR_HEADER_SIZE + 1, 1);
-      memcpy(res->datum.p, output.columnData->pData, tLen);
+      memcpy(res->datum.p, output.columnData->pData, varDataTLen(output.columnData->pData));
     } else {
       memcpy(nodesGetValueFromNode(res), output.columnData->pData, tDataTypes[type].bytes);
     }