From e5286898c02c21e97b91a3332771b9aa4e0a0100 Mon Sep 17 00:00:00 2001
From: Xiaoyu Wang <xiaoyuwang@taosdata.com>
Date: Fri, 11 Mar 2022 05:11:25 -0500
Subject: [PATCH 01/16] TD-13990 implement interval plan

---
 include/libs/nodes/nodes.h                 |  2 ++
 include/libs/nodes/plannodes.h             | 13 +++++++++++++
 source/libs/planner/src/planLogicCreater.c | 15 +++++++++++++++
 3 files changed, 30 insertions(+)

diff --git a/include/libs/nodes/nodes.h b/include/libs/nodes/nodes.h
index 8fb52ceb85..3a9dd3c713 100644
--- a/include/libs/nodes/nodes.h
+++ b/include/libs/nodes/nodes.h
@@ -101,6 +101,7 @@ typedef enum ENodeType {
   QUERY_NODE_LOGIC_PLAN_PROJECT,
   QUERY_NODE_LOGIC_PLAN_VNODE_MODIF,
   QUERY_NODE_LOGIC_PLAN_EXCHANGE,
+  QUERY_NODE_LOGIC_PLAN_WINDOW,
   QUERY_NODE_LOGIC_SUBPLAN,
   QUERY_NODE_LOGIC_PLAN,
 
@@ -115,6 +116,7 @@ typedef enum ENodeType {
   QUERY_NODE_PHYSICAL_PLAN_AGG,
   QUERY_NODE_PHYSICAL_PLAN_EXCHANGE,
   QUERY_NODE_PHYSICAL_PLAN_SORT,
+  QUERY_NODE_PHYSICAL_PLAN_INTERVAL,
   QUERY_NODE_PHYSICAL_PLAN_DISPATCH,
   QUERY_NODE_PHYSICAL_PLAN_INSERT,
   QUERY_NODE_PHYSICAL_SUBPLAN,
diff --git a/include/libs/nodes/plannodes.h b/include/libs/nodes/plannodes.h
index 717baf24cd..2d870008df 100644
--- a/include/libs/nodes/plannodes.h
+++ b/include/libs/nodes/plannodes.h
@@ -80,6 +80,11 @@ typedef struct SExchangeLogicNode {
   int32_t srcGroupId;
 } SExchangeLogicNode;
 
+typedef struct SWindowLogicNode {
+  SLogicNode node;
+  SNode* pWindow;
+} SWindowLogicNode;
+
 typedef enum ESubplanType {
   SUBPLAN_TYPE_MERGE = 1,
   SUBPLAN_TYPE_PARTIAL,
@@ -191,6 +196,14 @@ typedef struct SExchangePhysiNode {
   SNodeList* pSrcEndPoints;  // element is SDownstreamSource, scheduler fill by calling qSetSuplanExecutionNode
 } SExchangePhysiNode;
 
+typedef struct SIntervalPhysiNode {
+  SPhysiNode node;
+  int64_t interval;
+  int64_t sliding;
+  int64_t offset;
+  SFillNode* pFill;
+} SIntervalPhysiNode;
+
 typedef struct SDataSinkNode {
   ENodeType type;
   SDataBlockDescNode* pInputDataBlockDesc;
diff --git a/source/libs/planner/src/planLogicCreater.c b/source/libs/planner/src/planLogicCreater.c
index a93985e8ba..543bc05554 100644
--- a/source/libs/planner/src/planLogicCreater.c
+++ b/source/libs/planner/src/planLogicCreater.c
@@ -257,6 +257,18 @@ static SNodeList* createColumnByRewriteExps(SLogicPlanContext* pCxt, SNodeList*
   return cxt.pList;
 }
 
+static SLogicNode* createWindowLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect) {
+  if (NULL == pSelect->pWindow) {
+    return NULL;
+  }
+
+  SWindowLogicNode* pAgg = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW);
+  CHECK_ALLOC(pAgg, NULL);
+  pAgg->node.id = pCxt->planNodeId++;
+
+
+}
+
 static SLogicNode* createAggLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect) {
   SNodeList* pAggFuncs = NULL;
   CHECK_CODE(nodesCollectFuncs(pSelect, fmIsAggFunc, &pAggFuncs), NULL);
@@ -345,6 +357,9 @@ static SLogicNode* createSelectLogicNode(SLogicPlanContext* pCxt, SSelectStmt* p
     pRoot->pConditions = nodesCloneNode(pSelect->pWhere);
     CHECK_ALLOC(pRoot->pConditions, pRoot);
   }
+  if (TSDB_CODE_SUCCESS == pCxt->errCode) {
+    pRoot = pushLogicNode(pCxt, pRoot, createWindowLogicNode(pCxt, pSelect));
+  }
   if (TSDB_CODE_SUCCESS == pCxt->errCode) {
     pRoot = pushLogicNode(pCxt, pRoot, createAggLogicNode(pCxt, pSelect));
   }

From 64d979fd5c652b3e9d3fdf412904ea40e3684a9c Mon Sep 17 00:00:00 2001
From: ubuntu <ubuntu@ubuntu-OptiPlex-7060>
Date: Sat, 12 Mar 2022 19:07:53 +0800
Subject: [PATCH 02/16] update transport

---
 include/libs/transport/trpc.h            |  7 +++
 source/libs/transport/inc/transportInt.h |  1 +
 source/libs/transport/src/transCli.c     | 59 +++++++++++++++---------
 source/libs/transport/src/transSrv.c     |  2 +-
 4 files changed, 47 insertions(+), 22 deletions(-)

diff --git a/include/libs/transport/trpc.h b/include/libs/transport/trpc.h
index fdc9368b76..8dfd736df6 100644
--- a/include/libs/transport/trpc.h
+++ b/include/libs/transport/trpc.h
@@ -71,6 +71,10 @@ typedef struct SRpcInit {
   // call back to keep conn or not
   bool (*pfp)(void *parent, tmsg_t msgType);
 
+  // to support Send messages multiple times on a link  
+  // 
+  void* (*mfp)(void *parent, tmsg_t msgType);
+
   void *parent;
 } SRpcInit;
 
@@ -89,6 +93,9 @@ void    rpcSendRecv(void *shandle, SEpSet *pEpSet, SRpcMsg *pReq, SRpcMsg *pRsp)
 int     rpcReportProgress(void *pConn, char *pCont, int contLen);
 void    rpcCancelRequest(int64_t rid);
 
+// just release client conn to rpc instance, no close sock
+void rpcReleaseHandle(void *handle);   
+
 void rpcRefHandle(void *handle, int8_t type);
 void rpcUnrefHandle(void *handle, int8_t type);
 
diff --git a/source/libs/transport/inc/transportInt.h b/source/libs/transport/inc/transportInt.h
index 4e4dcf7aa4..3924a5cf1a 100644
--- a/source/libs/transport/inc/transportInt.h
+++ b/source/libs/transport/inc/transportInt.h
@@ -64,6 +64,7 @@ typedef struct {
   void (*cfp)(void* parent, SRpcMsg*, SEpSet*);
   int (*afp)(void* parent, char* user, char* spi, char* encrypt, char* secret, char* ckey);
   bool (*pfp)(void* parent, tmsg_t msgType);
+  void* (*mfp)(void* parent, tmsg_t msgType);
 
   int32_t         refCount;
   void*           parent;
diff --git a/source/libs/transport/src/transCli.c b/source/libs/transport/src/transCli.c
index 727845b7a9..ce3c1c2dc8 100644
--- a/source/libs/transport/src/transCli.c
+++ b/source/libs/transport/src/transCli.c
@@ -135,13 +135,12 @@ static void         destroyThrdObj(SCliThrdObj* pThrd);
     }                            \
   } while (0);
 
+#define CONN_PERSIST_BY_APP(conn) do { if (conn->persist == false) { conn->persist = true; transRefCliHandle(conn);}} while(0)
+#define CONN_NO_PERSIST_BY_APP(conn) ((conn)->persist == false)
+
 static void* cliWorkThread(void* arg);
 
-static void* cliNotifyApp() {}
 static void  cliHandleResp(SCliConn* conn) {
-  SCliMsg*       pMsg = conn->data;
-  STransConnCtx* pCtx = pMsg->ctx;
-
   SCliThrdObj* pThrd = conn->hostThrd;
   SRpcInfo*    pTransInst = pThrd->pTransInst;
 
@@ -157,14 +156,24 @@ static void  cliHandleResp(SCliConn* conn) {
   rpcMsg.pCont = transContFromHead((char*)pHead);
   rpcMsg.code = pHead->code;
   rpcMsg.msgType = pHead->msgType;
-  rpcMsg.ahandle = pCtx->ahandle;
+  rpcMsg.ahandle = NULL; 
 
-  if (pTransInst->pfp != NULL && (pTransInst->pfp)(pTransInst->parent, rpcMsg.msgType)) {
+  SCliMsg* pMsg = conn->data;
+  STransConnCtx *pCtx = pMsg ? pMsg->ctx : NULL;
+  if (pMsg == NULL && !CONN_NO_PERSIST_BY_APP(conn)) {
+    rpcMsg.ahandle = pTransInst->mfp ? (*pTransInst->mfp)(pTransInst->parent, rpcMsg.msgType) : NULL;
+  } else {
+    rpcMsg.ahandle = pCtx ? pCtx->ahandle : NULL;  
+  }
+  //if (rpcMsg.ahandle == NULL) {
+  //  tDebug("%s cli conn %p handle except", CONN_GET_INST_LABEL(conn), conn);
+  //  return;
+  //}
+
+  if (pTransInst->pfp != NULL && (*pTransInst->pfp)(pTransInst->parent, rpcMsg.msgType)) {
     rpcMsg.handle = conn;
-    transRefCliHandle(conn);
-
-    conn->persist = 1;
-    tDebug("cli conn %p persist by app", conn);
+    CONN_PERSIST_BY_APP(conn);
+    tDebug("%s cli conn %p ref by app", CONN_GET_INST_LABEL(conn), conn);
   }
 
   tDebug("%s cli conn %p %s received from %s:%d, local info: %s:%d, msg size: %d", pTransInst->label, conn,
@@ -173,7 +182,7 @@ static void  cliHandleResp(SCliConn* conn) {
 
   conn->secured = pHead->secured;
 
-  if (pCtx->pSem == NULL) {
+  if (pCtx == NULL || pCtx->pSem == NULL) {
     tTrace("%s cli conn %p handle resp", pTransInst->label, conn);
     (pTransInst->cfp)(pTransInst->parent, &rpcMsg, NULL);
   } else {
@@ -184,8 +193,7 @@ static void  cliHandleResp(SCliConn* conn) {
 
   uv_read_start((uv_stream_t*)conn->stream, cliAllocBufferCb, cliRecvCb);
 
-  // user owns conn->persist = 1
-  if (conn->persist == 0) {
+  if (CONN_NO_PERSIST_BY_APP(conn)) {
     addConnToPool(pThrd->pool, pCtx->ip, pCtx->port, conn);
   }
   destroyCmsg(conn->data);
@@ -198,22 +206,29 @@ static void  cliHandleResp(SCliConn* conn) {
 }
 static void cliHandleExcept(SCliConn* pConn) {
   if (pConn->data == NULL) {
-    // handle conn except in conn pool
-    transUnrefCliHandle(pConn);
-    return;
+     if (pConn->broken == true || CONN_NO_PERSIST_BY_APP(pConn)) {
+        transUnrefCliHandle(pConn);
+        return;
+     }
   }
   SCliThrdObj* pThrd = pConn->hostThrd;
   SRpcInfo*    pTransInst = pThrd->pTransInst;
 
   SCliMsg*       pMsg = pConn->data;
-  STransConnCtx* pCtx = pMsg->ctx;
+  STransConnCtx *pCtx = pMsg ? pMsg->ctx : NULL;
 
   SRpcMsg rpcMsg = {0};
-  rpcMsg.ahandle = pCtx->ahandle;
   rpcMsg.code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
-  rpcMsg.msgType = pMsg->msg.msgType + 1;
+  rpcMsg.msgType = pMsg ? pMsg->msg.msgType + 1 : 0;
+  rpcMsg.ahandle = NULL; 
 
-  if (pCtx->pSem == NULL) {
+  if (pMsg == NULL && !CONN_NO_PERSIST_BY_APP(pConn)) {
+    rpcMsg.ahandle = pTransInst->mfp ? (*pTransInst->mfp)(pTransInst->parent, rpcMsg.msgType) : NULL;
+  } else {
+    rpcMsg.ahandle = pCtx ? pCtx->ahandle : NULL;  
+  }
+
+  if (pCtx == NULL || pCtx->pSem == NULL) {
     tTrace("%s cli conn %p handle resp", pTransInst->label, pConn);
     (pTransInst->cfp)(pTransInst->parent, &rpcMsg, NULL);
   } else {
@@ -358,6 +373,7 @@ static SCliConn* cliCreateConn(SCliThrdObj* pThrd) {
 
   QUEUE_INIT(&conn->conn);
   conn->hostThrd = pThrd;
+  conn->persist = false;
   conn->broken = false;
   transRefCliHandle(conn);
   return conn;
@@ -476,7 +492,6 @@ static SCliConn* cliGetConn(SCliMsg* pMsg, SCliThrdObj* pThrd) {
   SCliConn* conn = NULL;
   if (pMsg->msg.handle != NULL) {
     conn = (SCliConn*)(pMsg->msg.handle);
-    transUnrefCliHandle(conn);
     if (conn != NULL) {
       tTrace("%s cli conn %p reused", CONN_GET_INST_LABEL(conn), conn);
     }
@@ -514,6 +529,7 @@ static void cliHandleReq(SCliMsg* pMsg, SCliThrdObj* pThrd) {
     tTrace("%s cli conn %p try to connect to %s:%d", pTransInst->label, conn, pMsg->ctx->ip, pMsg->ctx->port);
     uv_tcp_connect(&conn->connReq, (uv_tcp_t*)(conn->stream), (const struct sockaddr*)&addr, cliConnCb);
   }
+  
   conn->hThrdIdx = pCtx->hThrdIdx;
 }
 static void cliAsyncCb(uv_async_t* handle) {
@@ -683,6 +699,7 @@ void rpcSendRequest(void* shandle, const SEpSet* pEpSet, SRpcMsg* pMsg, int64_t*
   if (transCompressMsg(pMsg->pCont, pMsg->contLen, &flen)) {
     // imp later
   }
+  tDebug("send request at thread:%d %p", index, pMsg);
   STransConnCtx* pCtx = calloc(1, sizeof(STransConnCtx));
   pCtx->ahandle = pMsg->ahandle;
   pCtx->msgType = pMsg->msgType;
diff --git a/source/libs/transport/src/transSrv.c b/source/libs/transport/src/transSrv.c
index 1abca9ad97..c4c3d9ed0a 100644
--- a/source/libs/transport/src/transSrv.c
+++ b/source/libs/transport/src/transSrv.c
@@ -260,7 +260,7 @@ void uvOnRecvCb(uv_stream_t* cli, ssize_t nread, const uv_buf_t* buf) {
   }
 
   tError("server conn %p read error: %s", conn, uv_err_name(nread));
-  if (nread < 0 || nread == UV_EOF) {
+  if (nread < 0) {
     conn->broken = true;
     transUnrefSrvHandle(conn);
 

From 421d087a8f11d75ec00323290d5b3039eb434196 Mon Sep 17 00:00:00 2001
From: Cary Xu <klxu@taosdata.com>
Date: Sat, 12 Mar 2022 19:19:21 +0800
Subject: [PATCH 03/16] add tsdbBDBImpl files

---
 include/common/taosdef.h                  |   6 +
 source/dnode/vnode/inc/tsdb.h             |   2 +
 source/dnode/vnode/src/inc/tsdbDBDef.h    |  35 ++++
 source/dnode/vnode/src/inc/tsdbDef.h      |  16 +-
 source/dnode/vnode/src/inc/tsdbFile.h     |  12 +-
 source/dnode/vnode/src/inc/tsdbSma.h      |  50 +++++-
 source/dnode/vnode/src/tsdb/tsdbBDBImpl.c | 112 +++++++++++++
 source/dnode/vnode/src/tsdb/tsdbMain.c    |  29 +++-
 source/dnode/vnode/src/tsdb/tsdbSma.c     | 196 +++++++++++++++++-----
 source/dnode/vnode/src/tsdb/tsdbWrite.c   |   8 +
 source/dnode/vnode/test/tsdbSmaTest.cpp   |  53 +++++-
 11 files changed, 465 insertions(+), 54 deletions(-)
 create mode 100644 source/dnode/vnode/src/inc/tsdbDBDef.h

diff --git a/include/common/taosdef.h b/include/common/taosdef.h
index 9e5e5ebdcf..8dc634571f 100644
--- a/include/common/taosdef.h
+++ b/include/common/taosdef.h
@@ -61,6 +61,12 @@ typedef enum {
   TSDB_SMA_STAT_EXPIRED = 1,  // not ready or expired
 } ETsdbSmaStat;
 
+typedef enum {
+  TSDB_SMA_TYPE_BLOCK = 0,       // Block-wise SMA
+  TSDB_SMA_TYPE_TIME_RANGE = 1,  // Time-range-wise SMA
+  TSDB_SMA_TYPE_ROLLUP = 2,      // Rollup SMA
+} ETsdbSmaType;
+
 extern char *qtypeStr[];
 
 #define TSDB_PORT_HTTP      11
diff --git a/source/dnode/vnode/inc/tsdb.h b/source/dnode/vnode/inc/tsdb.h
index e67e0cae4b..25bac86f71 100644
--- a/source/dnode/vnode/inc/tsdb.h
+++ b/source/dnode/vnode/inc/tsdb.h
@@ -96,6 +96,8 @@ int    tsdbCommit(STsdb *pTsdb);
  */
 int32_t tsdbInsertTSmaData(STsdb *pTsdb, char *msg);
 
+int32_t tsdbUpdateSmaWindow(STsdb *pTsdb, int8_t smaType, char *msg);
+
 /**
  * @brief Insert RSma(Time-range-wise Rollup SMA) data.
  *
diff --git a/source/dnode/vnode/src/inc/tsdbDBDef.h b/source/dnode/vnode/src/inc/tsdbDBDef.h
new file mode 100644
index 0000000000..cc40cec7d1
--- /dev/null
+++ b/source/dnode/vnode/src/inc/tsdbDBDef.h
@@ -0,0 +1,35 @@
+/*
+ * 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_TSDB_DB_DEF_H_
+#define _TD_TSDB_DB_DEF_H_
+
+#include "db.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct SDBFile SDBFile;
+typedef DB_ENV*        TDBEnv;
+
+int32_t tsdbOpenDBF(TDBEnv pEnv, SDBFile* pDBF);
+void    tsdbCloseDBF(SDBFile* pDBF);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_TSDB_DB_DEF_H_*/
diff --git a/source/dnode/vnode/src/inc/tsdbDef.h b/source/dnode/vnode/src/inc/tsdbDef.h
index 1451ac9685..0956e418bb 100644
--- a/source/dnode/vnode/src/inc/tsdbDef.h
+++ b/source/dnode/vnode/src/inc/tsdbDef.h
@@ -43,6 +43,8 @@ extern "C" {
 
 struct STsdb {
   int32_t               vgId;
+  bool                  repoLocked;
+  pthread_mutex_t       mutex;
   char *                path;
   STsdbCfg              config;
   STsdbMemTable *       mem;
@@ -52,12 +54,18 @@ struct STsdb {
   STsdbFS *             fs;
   SMeta *               pMeta;
   STfs *                pTfs;
-  SSmaStat *            pSmaStat;
+  SSmaEnv *             pTSmaEnv;
+  SSmaEnv *             pRSmaEnv;
+  // SSmaStat *            pSmaStat;
 };
 
-#define REPO_ID(r) ((r)->vgId)
-#define REPO_CFG(r) (&(r)->config)
-#define REPO_FS(r) (r)->fs
+#define REPO_ID(r)        ((r)->vgId)
+#define REPO_CFG(r)       (&(r)->config)
+#define REPO_FS(r)        (r)->fs
+#define IS_REPO_LOCKED(r) (r)->repoLocked
+
+int tsdbLockRepo(STsdb *pTsdb);
+int tsdbUnlockRepo(STsdb *pTsdb);
 
 static FORCE_INLINE STSchema *tsdbGetTableSchemaImpl(STable *pTable, bool lock, bool copy, int32_t version) {
   return pTable->pSchema;
diff --git a/source/dnode/vnode/src/inc/tsdbFile.h b/source/dnode/vnode/src/inc/tsdbFile.h
index 5cc8cc045e..e65ef72623 100644
--- a/source/dnode/vnode/src/inc/tsdbFile.h
+++ b/source/dnode/vnode/src/inc/tsdbFile.h
@@ -329,21 +329,23 @@ static FORCE_INLINE int tsdbCopyDFile(SDFile* pSrc, SDFile* pDest) {
 // =============== SDFileSet
 typedef struct {
   int      fid;
-  int8_t   state;    // -128~127
-  uint8_t  ver;      // 0~255, DFileSet version
+  int8_t   state;  // -128~127
+  uint8_t  ver;    // 0~255, DFileSet version
   uint16_t reserve;
   SDFile   files[TSDB_FILE_MAX];
 } SDFileSet;
 
 typedef struct {
-  int     fid;
-  int8_t  state;
-  uint8_t ver;
+  int      fid;
+  int8_t   state;
+  uint8_t  ver;
+  uint16_t reserve;
 #if 0
   SDFInfo   info;
 #endif
   STfsFile  f;
   TdFilePtr pFile;
+
 } SSFile;  // files split by days with fid
 
 #define TSDB_LATEST_FSET_VER 0
diff --git a/source/dnode/vnode/src/inc/tsdbSma.h b/source/dnode/vnode/src/inc/tsdbSma.h
index 7fceb580d6..87e20b8aa9 100644
--- a/source/dnode/vnode/src/inc/tsdbSma.h
+++ b/source/dnode/vnode/src/inc/tsdbSma.h
@@ -17,27 +17,40 @@
 #define _TD_TSDB_SMA_H_
 
 typedef struct SSmaStat SSmaStat;
+typedef struct SSmaEnv  SSmaEnv;
+
+
+struct SSmaEnv {
+  pthread_rwlock_t lock;
+  char *           path;
+  SSmaStat *       pStat;
+};
+
+#define SMA_ENV_LOCK(env)       ((env)->lock)
+#define SMA_ENV_PATH(env)       ((env)->path)
+#define SMA_ENV_STAT(env)       ((env)->pStat)
+#define SMA_ENV_STAT_ITEMS(env) ((env)->pStat->smaStatItems)
 
 // insert/update interface
 int32_t tsdbInsertTSmaDataImpl(STsdb *pTsdb, char *msg);
 int32_t tsdbInsertRSmaDataImpl(STsdb *pTsdb, char *msg);
 
-
 // query interface
 // TODO: This is the basic params, and should wrap the params to a queryHandle.
 int32_t tsdbGetTSmaDataImpl(STsdb *pTsdb, STSmaDataWrapper *pData, STimeWindow *queryWin, int32_t nMaxResult);
 
 // management interface
-int32_t tsdbUpdateExpiredWindow(STsdb *pTsdb, char *msg);
-int32_t tsdbDestroySmaState(SSmaStat *pSmaStat);
+int32_t tsdbUpdateExpiredWindow(STsdb *pTsdb, int8_t smaType, char *msg);
+void    tsdbDestroySmaEnv(SSmaEnv *pSmaEnv);
+void *  tsdbFreeSmaEnv(SSmaEnv *pSmaEnv);
 #if 0
 int32_t tsdbGetTSmaStatus(STsdb *pTsdb, STSma *param, void *result);
 int32_t tsdbRemoveTSmaData(STsdb *pTsdb, STSma *param, STimeWindow *pWin);
 #endif
 
+
+
 // internal func
-
-
 static FORCE_INLINE int32_t tsdbEncodeTSmaKey(tb_uid_t tableUid, col_id_t colId, TSKEY tsKey, void **pData) {
   int32_t len = 0;
   len += taosEncodeFixedI64(pData, tableUid);
@@ -46,4 +59,31 @@ static FORCE_INLINE int32_t tsdbEncodeTSmaKey(tb_uid_t tableUid, col_id_t colId,
   return len;
 }
 
+static FORCE_INLINE int tsdbRLockSma(SSmaEnv *pEnv) {
+  int code = pthread_rwlock_rdlock(&(pEnv->lock));
+  if (code != 0) {
+    terrno = TAOS_SYSTEM_ERROR(code);
+    return -1;
+  }
+  return 0;
+}
+
+static FORCE_INLINE int tsdbWLockSma(SSmaEnv *pEnv) {
+  int code = pthread_rwlock_wrlock(&(pEnv->lock));
+  if (code != 0) {
+    terrno = TAOS_SYSTEM_ERROR(code);
+    return -1;
+  }
+  return 0;
+}
+
+static FORCE_INLINE int tsdbUnLockSma(SSmaEnv *pEnv) {
+  int code = pthread_rwlock_unlock(&(pEnv->lock));
+  if (code != 0) {
+    terrno = TAOS_SYSTEM_ERROR(code);
+    return -1;
+  }
+  return 0;
+}
+
 #endif /* _TD_TSDB_SMA_H_ */
\ No newline at end of file
diff --git a/source/dnode/vnode/src/tsdb/tsdbBDBImpl.c b/source/dnode/vnode/src/tsdb/tsdbBDBImpl.c
index f2f48bbc8a..7ea9f134cf 100644
--- a/source/dnode/vnode/src/tsdb/tsdbBDBImpl.c
+++ b/source/dnode/vnode/src/tsdb/tsdbBDBImpl.c
@@ -12,3 +12,115 @@
  * 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 ALLOW_FORBID_FUNC
+#include "db.h"
+
+#include "tcoding.h"
+#include "thash.h"
+#include "tsdbDBDef.h"
+
+#define IMPL_WITH_LOCK 1
+
+struct SDBFile {
+  DB *  pDB;
+  char *path;
+};
+
+static int   tsdbOpenBDBEnv(DB_ENV **ppEnv, const char *path);
+static void  tsdbCloseBDBEnv(DB_ENV *pEnv);
+static int   tsdbOpenBDBDb(DB **ppDB, DB_ENV *pEnv, const char *pFName, bool isDup);
+static void  tsdbCloseBDBDb(DB *pDB);
+
+#define BDB_PERR(info, code) fprintf(stderr, info " reason: %s", db_strerror(code))
+
+int tsdbOpenDBF(TDBEnv pEnv, SDBFile *pDBF) {
+  // TDBEnv is shared by a group of SDBFile
+  ASSERT(pEnv != NULL);
+
+  // Open DBF
+  if (tsdbOpenBDBDb(&(pDBF->pDB), pEnv, pDBF->path, false) < 0) {
+    tsdbCloseBDBDb(pDBF->pDB);
+    return -1;
+  }
+
+  return 0;
+}
+
+static void *tsdbFreeDBF(SDBFile *pDBF) {
+  if (pDBF) {
+    free(pDBF);
+  }
+  return NULL;
+}
+
+void tsdbCloseDBF(SDBFile *pDBF) {
+  if (pDBF->pDB) {
+    tsdbCloseBDBDb(pDBF->pDB);
+    pDBF->pDB = tsdbFreeDBF(pDBF);
+  }
+}
+
+static int tsdbOpenBDBEnv(DB_ENV **ppEnv, const char *path) {
+  int     ret = 0;
+  DB_ENV *pEnv = NULL;
+
+  if (path == NULL) return 0;
+
+  ret = db_env_create(&pEnv, 0);
+  if (ret != 0) {
+    BDB_PERR("Failed to create tsdb env", ret);
+    return -1;
+  }
+
+  ret = pEnv->open(pEnv, path, DB_CREATE | DB_INIT_CDB | DB_INIT_MPOOL, 0);
+  if (ret != 0) {
+    BDB_PERR("Failed to open tsdb env", ret);
+    return -1;
+  }
+
+  *ppEnv = pEnv;
+
+  return 0;
+}
+
+static void tsdbCloseBDBEnv(DB_ENV *pEnv) {
+  if (pEnv) {
+    pEnv->close(pEnv, 0);
+  }
+}
+
+static int tsdbOpenBDBDb(DB **ppDB, DB_ENV *pEnv, const char *pFName, bool isDup) {
+  int ret;
+  DB *pDB;
+
+  ret = db_create(&(pDB), pEnv, 0);
+  if (ret != 0) {
+    BDB_PERR("Failed to create DBP", ret);
+    return -1;
+  }
+
+  if (isDup) {
+    ret = pDB->set_flags(pDB, DB_DUPSORT);
+    if (ret != 0) {
+      BDB_PERR("Failed to set DB flags", ret);
+      return -1;
+    }
+  }
+
+  ret = pDB->open(pDB, NULL, pFName, NULL, DB_BTREE, DB_CREATE, 0);
+  if (ret) {
+    BDB_PERR("Failed to open DBF", ret);
+    return -1;
+  }
+
+  *ppDB = pDB;
+
+  return 0;
+}
+
+static void tsdbCloseBDBDb(DB *pDB) {
+  if (pDB) {
+    pDB->close(pDB, 0);
+  }
+}
\ No newline at end of file
diff --git a/source/dnode/vnode/src/tsdb/tsdbMain.c b/source/dnode/vnode/src/tsdb/tsdbMain.c
index 0c82911226..afa8921c00 100644
--- a/source/dnode/vnode/src/tsdb/tsdbMain.c
+++ b/source/dnode/vnode/src/tsdb/tsdbMain.c
@@ -80,6 +80,8 @@ static STsdb *tsdbNew(const char *path, int32_t vgId, const STsdbCfg *pTsdbCfg,
   pTsdb->pmaf = pMAF;
   pTsdb->pMeta = pMeta;
   pTsdb->pTfs = pTfs;
+  pTsdb->pTSmaEnv = NULL;
+  pTsdb->pRSmaEnv = NULL;
 
   pTsdb->fs = tsdbNewFS(pTsdbCfg);
 
@@ -88,8 +90,9 @@ static STsdb *tsdbNew(const char *path, int32_t vgId, const STsdbCfg *pTsdbCfg,
 
 static void tsdbFree(STsdb *pTsdb) {
   if (pTsdb) {
+    tsdbFreeSmaEnv(pTsdb->pRSmaEnv);
+    tsdbFreeSmaEnv(pTsdb->pTSmaEnv);
     tsdbFreeFS(pTsdb->fs);
-    tsdbDestroySmaState(pTsdb->pSmaStat);
     tfree(pTsdb->path);
     free(pTsdb);
   }
@@ -105,6 +108,30 @@ static void tsdbCloseImpl(STsdb *pTsdb) {
   tsdbCloseFS(pTsdb);
   // TODO
 }
+
+int tsdbLockRepo(STsdb *pTsdb) {
+  int code = pthread_mutex_lock(&pTsdb->mutex);
+  if (code != 0) {
+    tsdbError("vgId:%d failed to lock tsdb since %s", REPO_ID(pTsdb), strerror(errno));
+    terrno = TAOS_SYSTEM_ERROR(code);
+    return -1;
+  }
+  pTsdb->repoLocked = true;
+  return 0;
+}
+
+int tsdbUnlockRepo(STsdb *pTsdb) {
+  ASSERT(IS_REPO_LOCKED(pTsdb));
+  pTsdb->repoLocked = false;
+  int code = pthread_mutex_unlock(&pTsdb->mutex);
+  if (code != 0) {
+    tsdbError("vgId:%d failed to unlock tsdb since %s", REPO_ID(pTsdb), strerror(errno));
+    terrno = TAOS_SYSTEM_ERROR(code);
+    return -1;
+  }
+  return 0;
+}
+
 #if 0
 /*
  * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
diff --git a/source/dnode/vnode/src/tsdb/tsdbSma.c b/source/dnode/vnode/src/tsdb/tsdbSma.c
index dc0d262725..ba8cde2121 100644
--- a/source/dnode/vnode/src/tsdb/tsdbSma.c
+++ b/source/dnode/vnode/src/tsdb/tsdbSma.c
@@ -16,6 +16,7 @@
 #include "tsdbDef.h"
 
 #define SMA_STORAGE_TSDB_DAYS   30
+#define SMA_STORAGE_TSDB_TIMES  30
 #define SMA_STORAGE_SPLIT_HOURS 24
 #define SMA_KEY_LEN             18  // tableUid_colId_TSKEY 8+2+8
 
@@ -68,19 +69,104 @@ struct SSmaStat {
 };
 
 // declaration of static functions
-static int32_t tsdbInitTSmaWriteH(STSmaWriteH *pSmaH, STsdb *pTsdb, STSmaDataWrapper *pData);
-static int32_t tsdbInitTSmaReadH(STSmaReadH *pSmaH, STsdb *pTsdb, STSmaDataWrapper *pData);
-static int32_t tsdbJudgeStorageLevel(int64_t interval, int8_t intervalUnit);
-static int32_t tsdbInsertTSmaDataSection(STSmaWriteH *pSmaH, STSmaDataWrapper *pData);
-static int32_t tsdbInsertTSmaBlocks(void *bTree, const char *smaKey, const char *pData, int32_t dataLen);
+static int32_t  tsdbInitSmaStat(SSmaStat **pSmaStat);
+static int32_t  tsdbDestroySmaState(SSmaStat *pSmaStat);
+static SSmaEnv *tsdbNewSmaEnv(const STsdb *pTsdb, const char *path);
+static int32_t  tsdbInitSmaEnv(STsdb *pTsdb, const char *path, SSmaEnv **pEnv);
+static int32_t  tsdbInitTSmaWriteH(STSmaWriteH *pSmaH, STsdb *pTsdb, STSmaDataWrapper *pData);
+static int32_t  tsdbInitTSmaReadH(STSmaReadH *pSmaH, STsdb *pTsdb, STSmaDataWrapper *pData);
+static int32_t  tsdbGetSmaStorageLevel(int64_t interval, int8_t intervalUnit);
+static int32_t  tsdbInsertTSmaDataSection(STSmaWriteH *pSmaH, STSmaDataWrapper *pData);
+static int32_t  tsdbInsertTSmaBlocks(void *bTree, const char *smaKey, const char *pData, int32_t dataLen);
 
 static int64_t tsdbGetIntervalByPrecision(int64_t interval, uint8_t intervalUnit, int8_t precision);
+static int32_t tsdbGetTSmaDays(STSmaWriteH *pSmaH, int32_t storageLevel);
 static int32_t tsdbSetTSmaDataFile(STSmaWriteH *pSmaH, STSmaDataWrapper *pData, int32_t storageLevel, int32_t fid);
-
 static int32_t tsdbInitTSmaReadH(STSmaReadH *pSmaH, STsdb *pTsdb, STSmaDataWrapper *pData);
 static int32_t tsdbInitTSmaFile(STSmaReadH *pReadH, STimeWindow *queryWin);
 static bool    tsdbSetAndOpenTSmaFile(STSmaReadH *pReadH, STimeWindow *queryWin);
 
+static SSmaEnv *tsdbNewSmaEnv(const STsdb *pTsdb, const char *path) {
+  SSmaEnv *pEnv = NULL;
+
+  pEnv = (SSmaEnv *)calloc(1, sizeof(SSmaEnv));
+  if (pEnv == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
+
+  int code = pthread_rwlock_init(&(pEnv->lock), NULL);
+  if (code) {
+    terrno = TAOS_SYSTEM_ERROR(code);
+    free(pEnv);
+    return NULL;
+  }
+
+  ASSERT(path && (strlen(path) > 0));
+  pEnv->path = strdup(path);
+  if (pEnv->path == NULL) {
+    tsdbFreeSmaEnv(pEnv);
+    return NULL;
+  }
+
+  if (tsdbInitSmaStat(&pEnv->pStat) != TSDB_CODE_SUCCESS) {
+    tsdbFreeSmaEnv(pEnv);
+    return NULL;
+  }
+
+  return pEnv;
+}
+
+static int32_t tsdbInitSmaEnv(STsdb *pTsdb, const char *path, SSmaEnv **pEnv) {
+  if (!pEnv) {
+    terrno = TSDB_CODE_INVALID_PTR;
+    return TSDB_CODE_FAILED;
+  }
+
+  if (pEnv && *pEnv) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if (tsdbLockRepo(pTsdb) != 0) {
+    return TSDB_CODE_FAILED;
+  }
+
+  if (*pEnv == NULL) {
+    if ((*pEnv = tsdbNewSmaEnv(pTsdb, path)) == NULL) {
+      tsdbUnlockRepo(pTsdb);
+      return TSDB_CODE_FAILED;
+    }
+  }
+
+  if (tsdbUnlockRepo(pTsdb) != 0) {
+    tsdbFreeSmaEnv(*pEnv);
+    return TSDB_CODE_FAILED;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+/**
+ * @brief Release resources allocated for its member fields, not including itself.
+ *
+ * @param pSmaEnv
+ * @return int32_t
+ */
+void tsdbDestroySmaEnv(SSmaEnv *pSmaEnv) {
+  if (pSmaEnv) {
+    tsdbDestroySmaState(pSmaEnv->pStat);
+    tfree(pSmaEnv->pStat);
+    tfree(pSmaEnv->path);
+    pthread_rwlock_destroy(&(pSmaEnv->lock));
+  }
+}
+
+void *tsdbFreeSmaEnv(SSmaEnv *pSmaEnv) {
+  tsdbDestroySmaEnv(pSmaEnv);
+  tfree(pSmaEnv);
+  return NULL;
+}
+
 static int32_t tsdbInitSmaStat(SSmaStat **pSmaStat) {
   ASSERT(pSmaStat != NULL);
 
@@ -125,6 +211,12 @@ static SSmaStatItem *tsdbNewSmaStatItem(int8_t state) {
   return pItem;
 }
 
+/**
+ * @brief Release resources allocated for its member fields, not including itself.
+ * 
+ * @param pSmaStat 
+ * @return int32_t 
+ */
 int32_t tsdbDestroySmaState(SSmaStat *pSmaStat) {
   if (pSmaStat) {
     // TODO: use taosHashSetFreeFp when taosHashSetFreeFp is ready.
@@ -135,30 +227,42 @@ int32_t tsdbDestroySmaState(SSmaStat *pSmaStat) {
       item = taosHashIterate(pSmaStat->smaStatItems, item);
     }
     taosHashCleanup(pSmaStat->smaStatItems);
-    free(pSmaStat);
   }
 }
 
 /**
  * @brief Update expired window according to msg from stream computing module.
- *
- * @param pTsdb
- * @param msg
- * @return int32_t
+ * 
+ * @param pTsdb 
+ * @param smaType ETsdbSmaType
+ * @param msg 
+ * @return int32_t 
  */
-int32_t tsdbUpdateExpiredWindow(STsdb *pTsdb, char *msg) {
-  if (msg == NULL) {
+int32_t tsdbUpdateExpiredWindow(STsdb *pTsdb, int8_t smaType, char *msg) {
+  STsdbCfg *pCfg = REPO_CFG(pTsdb);
+  SSmaEnv * pEnv = NULL;
+
+  if (!msg || !pTsdb->pMeta) {
+    terrno = TSDB_CODE_INVALID_PTR;
     return TSDB_CODE_FAILED;
   }
 
-  // lazy mode
-  if (tsdbInitSmaStat(&pTsdb->pSmaStat) != TSDB_CODE_SUCCESS) {
+  if (smaType == TSDB_SMA_TYPE_TIME_RANGE) {
+    pEnv = pTsdb->pTSmaEnv;
+  } else if (smaType == TSDB_SMA_TYPE_ROLLUP) {
+    pEnv = pTsdb->pRSmaEnv;
+  } else {
+    ASSERT(0);
+  }
+
+  char smaPath[TSDB_FILENAME_LEN] = "/proj/.sma/";
+  if (tsdbInitSmaEnv(pTsdb, smaPath, &pEnv) != TSDB_CODE_SUCCESS) {
     return TSDB_CODE_FAILED;
   }
 
   // TODO: decode the msg => start
   int64_t       indexUid = SMA_TEST_INDEX_UID;
-  const char *  indexName = SMA_TEST_INDEX_NAME;
+  // const char *  indexName = SMA_TEST_INDEX_NAME;
   const int32_t SMA_TEST_EXPIRED_WINDOW_SIZE = 10;
   TSKEY         expiredWindows[SMA_TEST_EXPIRED_WINDOW_SIZE];
   int64_t       now = taosGetTimestampMs();
@@ -167,9 +271,9 @@ int32_t tsdbUpdateExpiredWindow(STsdb *pTsdb, char *msg) {
   }
 
   // TODO: decode the msg <= end
-  SHashObj *pItemsHash = pTsdb->pSmaStat->smaStatItems;
+  SHashObj *pItemsHash = SMA_ENV_STAT_ITEMS(pEnv);
 
-  SSmaStatItem *pItem = (SSmaStatItem *)taosHashGet(pItemsHash, indexName, strlen(indexName));
+  SSmaStatItem *pItem = (SSmaStatItem *)taosHashGet(pItemsHash, &indexUid, sizeof(indexUid));
   if (pItem == NULL) {
     pItem = tsdbNewSmaStatItem(TSDB_SMA_STAT_EXPIRED);  // TODO use the real state
     if (pItem == NULL) {
@@ -188,7 +292,7 @@ int32_t tsdbUpdateExpiredWindow(STsdb *pTsdb, char *msg) {
     pItem->pSma = pSma;
 
     // TODO: change indexName to indexUid
-    if (taosHashPut(pItemsHash, indexName, strnlen(indexName, TSDB_INDEX_NAME_LEN), &pItem, sizeof(pItem)) != 0) {
+    if (taosHashPut(pItemsHash, &indexUid, sizeof(indexUid), &pItem, sizeof(pItem)) != 0) {
       // If error occurs during put smaStatItem, free the resources of pItem
       taosHashCleanup(pItem->expiredWindows);
       free(pItem);
@@ -207,7 +311,7 @@ int32_t tsdbUpdateExpiredWindow(STsdb *pTsdb, char *msg) {
       // windows failed to put into hash table.
       taosHashCleanup(pItem->expiredWindows);
       tfree(pItem->pSma);
-      taosHashRemove(pItemsHash, indexName, sizeof(indexName));
+      taosHashRemove(pItemsHash, &indexUid, sizeof(indexUid));
       return TSDB_CODE_FAILED;
     }
   }
@@ -215,11 +319,12 @@ int32_t tsdbUpdateExpiredWindow(STsdb *pTsdb, char *msg) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t tsdbResetExpiredWindow(STsdb *pTsdb, int64_t indexUid, TSKEY skey) {
+static int32_t tsdbResetExpiredWindow(SSmaStat *pStat, int64_t indexUid, TSKEY skey) {
   SSmaStatItem *pItem = NULL;
 
-  if (pTsdb->pSmaStat && pTsdb->pSmaStat->smaStatItems) {
-    pItem = (SSmaStatItem *)taosHashGet(pTsdb->pSmaStat->smaStatItems, &indexUid, sizeof(indexUid));
+  // TODO: If HASH_ENTRY_LOCK used, whether rwlock needed to handle cases of removing hashNode?
+  if (pStat && pStat->smaStatItems) {
+    pItem = (SSmaStatItem *)taosHashGet(pStat->smaStatItems, &indexUid, sizeof(indexUid));
   }
 
   if (pItem != NULL) {
@@ -241,7 +346,7 @@ static int32_t tsdbResetExpiredWindow(STsdb *pTsdb, int64_t indexUid, TSKEY skey
  * @param intervalUnit
  * @return int32_t
  */
-static int32_t tsdbJudgeStorageLevel(int64_t interval, int8_t intervalUnit) {
+static int32_t tsdbGetSmaStorageLevel(int64_t interval, int8_t intervalUnit) {
   // TODO: configurable for SMA_STORAGE_SPLIT_HOURS?
   switch (intervalUnit) {
     case TD_TIME_UNIT_HOUR:
@@ -422,12 +527,24 @@ static int32_t tsdbInitTSmaWriteH(STSmaWriteH *pSmaH, STsdb *pTsdb, STSmaDataWra
 }
 
 static int32_t tsdbSetTSmaDataFile(STSmaWriteH *pSmaH, STSmaDataWrapper *pData, int32_t storageLevel, int32_t fid) {
-  // TODO
+  STsdb *pTsdb = pSmaH->pTsdb;
+  
   pSmaH->pDFile = "tSma_interval_file_name";
 
   return TSDB_CODE_SUCCESS;
-} 
+}
 
+static int32_t tsdbGetTSmaDays(STSmaWriteH *pSmaH, int32_t storageLevel) {
+  STsdbCfg *pCfg = REPO_CFG(pSmaH->pTsdb);
+  int32_t   daysPerFile = pCfg->daysPerFile;
+
+  if (storageLevel == SMA_STORAGE_LEVEL_TSDB) {
+    int32_t days = 30 * (pSmaH->interval / tsTickPerDay[pCfg->precision]);
+    daysPerFile = days > SMA_STORAGE_TSDB_DAYS ? days : SMA_STORAGE_TSDB_DAYS;
+  }
+
+  return daysPerFile;
+}
 
 /**
  * @brief Insert/Update Time-range-wise SMA data.
@@ -454,23 +571,26 @@ int32_t tsdbInsertTSmaDataImpl(STsdb *pTsdb, char *msg) {
     return terrno;
   }
 
-  // Step 1: Judge the storage level
-  int32_t storageLevel = tsdbJudgeStorageLevel(pData->interval, pData->intervalUnit);
-  int32_t daysPerFile = storageLevel == SMA_STORAGE_LEVEL_TSDB ? SMA_STORAGE_TSDB_DAYS : pCfg->daysPerFile;
+  if (!pTsdb->pTSmaEnv) {
+    terrno = TSDB_CODE_INVALID_PTR;
+    return terrno;
+  }
+
+  // Step 1: Judge the storage level and days
+  int32_t storageLevel = tsdbGetSmaStorageLevel(pData->interval, pData->intervalUnit);
+  int32_t daysPerFile = tsdbGetTSmaDays(&tSmaH, storageLevel);
+  int32_t fid = (int32_t)(TSDB_KEY_FID(pData->skey, daysPerFile, pCfg->precision));
 
   // Step 2: Set the DFile for storage of SMA index, and iterate/split the TSma data and store to B+Tree index file
   //         - Set and open the DFile or the B+Tree file
-
-  int32_t fid = (int32_t)(TSDB_KEY_FID(pData->skey, daysPerFile, pCfg->precision));
-
-  // Save all the TSma data to one file
   // TODO: tsdbStartTSmaCommit();
   tsdbSetTSmaDataFile(&tSmaH, pData, storageLevel, fid);
+
   tsdbInsertTSmaDataSection(&tSmaH, pData);
   // TODO:tsdbEndTSmaCommit();
 
   // reset the SSmaStat
-  tsdbResetExpiredWindow(pTsdb, pData->indexUid, pData->skey);
+  tsdbResetExpiredWindow(SMA_ENV_STAT(pTsdb->pTSmaEnv), pData->indexUid, pData->skey);
 
   return TSDB_CODE_SUCCESS;
 }
@@ -496,7 +616,7 @@ int32_t tsdbInsertRSmaDataImpl(STsdb *pTsdb, char *msg) {
   }
 
   // Step 1: Judge the storage level
-  int32_t storageLevel = tsdbJudgeStorageLevel(pData->interval, pData->intervalUnit);
+  int32_t storageLevel = tsdbGetSmaStorageLevel(pData->interval, pData->intervalUnit);
   int32_t daysPerFile = storageLevel == SMA_STORAGE_LEVEL_TSDB ? SMA_STORAGE_TSDB_DAYS : pCfg->daysPerFile;
 
   // Step 2: Set the DFile for storage of SMA index, and iterate/split the TSma data and store to B+Tree index file
@@ -511,7 +631,7 @@ int32_t tsdbInsertRSmaDataImpl(STsdb *pTsdb, char *msg) {
   // TODO:tsdbEndTSmaCommit();
 
   // reset the SSmaStat
-  tsdbResetExpiredWindow(pTsdb, pData->indexUid, pData->skey);
+  tsdbResetExpiredWindow(SMA_ENV_STAT(pTsdb->pRSmaEnv), pData->indexUid, pData->skey);
 
   return TSDB_CODE_SUCCESS;
 }
@@ -540,7 +660,7 @@ static int32_t tsdbInitTSmaReadH(STSmaReadH *pSmaH, STsdb *pTsdb, STSmaDataWrapp
  * @return int32_t
  */
 static int32_t tsdbInitTSmaFile(STSmaReadH *pReadH, STimeWindow *queryWin) {
-  int32_t storageLevel = 0;   //tsdbJudgeStorageLevel(param->interval, param->intervalUnit);
+  int32_t storageLevel = 0;  // tsdbGetSmaStorageLevel(param->interval, param->intervalUnit);
   int32_t daysPerFile =
       storageLevel == SMA_STORAGE_LEVEL_TSDB ? SMA_STORAGE_TSDB_DAYS : REPO_CFG(pReadH->pTsdb)->daysPerFile;
   pReadH->storageLevel = storageLevel;
@@ -594,7 +714,7 @@ static bool tsdbSetAndOpenTSmaFile(STSmaReadH *pReadH, STimeWindow *queryWin) {
  */
 int32_t tsdbGetTSmaDataImpl(STsdb *pTsdb, STSmaDataWrapper *pData, STimeWindow *queryWin, int32_t nMaxResult) {
   SSmaStatItem *pItem =
-      (SSmaStatItem *)taosHashGet(pTsdb->pSmaStat->smaStatItems, &pData->indexUid, sizeof(pData->indexUid));
+      (SSmaStatItem *)taosHashGet(SMA_ENV_STAT_ITEMS(pTsdb->pTSmaEnv), &pData->indexUid, sizeof(pData->indexUid));
   if (pItem == NULL) {
     // mark all window as expired and notify query module to query raw TS data.
     return TSDB_CODE_SUCCESS;
diff --git a/source/dnode/vnode/src/tsdb/tsdbWrite.c b/source/dnode/vnode/src/tsdb/tsdbWrite.c
index 26d31af4f3..dede1502f4 100644
--- a/source/dnode/vnode/src/tsdb/tsdbWrite.c
+++ b/source/dnode/vnode/src/tsdb/tsdbWrite.c
@@ -51,6 +51,14 @@ int32_t tsdbInsertTSmaData(STsdb *pTsdb, char *msg) {
   return code;
 }
 
+int32_t tsdbUpdateSmaWindow(STsdb *pTsdb, int8_t smaType, char *msg) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  if ((code = tsdbUpdateExpiredWindow(pTsdb, smaType, msg)) < 0) {
+    tsdbWarn("vgId:%d update expired window failed since %s", REPO_ID(pTsdb), tstrerror(terrno));
+  }
+  return code;
+}
+
 /**
  * @brief Insert Time-range-wise Rollup Sma(RSma) data
  *
diff --git a/source/dnode/vnode/test/tsdbSmaTest.cpp b/source/dnode/vnode/test/tsdbSmaTest.cpp
index ac9a8fd3d0..159ad98219 100644
--- a/source/dnode/vnode/test/tsdbSmaTest.cpp
+++ b/source/dnode/vnode/test/tsdbSmaTest.cpp
@@ -221,12 +221,60 @@ TEST(testCase, tSma_DB_Put_Get_Del_Test) {
 
 #if 1
 TEST(testCase, tSmaInsertTest) {
+  // prepare meta
+  const char *   smaIndexName1 = "sma_index_test_1";
+  const char *   smaIndexName2 = "sma_index_test_2";
+  const char *   timezone = "Asia/Shanghai";
+  const char *   expr = "select count(a,b, top 20), from table interval 1d, sliding 1h;";
+  const char *   tagsFilter = "I'm tags filter";
+  const char *   smaTestDir = "./smaTest";
+  const tb_uid_t tbUid = 1234567890;
+  const int64_t  indexUid1 = 2000000001;
+  const int64_t  indexUid2 = 2000000002;
+  const uint32_t nCntTSma = 2;
+  // encode
+  STSma tSma = {0};
+  tSma.version = 0;
+  tSma.intervalUnit = TD_TIME_UNIT_DAY;
+  tSma.interval = 1;
+  tSma.slidingUnit = TD_TIME_UNIT_HOUR;
+  tSma.sliding = 0;
+  tSma.indexUid = indexUid1;
+  tstrncpy(tSma.indexName, smaIndexName1, TSDB_INDEX_NAME_LEN);
+  tstrncpy(tSma.timezone, timezone, TD_TIMEZONE_LEN);
+  tSma.tableUid = tbUid;
+
+  tSma.exprLen = strlen(expr);
+  tSma.expr = (char *)calloc(tSma.exprLen + 1, 1);
+  tstrncpy(tSma.expr, expr, tSma.exprLen + 1);
+
+  tSma.tagsFilterLen = strlen(tagsFilter);
+  tSma.tagsFilter = (char *)calloc(tSma.tagsFilterLen + 1, 1);
+  tstrncpy(tSma.tagsFilter, tagsFilter, tSma.tagsFilterLen + 1);
+
+  SMeta *         pMeta = NULL;
+  STSma *         pSmaCfg = &tSma;
+  const SMetaCfg *pMetaCfg = &defaultMetaOptions;
+
+  taosRemoveDir(smaTestDir);
+
+  pMeta = metaOpen(smaTestDir, pMetaCfg, NULL);
+  assert(pMeta != NULL);
+  // save index 1
+  EXPECT_EQ(metaSaveSmaToDB(pMeta, pSmaCfg), 0);
+
+
+  // insert data
   const int64_t     indexUid = 2000000002;
   STSmaDataWrapper *pSmaData = NULL;
   STsdb             tsdb = {0};
   STsdbCfg *        pCfg = &tsdb.config;
 
   pCfg->daysPerFile = 1;
+  tsdb.pMeta = pMeta;
+
+  char *msg = (char *)calloc(100, 1);
+  EXPECT_EQ(tsdbUpdateSmaWindow(&tsdb, TSDB_SMA_TYPE_TIME_RANGE, msg), 0);
 
   // init
   int32_t allocCnt = 0;
@@ -277,8 +325,11 @@ TEST(testCase, tSmaInsertTest) {
   // execute
   EXPECT_EQ(tsdbInsertTSmaData(&tsdb, (char *)pSmaData), TSDB_CODE_SUCCESS);
 
-  // release
+  // release data
   taosTZfree(buf);
+  // release meta
+  tdDestroyTSma(&tSma);
+  metaClose(pMeta);
 }
 #endif
 

From 4caa94d5c9c80848c5c07ce530fcc6cf1ce5eb00 Mon Sep 17 00:00:00 2001
From: afwerar <1296468573@qq.com>
Date: Sun, 13 Mar 2022 18:55:12 +0800
Subject: [PATCH 04/16] [TD-13767]<fix>: redefine Locale api.

---
 include/os/osLocale.h    | 6 +++++-
 source/os/src/osLocale.c | 1 +
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/include/os/osLocale.h b/include/os/osLocale.h
index 6e313eb8cd..ddafd2e93c 100644
--- a/include/os/osLocale.h
+++ b/include/os/osLocale.h
@@ -17,12 +17,16 @@
 #define _TD_OS_LOCALE_H_
 
 #include "os.h"
-#include "osString.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+// If the error is in a third-party library, place this header file under the third-party library header file.
+#ifndef ALLOW_FORBID_FUNC
+    #define setlocale SETLOCALE_FUNC_TAOS_FORBID
+#endif
+
 char *taosCharsetReplace(char *charsetstr);
 void  taosGetSystemLocale(char *outLocale, char *outCharset);
 void  taosSetSystemLocale(const char *inLocale, const char *inCharSet);
diff --git a/source/os/src/osLocale.c b/source/os/src/osLocale.c
index 47546f7deb..e9d6ed7c54 100644
--- a/source/os/src/osLocale.c
+++ b/source/os/src/osLocale.c
@@ -13,6 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#define ALLOW_FORBID_FUNC
 #define _DEFAULT_SOURCE
 #include "osLocale.h"
 

From abbd818fe6e639cd8e7cc171446b6de6699095f2 Mon Sep 17 00:00:00 2001
From: Cary Xu <klxu@taosdata.com>
Date: Sun, 13 Mar 2022 23:32:33 +0800
Subject: [PATCH 05/16] import SmaEnv/SmaStat to facilitate save data

---
 include/util/taoserror.h                  |   1 +
 source/dnode/vnode/src/inc/tsdbDBDef.h    |   8 ++
 source/dnode/vnode/src/inc/tsdbDef.h      |   3 +-
 source/dnode/vnode/src/inc/tsdbSma.h      |   2 +-
 source/dnode/vnode/src/meta/metaBDBImpl.c |  37 +++---
 source/dnode/vnode/src/tsdb/tsdbBDBImpl.c |  50 ++++++--
 source/dnode/vnode/src/tsdb/tsdbSma.c     | 149 +++++++++++++++-------
 source/dnode/vnode/src/tsdb/tsdbWrite.c   |   2 +-
 source/dnode/vnode/test/tsdbSmaTest.cpp   |  21 +--
 source/util/src/terror.c                  |   1 +
 10 files changed, 186 insertions(+), 88 deletions(-)

diff --git a/include/util/taoserror.h b/include/util/taoserror.h
index 3a1343b384..1c61d738b5 100644
--- a/include/util/taoserror.h
+++ b/include/util/taoserror.h
@@ -353,6 +353,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_TDB_MESSED_MSG                TAOS_DEF_ERROR_CODE(0, 0x0614)
 #define TSDB_CODE_TDB_IVLD_TAG_VAL              TAOS_DEF_ERROR_CODE(0, 0x0615)
 #define TSDB_CODE_TDB_NO_CACHE_LAST_ROW         TAOS_DEF_ERROR_CODE(0, 0x0616)
+#define TSDB_CODE_TDB_NO_SMA_INDEX_IN_META      TAOS_DEF_ERROR_CODE(0, 0x0617)
 
 // query
 #define TSDB_CODE_QRY_INVALID_QHANDLE           TAOS_DEF_ERROR_CODE(0, 0x0700)
diff --git a/source/dnode/vnode/src/inc/tsdbDBDef.h b/source/dnode/vnode/src/inc/tsdbDBDef.h
index cc40cec7d1..7740dd0fab 100644
--- a/source/dnode/vnode/src/inc/tsdbDBDef.h
+++ b/source/dnode/vnode/src/inc/tsdbDBDef.h
@@ -25,8 +25,16 @@ extern "C" {
 typedef struct SDBFile SDBFile;
 typedef DB_ENV*        TDBEnv;
 
+struct SDBFile {
+  DB*   pDB;
+  char* path;
+};
+
 int32_t tsdbOpenDBF(TDBEnv pEnv, SDBFile* pDBF);
 void    tsdbCloseDBF(SDBFile* pDBF);
+int32_t tsdbOpenBDBEnv(DB_ENV** ppEnv, const char* path);
+void    tsdbCloseBDBEnv(DB_ENV* pEnv);
+int32_t tsdbSaveSmaToDB(SDBFile* pDBF, void* key, uint32_t keySize, void* data, uint32_t dataSize);
 
 #ifdef __cplusplus
 }
diff --git a/source/dnode/vnode/src/inc/tsdbDef.h b/source/dnode/vnode/src/inc/tsdbDef.h
index 0956e418bb..6f91b4d3ab 100644
--- a/source/dnode/vnode/src/inc/tsdbDef.h
+++ b/source/dnode/vnode/src/inc/tsdbDef.h
@@ -27,6 +27,7 @@
 #include "ttime.h"
 
 #include "tsdb.h"
+#include "tsdbDBDef.h"
 #include "tsdbCommit.h"
 #include "tsdbFS.h"
 #include "tsdbFile.h"
@@ -37,6 +38,7 @@
 #include "tsdbReadImpl.h"
 #include "tsdbSma.h"
 
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -56,7 +58,6 @@ struct STsdb {
   STfs *                pTfs;
   SSmaEnv *             pTSmaEnv;
   SSmaEnv *             pRSmaEnv;
-  // SSmaStat *            pSmaStat;
 };
 
 #define REPO_ID(r)        ((r)->vgId)
diff --git a/source/dnode/vnode/src/inc/tsdbSma.h b/source/dnode/vnode/src/inc/tsdbSma.h
index 87e20b8aa9..c54fdf85a3 100644
--- a/source/dnode/vnode/src/inc/tsdbSma.h
+++ b/source/dnode/vnode/src/inc/tsdbSma.h
@@ -19,9 +19,9 @@
 typedef struct SSmaStat SSmaStat;
 typedef struct SSmaEnv  SSmaEnv;
 
-
 struct SSmaEnv {
   pthread_rwlock_t lock;
+  TDBEnv           dbEnv;
   char *           path;
   SSmaStat *       pStat;
 };
diff --git a/source/dnode/vnode/src/meta/metaBDBImpl.c b/source/dnode/vnode/src/meta/metaBDBImpl.c
index d9af526c2a..a729288e34 100644
--- a/source/dnode/vnode/src/meta/metaBDBImpl.c
+++ b/source/dnode/vnode/src/meta/metaBDBImpl.c
@@ -231,30 +231,31 @@ int metaSaveSmaToDB(SMeta *pMeta, STSma *pSmaCfg) {
   void *pBuf = NULL, *qBuf = NULL;
   DBT   key1 = {0}, value1 = {0};
 
-  {
-    // save sma info
-    int32_t len = tEncodeTSma(NULL, pSmaCfg);
-    pBuf = calloc(len, 1);
-    if (pBuf == NULL) {
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      return -1;
-    }
-
-    key1.data = (void *)&pSmaCfg->indexUid;
-    key1.size = sizeof(pSmaCfg->indexUid);
-
-    qBuf = pBuf;
-    tEncodeTSma(&qBuf, pSmaCfg);
-
-    value1.data = pBuf;
-    value1.size = POINTER_DISTANCE(qBuf, pBuf);
-    value1.app_data = pSmaCfg;
+  // save sma info
+  int32_t len = tEncodeTSma(NULL, pSmaCfg);
+  pBuf = calloc(len, 1);
+  if (pBuf == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
   }
 
+  key1.data = (void *)&pSmaCfg->indexUid;
+  key1.size = sizeof(pSmaCfg->indexUid);
+
+  qBuf = pBuf;
+  tEncodeTSma(&qBuf, pSmaCfg);
+
+  value1.data = pBuf;
+  value1.size = POINTER_DISTANCE(qBuf, pBuf);
+  value1.app_data = pSmaCfg;
+
   metaDBWLock(pMeta->pDB);
   pMeta->pDB->pSmaDB->put(pMeta->pDB->pSmaDB, NULL, &key1, &value1, 0);
   metaDBULock(pMeta->pDB);
 
+  // release
+  tfree(pBuf);
+
   return 0;
 }
 
diff --git a/source/dnode/vnode/src/tsdb/tsdbBDBImpl.c b/source/dnode/vnode/src/tsdb/tsdbBDBImpl.c
index 7ea9f134cf..4fc415cfd1 100644
--- a/source/dnode/vnode/src/tsdb/tsdbBDBImpl.c
+++ b/source/dnode/vnode/src/tsdb/tsdbBDBImpl.c
@@ -16,30 +16,29 @@
 #define ALLOW_FORBID_FUNC
 #include "db.h"
 
+#include "taoserror.h"
 #include "tcoding.h"
 #include "thash.h"
 #include "tsdbDBDef.h"
+#include "tsdbLog.h"
 
 #define IMPL_WITH_LOCK 1
 
-struct SDBFile {
-  DB *  pDB;
-  char *path;
-};
+static int  tsdbOpenBDBDb(DB **ppDB, DB_ENV *pEnv, const char *pFName, bool isDup);
+static void tsdbCloseBDBDb(DB *pDB);
 
-static int   tsdbOpenBDBEnv(DB_ENV **ppEnv, const char *path);
-static void  tsdbCloseBDBEnv(DB_ENV *pEnv);
-static int   tsdbOpenBDBDb(DB **ppDB, DB_ENV *pEnv, const char *pFName, bool isDup);
-static void  tsdbCloseBDBDb(DB *pDB);
-
-#define BDB_PERR(info, code) fprintf(stderr, info " reason: %s", db_strerror(code))
+#define BDB_PERR(info, code) fprintf(stderr, "%s:%d " info " reason: %s\n", __FILE__, __LINE__, db_strerror(code))
 
 int tsdbOpenDBF(TDBEnv pEnv, SDBFile *pDBF) {
   // TDBEnv is shared by a group of SDBFile
-  ASSERT(pEnv != NULL);
+  if (!pEnv) {
+    terrno = TSDB_CODE_INVALID_PTR;
+    return -1;
+  }
 
   // Open DBF
   if (tsdbOpenBDBDb(&(pDBF->pDB), pEnv, pDBF->path, false) < 0) {
+    terrno = TSDB_CODE_TDB_INIT_FAILED;
     tsdbCloseBDBDb(pDBF->pDB);
     return -1;
   }
@@ -61,7 +60,7 @@ void tsdbCloseDBF(SDBFile *pDBF) {
   }
 }
 
-static int tsdbOpenBDBEnv(DB_ENV **ppEnv, const char *path) {
+int32_t tsdbOpenBDBEnv(DB_ENV **ppEnv, const char *path) {
   int     ret = 0;
   DB_ENV *pEnv = NULL;
 
@@ -75,7 +74,8 @@ static int tsdbOpenBDBEnv(DB_ENV **ppEnv, const char *path) {
 
   ret = pEnv->open(pEnv, path, DB_CREATE | DB_INIT_CDB | DB_INIT_MPOOL, 0);
   if (ret != 0) {
-    BDB_PERR("Failed to open tsdb env", ret);
+    // BDB_PERR("Failed to open tsdb env", ret);
+    tsdbWarn("Failed to open tsdb env for path %s since %d", path ? path : "NULL", ret);
     return -1;
   }
 
@@ -84,7 +84,7 @@ static int tsdbOpenBDBEnv(DB_ENV **ppEnv, const char *path) {
   return 0;
 }
 
-static void tsdbCloseBDBEnv(DB_ENV *pEnv) {
+void tsdbCloseBDBEnv(DB_ENV *pEnv) {
   if (pEnv) {
     pEnv->close(pEnv, 0);
   }
@@ -123,4 +123,26 @@ static void tsdbCloseBDBDb(DB *pDB) {
   if (pDB) {
     pDB->close(pDB, 0);
   }
+}
+
+int32_t tsdbSaveSmaToDB(SDBFile *pDBF, void *key, uint32_t keySize, void *data, uint32_t dataSize) {
+  int ret;
+  DBT key1 = {0}, value1 = {0};
+
+  key1.data = key;
+  key1.size = keySize;
+
+  value1.data = data;
+  value1.size = dataSize;
+
+  // TODO: lock
+  ret = pDBF->pDB->put(pDBF->pDB, NULL, &key1, &value1, 0);
+  if (ret) {
+    BDB_PERR("Failed to put data to DBF", ret);
+    // TODO: unlock
+    return -1;
+  }
+  // TODO: unlock
+
+  return 0;
 }
\ No newline at end of file
diff --git a/source/dnode/vnode/src/tsdb/tsdbSma.c b/source/dnode/vnode/src/tsdb/tsdbSma.c
index ba8cde2121..f96ea644b4 100644
--- a/source/dnode/vnode/src/tsdb/tsdbSma.c
+++ b/source/dnode/vnode/src/tsdb/tsdbSma.c
@@ -24,16 +24,16 @@
 #define SMA_STATE_ITEM_HASH_SLOT 32
 
 #define SMA_TEST_INDEX_NAME "smaTestIndexName"  // TODO: just for test
-#define SMA_TEST_INDEX_UID  123456              // TODO: just for test
+#define SMA_TEST_INDEX_UID  2000000001          // TODO: just for test
 typedef enum {
   SMA_STORAGE_LEVEL_TSDB = 0,     // use days of self-defined  e.g. vnode${N}/tsdb/tsma/sma_index_uid/v2t200.dat
   SMA_STORAGE_LEVEL_DFILESET = 1  // use days of TS data       e.g. vnode${N}/tsdb/rsma/sma_index_uid/v2r200.dat
 } ESmaStorageLevel;
 
 typedef struct {
-  STsdb * pTsdb;
-  char *  pDFile;     // TODO: use the real DFile type, not char*
-  int32_t interval;   // interval with the precision of DB
+  STsdb *  pTsdb;
+  SDBFile *pDFile;
+  int32_t  interval;  // interval with the precision of DB
   // TODO
 } STSmaWriteH;
 
@@ -74,10 +74,11 @@ static int32_t  tsdbDestroySmaState(SSmaStat *pSmaStat);
 static SSmaEnv *tsdbNewSmaEnv(const STsdb *pTsdb, const char *path);
 static int32_t  tsdbInitSmaEnv(STsdb *pTsdb, const char *path, SSmaEnv **pEnv);
 static int32_t  tsdbInitTSmaWriteH(STSmaWriteH *pSmaH, STsdb *pTsdb, STSmaDataWrapper *pData);
+static void     tsdbDestroyTSmaWriteH(STSmaWriteH *pSmaH);
 static int32_t  tsdbInitTSmaReadH(STSmaReadH *pSmaH, STsdb *pTsdb, STSmaDataWrapper *pData);
 static int32_t  tsdbGetSmaStorageLevel(int64_t interval, int8_t intervalUnit);
 static int32_t  tsdbInsertTSmaDataSection(STSmaWriteH *pSmaH, STSmaDataWrapper *pData);
-static int32_t  tsdbInsertTSmaBlocks(void *bTree, const char *smaKey, const char *pData, int32_t dataLen);
+static int32_t tsdbInsertTSmaBlocks(STSmaWriteH *pSmaH, void *smaKey, uint32_t keyLen, void *pData, uint32_t dataLen);
 
 static int64_t tsdbGetIntervalByPrecision(int64_t interval, uint8_t intervalUnit, int8_t precision);
 static int32_t tsdbGetTSmaDays(STSmaWriteH *pSmaH, int32_t storageLevel);
@@ -114,6 +115,11 @@ static SSmaEnv *tsdbNewSmaEnv(const STsdb *pTsdb, const char *path) {
     return NULL;
   }
 
+  if (tsdbOpenBDBEnv(&pEnv->dbEnv, pEnv->path) != TSDB_CODE_SUCCESS) {
+    tsdbFreeSmaEnv(pEnv);
+    return NULL;
+  }
+
   return pEnv;
 }
 
@@ -158,6 +164,7 @@ void tsdbDestroySmaEnv(SSmaEnv *pSmaEnv) {
     tfree(pSmaEnv->pStat);
     tfree(pSmaEnv->path);
     pthread_rwlock_destroy(&(pSmaEnv->lock));
+    tsdbCloseBDBEnv(pSmaEnv->dbEnv);
   }
 }
 
@@ -213,9 +220,9 @@ static SSmaStatItem *tsdbNewSmaStatItem(int8_t state) {
 
 /**
  * @brief Release resources allocated for its member fields, not including itself.
- * 
- * @param pSmaStat 
- * @return int32_t 
+ *
+ * @param pSmaStat
+ * @return int32_t
  */
 int32_t tsdbDestroySmaState(SSmaStat *pSmaStat) {
   if (pSmaStat) {
@@ -232,11 +239,11 @@ int32_t tsdbDestroySmaState(SSmaStat *pSmaStat) {
 
 /**
  * @brief Update expired window according to msg from stream computing module.
- * 
- * @param pTsdb 
+ *
+ * @param pTsdb
  * @param smaType ETsdbSmaType
- * @param msg 
- * @return int32_t 
+ * @param msg
+ * @return int32_t
  */
 int32_t tsdbUpdateExpiredWindow(STsdb *pTsdb, int8_t smaType, char *msg) {
   STsdbCfg *pCfg = REPO_CFG(pTsdb);
@@ -247,21 +254,21 @@ int32_t tsdbUpdateExpiredWindow(STsdb *pTsdb, int8_t smaType, char *msg) {
     return TSDB_CODE_FAILED;
   }
 
-  if (smaType == TSDB_SMA_TYPE_TIME_RANGE) {
-    pEnv = pTsdb->pTSmaEnv;
-  } else if (smaType == TSDB_SMA_TYPE_ROLLUP) {
-    pEnv = pTsdb->pRSmaEnv;
-  } else {
-    ASSERT(0);
-  }
-
   char smaPath[TSDB_FILENAME_LEN] = "/proj/.sma/";
   if (tsdbInitSmaEnv(pTsdb, smaPath, &pEnv) != TSDB_CODE_SUCCESS) {
     return TSDB_CODE_FAILED;
   }
 
+  if (smaType == TSDB_SMA_TYPE_TIME_RANGE) {
+    pTsdb->pTSmaEnv = pEnv;
+  } else if (smaType == TSDB_SMA_TYPE_ROLLUP) {
+    pTsdb->pRSmaEnv = pEnv;
+  } else {
+    ASSERT(0);
+  }
+
   // TODO: decode the msg => start
-  int64_t       indexUid = SMA_TEST_INDEX_UID;
+  int64_t indexUid = SMA_TEST_INDEX_UID;
   // const char *  indexName = SMA_TEST_INDEX_NAME;
   const int32_t SMA_TEST_EXPIRED_WINDOW_SIZE = 10;
   TSKEY         expiredWindows[SMA_TEST_EXPIRED_WINDOW_SIZE];
@@ -285,8 +292,11 @@ int32_t tsdbUpdateExpiredWindow(STsdb *pTsdb, int8_t smaType, char *msg) {
     // cache smaMeta
     STSma *pSma = metaGetSmaInfoByIndex(pTsdb->pMeta, indexUid);
     if (pSma == NULL) {
+      terrno = TSDB_CODE_TDB_NO_SMA_INDEX_IN_META;
       taosHashCleanup(pItem->expiredWindows);
       free(pItem);
+      tsdbWarn("vgId:%d update expired window failed for smaIndex %" PRIi64 " since %s", REPO_ID(pTsdb), indexUid,
+               tstrerror(terrno));
       return TSDB_CODE_FAILED;
     }
     pItem->pSma = pSma;
@@ -299,6 +309,11 @@ int32_t tsdbUpdateExpiredWindow(STsdb *pTsdb, int8_t smaType, char *msg) {
       return TSDB_CODE_FAILED;
     }
   }
+#if 0
+  SSmaStatItem *pItem1 = (SSmaStatItem *)taosHashGet(pItemsHash, &indexUid, sizeof(indexUid));
+  int size1 = taosHashGetSize(pItem1->expiredWindows);
+  tsdbWarn("vgId:%d smaIndex %" PRIi64 " size is %d before hashPut", REPO_ID(pTsdb), indexUid, size1);
+#endif
 
   int8_t state = TSDB_SMA_STAT_EXPIRED;
   for (int32_t i = 0; i < SMA_TEST_EXPIRED_WINDOW_SIZE; ++i) {
@@ -316,6 +331,12 @@ int32_t tsdbUpdateExpiredWindow(STsdb *pTsdb, int8_t smaType, char *msg) {
     }
   }
 
+#if 0
+  SSmaStatItem *pItem2 = (SSmaStatItem *)taosHashGet(pItemsHash, &indexUid, sizeof(indexUid));
+  int size2 = taosHashGetSize(pItem1->expiredWindows);
+  tsdbWarn("vgId:%d smaIndex %" PRIi64 " size is %d after hashPut", REPO_ID(pTsdb), indexUid, size2);
+#endif
+
   return TSDB_CODE_SUCCESS;
 }
 
@@ -326,7 +347,7 @@ static int32_t tsdbResetExpiredWindow(SSmaStat *pStat, int64_t indexUid, TSKEY s
   if (pStat && pStat->smaStatItems) {
     pItem = (SSmaStatItem *)taosHashGet(pStat->smaStatItems, &indexUid, sizeof(indexUid));
   }
-
+#if 0
   if (pItem != NULL) {
     // TODO: reset time window for the sma data blocks
     if (taosHashRemove(pItem->expiredWindows, &skey, sizeof(TSKEY)) != 0) {
@@ -336,6 +357,7 @@ static int32_t tsdbResetExpiredWindow(SSmaStat *pStat, int64_t indexUid, TSKEY s
   } else {
     // error handling
   }
+#endif
   return TSDB_CODE_SUCCESS;
 }
 
@@ -394,10 +416,17 @@ static int32_t tsdbGetSmaStorageLevel(int64_t interval, int8_t intervalUnit) {
  * @param dataLen
  * @return int32_t
  */
-static int32_t tsdbInsertTSmaBlocks(void *bTree, const char *smaKey, const char *pData, int32_t dataLen) {
+static int32_t tsdbInsertTSmaBlocks(STSmaWriteH *pSmaH, void *smaKey, uint32_t keyLen, void *pData, uint32_t dataLen) {
+  SDBFile *pDBFile = pSmaH->pDFile;
+
   // TODO: insert sma data blocks into B+Tree
-  tsdbDebug("insert sma data blocks into B+Tree: smaKey %" PRIx64 "-%" PRIu16 "-%" PRIx64 ", dataLen %d",
-         *(uint64_t *)smaKey, *(uint16_t *)POINTER_SHIFT(smaKey, 8), *(int64_t *)POINTER_SHIFT(smaKey, 10), dataLen);
+  tsdbDebug("insert sma data blocks into %s: smaKey %" PRIx64 "-%" PRIu16 "-%" PRIx64 ", dataLen %d", pDBFile->path,
+            *(uint64_t *)smaKey, *(uint16_t *)POINTER_SHIFT(smaKey, 8), *(int64_t *)POINTER_SHIFT(smaKey, 10), dataLen);
+
+  if(tsdbSaveSmaToDB(pDBFile, smaKey, keyLen, pData, dataLen) != 0){
+    return TSDB_CODE_FAILED;
+  }
+
   return TSDB_CODE_SUCCESS;
 }
 
@@ -486,8 +515,6 @@ static int32_t tsdbInsertTSmaDataSection(STSmaWriteH *pSmaH, STSmaDataWrapper *p
 
   // TODO: check the data integrity
 
-  void *bTree = pSmaH->pDFile;
-
   int32_t len = 0;
   while (true) {
     if (len >= pData->dataLen) {
@@ -510,7 +537,7 @@ static int32_t tsdbInsertTSmaDataSection(STSmaWriteH *pSmaH, STSmaDataWrapper *p
              pData->indexUid, pData->skey, pTbData->tableUid, pColData->colId);
 #endif
       tsdbEncodeTSmaKey(pTbData->tableUid, pColData->colId, pData->skey, (void **)&pSmaKey);
-      if (tsdbInsertTSmaBlocks(bTree, smaKey, pColData->data, pColData->blockSize) < 0) {
+      if (tsdbInsertTSmaBlocks(pSmaH, smaKey, SMA_KEY_LEN, pColData->data, pColData->blockSize) < 0) {
         tsdbWarn("vgId:%d insert tSma blocks failed since %s", REPO_ID(pTsdb), tstrerror(terrno));
       }
       tbLen += (sizeof(STSmaColData) + pColData->blockSize);
@@ -524,13 +551,28 @@ static int32_t tsdbInsertTSmaDataSection(STSmaWriteH *pSmaH, STSmaDataWrapper *p
 static int32_t tsdbInitTSmaWriteH(STSmaWriteH *pSmaH, STsdb *pTsdb, STSmaDataWrapper *pData) {
   pSmaH->pTsdb = pTsdb;
   pSmaH->interval = tsdbGetIntervalByPrecision(pData->interval, pData->intervalUnit, REPO_CFG(pTsdb)->precision);
+  pSmaH->pDFile = (SDBFile *)calloc(1, sizeof(SDBFile *));
+  if (!pSmaH->pDFile) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return TSDB_CODE_FAILED;
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
+static void tsdbDestroyTSmaWriteH(STSmaWriteH *pSmaH) {
+  if (pSmaH) {
+    if (pSmaH->pDFile) {
+      tsdbCloseDBF(pSmaH->pDFile);
+    }
+  }
 }
 
 static int32_t tsdbSetTSmaDataFile(STSmaWriteH *pSmaH, STSmaDataWrapper *pData, int32_t storageLevel, int32_t fid) {
   STsdb *pTsdb = pSmaH->pTsdb;
-  
-  pSmaH->pDFile = "tSma_interval_file_name";
-
+  ASSERT(pSmaH->pDFile->path == NULL && pSmaH->pDFile->pDB == NULL);
+  char tSmaFile[TSDB_FILENAME_LEN] = {0};
+  snprintf(tSmaFile, TSDB_FILENAME_LEN, "v%df%d.tsma", REPO_ID(pTsdb), fid);
+  pSmaH->pDFile->path = strdup(tSmaFile);
   return TSDB_CODE_SUCCESS;
 }
 
@@ -559,21 +601,25 @@ static int32_t tsdbGetTSmaDays(STSmaWriteH *pSmaH, int32_t storageLevel) {
  * @return int32_t
  */
 int32_t tsdbInsertTSmaDataImpl(STsdb *pTsdb, char *msg) {
-  STsdbCfg *  pCfg = REPO_CFG(pTsdb);
+  STsdbCfg *        pCfg = REPO_CFG(pTsdb);
   STSmaDataWrapper *pData = (STSmaDataWrapper *)msg;
-  STSmaWriteH tSmaH = {0};
 
-  tsdbInitTSmaWriteH(&tSmaH, pTsdb, pData);
+  if (!pTsdb->pTSmaEnv) {
+    terrno = TSDB_CODE_INVALID_PTR;
+    tsdbWarn("vgId:%d insert tSma data failed since pTSmaEnv is NULL", REPO_ID(pTsdb));
+    return terrno;
+  }
 
   if (pData->dataLen <= 0) {
     TASSERT(0);
     terrno = TSDB_CODE_INVALID_PARA;
-    return terrno;
+    return TSDB_CODE_FAILED;
   }
 
-  if (!pTsdb->pTSmaEnv) {
-    terrno = TSDB_CODE_INVALID_PTR;
-    return terrno;
+  STSmaWriteH tSmaH = {0};
+
+  if (tsdbInitTSmaWriteH(&tSmaH, pTsdb, pData) != 0) {
+    return TSDB_CODE_FAILED;
   }
 
   // Step 1: Judge the storage level and days
@@ -585,27 +631,41 @@ int32_t tsdbInsertTSmaDataImpl(STsdb *pTsdb, char *msg) {
   //         - Set and open the DFile or the B+Tree file
   // TODO: tsdbStartTSmaCommit();
   tsdbSetTSmaDataFile(&tSmaH, pData, storageLevel, fid);
+  if (tsdbOpenDBF(pTsdb->pTSmaEnv->dbEnv, tSmaH.pDFile) != 0) {
+    tsdbWarn("vgId:%d open DB file %s failed since %s", REPO_ID(pTsdb),
+             tSmaH.pDFile->path ? tSmaH.pDFile->path : "path is NULL", tstrerror(terrno));
+    tsdbDestroyTSmaWriteH(&tSmaH);
+    return TSDB_CODE_FAILED;
+  }
 
-  tsdbInsertTSmaDataSection(&tSmaH, pData);
+  if (tsdbInsertTSmaDataSection(&tSmaH, pData) != 0) {
+    tsdbWarn("vgId:%d insert tSma data section failed since %s", REPO_ID(pTsdb), tstrerror(terrno));
+    tsdbDestroyTSmaWriteH(&tSmaH);
+    return TSDB_CODE_FAILED;
+  }
   // TODO:tsdbEndTSmaCommit();
 
-  // reset the SSmaStat
+  // Step 3: reset the SSmaStat
   tsdbResetExpiredWindow(SMA_ENV_STAT(pTsdb->pTSmaEnv), pData->indexUid, pData->skey);
 
+  tsdbDestroyTSmaWriteH(&tSmaH);
   return TSDB_CODE_SUCCESS;
 }
 
 static int32_t tsdbSetRSmaDataFile(STSmaWriteH *pSmaH, STSmaDataWrapper *pData, int32_t fid) {
-  // TODO
-  pSmaH->pDFile = "rSma_interval_file_name";
+  STsdb *pTsdb = pSmaH->pTsdb;
+
+  char tSmaFile[TSDB_FILENAME_LEN] = {0};
+  snprintf(tSmaFile, TSDB_FILENAME_LEN, "v%df%d.rsma", REPO_ID(pTsdb), fid);
+  pSmaH->pDFile->path = strdup(tSmaFile);
 
   return TSDB_CODE_SUCCESS;
 }
 
 int32_t tsdbInsertRSmaDataImpl(STsdb *pTsdb, char *msg) {
-  STsdbCfg *  pCfg = REPO_CFG(pTsdb);
+  STsdbCfg *        pCfg = REPO_CFG(pTsdb);
   STSmaDataWrapper *pData = (STSmaDataWrapper *)msg;
-  STSmaWriteH tSmaH = {0};
+  STSmaWriteH       tSmaH = {0};
 
   tsdbInitTSmaWriteH(&tSmaH, pTsdb, pData);
 
@@ -627,6 +687,7 @@ int32_t tsdbInsertRSmaDataImpl(STsdb *pTsdb, char *msg) {
   // Save all the TSma data to one file
   // TODO: tsdbStartTSmaCommit();
   tsdbSetTSmaDataFile(&tSmaH, pData, storageLevel, fid);
+
   tsdbInsertTSmaDataSection(&tSmaH, pData);
   // TODO:tsdbEndTSmaCommit();
 
diff --git a/source/dnode/vnode/src/tsdb/tsdbWrite.c b/source/dnode/vnode/src/tsdb/tsdbWrite.c
index dede1502f4..9cccea9853 100644
--- a/source/dnode/vnode/src/tsdb/tsdbWrite.c
+++ b/source/dnode/vnode/src/tsdb/tsdbWrite.c
@@ -54,7 +54,7 @@ int32_t tsdbInsertTSmaData(STsdb *pTsdb, char *msg) {
 int32_t tsdbUpdateSmaWindow(STsdb *pTsdb, int8_t smaType, char *msg) {
   int32_t code = TSDB_CODE_SUCCESS;
   if ((code = tsdbUpdateExpiredWindow(pTsdb, smaType, msg)) < 0) {
-    tsdbWarn("vgId:%d update expired window failed since %s", REPO_ID(pTsdb), tstrerror(terrno));
+    tsdbWarn("vgId:%d update expired sma window failed since %s", REPO_ID(pTsdb), tstrerror(terrno));
   }
   return code;
 }
diff --git a/source/dnode/vnode/test/tsdbSmaTest.cpp b/source/dnode/vnode/test/tsdbSmaTest.cpp
index 159ad98219..f815291c77 100644
--- a/source/dnode/vnode/test/tsdbSmaTest.cpp
+++ b/source/dnode/vnode/test/tsdbSmaTest.cpp
@@ -223,14 +223,12 @@ TEST(testCase, tSma_DB_Put_Get_Del_Test) {
 TEST(testCase, tSmaInsertTest) {
   // prepare meta
   const char *   smaIndexName1 = "sma_index_test_1";
-  const char *   smaIndexName2 = "sma_index_test_2";
   const char *   timezone = "Asia/Shanghai";
   const char *   expr = "select count(a,b, top 20), from table interval 1d, sliding 1h;";
   const char *   tagsFilter = "I'm tags filter";
   const char *   smaTestDir = "./smaTest";
   const tb_uid_t tbUid = 1234567890;
   const int64_t  indexUid1 = 2000000001;
-  const int64_t  indexUid2 = 2000000002;
   const uint32_t nCntTSma = 2;
   // encode
   STSma tSma = {0};
@@ -263,15 +261,20 @@ TEST(testCase, tSmaInsertTest) {
   // save index 1
   EXPECT_EQ(metaSaveSmaToDB(pMeta, pSmaCfg), 0);
 
-
   // insert data
-  const int64_t     indexUid = 2000000002;
   STSmaDataWrapper *pSmaData = NULL;
   STsdb             tsdb = {0};
   STsdbCfg *        pCfg = &tsdb.config;
 
-  pCfg->daysPerFile = 1;
   tsdb.pMeta = pMeta;
+  tsdb.vgId = 2;
+  tsdb.config.daysPerFile = 10;  // default days is 10
+  tsdb.config.keep1 = 30;
+  tsdb.config.keep2 = 90;
+  tsdb.config.keep = 365;
+  tsdb.config.precision = TSDB_TIME_PRECISION_MILLI;
+  tsdb.config.update = TD_ROW_OVERWRITE_UPDATE;
+  tsdb.config.compression = TWO_STAGE_COMP;
 
   char *msg = (char *)calloc(100, 1);
   EXPECT_EQ(tsdbUpdateSmaWindow(&tsdb, TSDB_SMA_TYPE_TIME_RANGE, msg), 0);
@@ -283,16 +286,16 @@ TEST(testCase, tSmaInsertTest) {
   void *  buf = NULL;
   EXPECT_EQ(tsdbMakeRoom(&buf, allocStep), 0);
   int32_t  bufSize = taosTSizeof(buf);
-  int32_t  numOfTables = 25;
-  col_id_t numOfCols = 4096;
+  int32_t  numOfTables = 5;
+  col_id_t numOfCols = 10;
   EXPECT_GT(numOfCols, 0);
 
   pSmaData = (STSmaDataWrapper *)buf;
   printf(">> allocate [%d] time to %d and addr is %p\n", ++allocCnt, bufSize, pSmaData);
-  pSmaData->skey = 1646987196;
+  pSmaData->skey = 1646987196000;
   pSmaData->interval = 10;
   pSmaData->intervalUnit = TD_TIME_UNIT_MINUTE;
-  pSmaData->indexUid = indexUid;
+  pSmaData->indexUid = indexUid1;
 
   int32_t len = sizeof(STSmaDataWrapper);
   for (int32_t t = 0; t < numOfTables; ++t) {
diff --git a/source/util/src/terror.c b/source/util/src/terror.c
index c1cb4f8a41..f97df62ccc 100644
--- a/source/util/src/terror.c
+++ b/source/util/src/terror.c
@@ -349,6 +349,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_TDB_NO_AVAIL_DISK,            "No available disk")
 TAOS_DEFINE_ERROR(TSDB_CODE_TDB_MESSED_MSG,               "TSDB messed message")
 TAOS_DEFINE_ERROR(TSDB_CODE_TDB_IVLD_TAG_VAL,             "TSDB invalid tag value")
 TAOS_DEFINE_ERROR(TSDB_CODE_TDB_NO_CACHE_LAST_ROW,        "TSDB no cache last row data")
+TAOS_DEFINE_ERROR(TSDB_CODE_TDB_NO_SMA_INDEX_IN_META,     "No sma index in meta")
 
 // query
 TAOS_DEFINE_ERROR(TSDB_CODE_QRY_INVALID_QHANDLE,          "Invalid handle")

From 8a883ea00cfa4cdcc49a47ce5768260f2b78f76f Mon Sep 17 00:00:00 2001
From: Xiaoyu Wang <xiaoyuwang@taosdata.com>
Date: Sun, 13 Mar 2022 15:28:50 -0400
Subject: [PATCH 06/16] TD-13990 interval plan implement

---
 include/libs/nodes/plannodes.h             | 17 +++++-
 source/client/src/clientImpl.c             |  6 +--
 source/libs/nodes/src/nodesCloneFuncs.c    | 21 ++++++++
 source/libs/nodes/src/nodesCodeFuncs.c     | 63 ++++++++++++++++++++++
 source/libs/nodes/src/nodesUtilFuncs.c     |  4 ++
 source/libs/parser/inc/sql.y               |  2 +-
 source/libs/parser/src/parTranslater.c     | 10 +++-
 source/libs/parser/test/parserAstTest.cpp  |  7 +++
 source/libs/planner/src/planLogicCreater.c | 56 ++++++++++++++-----
 source/libs/planner/src/planPhysiCreater.c | 51 +++++++++++++++++-
 source/libs/planner/test/plannerTest.cpp   |  7 +++
 11 files changed, 221 insertions(+), 23 deletions(-)

diff --git a/include/libs/nodes/plannodes.h b/include/libs/nodes/plannodes.h
index 2d870008df..c028c4a1b9 100644
--- a/include/libs/nodes/plannodes.h
+++ b/include/libs/nodes/plannodes.h
@@ -80,9 +80,20 @@ typedef struct SExchangeLogicNode {
   int32_t srcGroupId;
 } SExchangeLogicNode;
 
+typedef enum EWindowType {
+  WINDOW_TYPE_INTERVAL = 1,
+  WINDOW_TYPE_SESSION,
+  WINDOW_TYPE_STATE
+} EWindowType;
+
 typedef struct SWindowLogicNode {
   SLogicNode node;
-  SNode* pWindow;
+  EWindowType winType;
+  SNodeList* pFuncs;
+  int64_t interval;
+  int64_t offset;
+  int64_t sliding;
+  SFillNode* pFill;
 } SWindowLogicNode;
 
 typedef enum ESubplanType {
@@ -198,9 +209,11 @@ typedef struct SExchangePhysiNode {
 
 typedef struct SIntervalPhysiNode {
   SPhysiNode node;
+  SNodeList* pExprs;   // these are expression list of parameter expression of function
+  SNodeList* pFuncs;
   int64_t interval;
-  int64_t sliding;
   int64_t offset;
+  int64_t sliding;
   SFillNode* pFill;
 } SIntervalPhysiNode;
 
diff --git a/source/client/src/clientImpl.c b/source/client/src/clientImpl.c
index 13a4fc70f7..646b443fb7 100644
--- a/source/client/src/clientImpl.c
+++ b/source/client/src/clientImpl.c
@@ -195,11 +195,7 @@ 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, .pAstRoot = pQuery->pRoot, .acctId = pRequest->pTscObj->acctId };
-  int32_t  code = qCreateQueryPlan(&cxt, pPlan, pNodeList);
-  if (code != 0) {
-    return code;
-  }
-  return code;
+  return qCreateQueryPlan(&cxt, pPlan, pNodeList);
 }
 
 void setResSchemaInfo(SReqResultInfo* pResInfo, const SSchema* pSchema, int32_t numOfCols) {
diff --git a/source/libs/nodes/src/nodesCloneFuncs.c b/source/libs/nodes/src/nodesCloneFuncs.c
index 180853c0fb..9779082e83 100644
--- a/source/libs/nodes/src/nodesCloneFuncs.c
+++ b/source/libs/nodes/src/nodesCloneFuncs.c
@@ -184,6 +184,12 @@ static SNode* groupingSetNodeCopy(const SGroupingSetNode* pSrc, SGroupingSetNode
   return (SNode*)pDst;
 }
 
+static SNode* fillNodeCopy(const SFillNode* pSrc, SFillNode* pDst) {
+  COPY_SCALAR_FIELD(mode);
+  CLONE_NODE_FIELD(pValues);
+  return (SNode*)pDst;
+}
+
 static SNode* logicNodeCopy(const SLogicNode* pSrc, SLogicNode* pDst) {
   COPY_SCALAR_FIELD(id);
   CLONE_NODE_LIST_FIELD(pTargets);
@@ -249,6 +255,17 @@ static SNode* logicExchangeCopy(const SExchangeLogicNode* pSrc, SExchangeLogicNo
   return (SNode*)pDst;
 }
 
+static SNode* logicWindowCopy(const SWindowLogicNode* pSrc, SWindowLogicNode* pDst) {
+  COPY_BASE_OBJECT_FIELD(node, logicNodeCopy);
+  COPY_SCALAR_FIELD(winType);
+  CLONE_NODE_LIST_FIELD(pFuncs);
+  COPY_SCALAR_FIELD(interval);
+  COPY_SCALAR_FIELD(offset);
+  COPY_SCALAR_FIELD(sliding);
+  CLONE_NODE_FIELD(pFill);
+  return (SNode*)pDst;
+}
+
 static SNode* logicSubplanCopy(const SSubLogicPlan* pSrc, SSubLogicPlan* pDst) {
   CLONE_NODE_FIELD(pNode);
   COPY_SCALAR_FIELD(subplanType);
@@ -310,6 +327,8 @@ SNodeptr nodesCloneNode(const SNodeptr pNode) {
     case QUERY_NODE_ORDER_BY_EXPR:
     case QUERY_NODE_LIMIT:
       break;
+    case QUERY_NODE_FILL:
+      return fillNodeCopy((const SFillNode*)pNode, (SFillNode*)pDst);
     case QUERY_NODE_DATABLOCK_DESC:
       return dataBlockDescCopy((const SDataBlockDescNode*)pNode, (SDataBlockDescNode*)pDst);
     case QUERY_NODE_SLOT_DESC:
@@ -326,6 +345,8 @@ SNodeptr nodesCloneNode(const SNodeptr pNode) {
       return logicVnodeModifCopy((const SVnodeModifLogicNode*)pNode, (SVnodeModifLogicNode*)pDst);
     case QUERY_NODE_LOGIC_PLAN_EXCHANGE:
       return logicExchangeCopy((const SExchangeLogicNode*)pNode, (SExchangeLogicNode*)pDst);
+    case QUERY_NODE_LOGIC_PLAN_WINDOW:
+      return logicWindowCopy((const SWindowLogicNode*)pNode, (SWindowLogicNode*)pDst);
     case QUERY_NODE_LOGIC_SUBPLAN:
       return logicSubplanCopy((const SSubLogicPlan*)pNode, (SSubLogicPlan*)pDst);
     default:
diff --git a/source/libs/nodes/src/nodesCodeFuncs.c b/source/libs/nodes/src/nodesCodeFuncs.c
index 7b60218180..2826c10542 100644
--- a/source/libs/nodes/src/nodesCodeFuncs.c
+++ b/source/libs/nodes/src/nodesCodeFuncs.c
@@ -117,6 +117,8 @@ const char* nodesNodeName(ENodeType type) {
       return "PhysiExchange";
     case QUERY_NODE_PHYSICAL_PLAN_SORT:
       return "PhysiSort";
+    case QUERY_NODE_PHYSICAL_PLAN_INTERVAL:
+      return "PhysiInterval";
     case QUERY_NODE_PHYSICAL_PLAN_DISPATCH:
       return "PhysiDispatch";
     case QUERY_NODE_PHYSICAL_PLAN_INSERT:
@@ -573,6 +575,65 @@ static int32_t jsonToPhysiExchangeNode(const SJson* pJson, void* pObj) {
   return code;
 }
 
+static const char* jkIntervalPhysiPlanExprs = "Exprs";
+static const char* jkIntervalPhysiPlanFuncs = "Funcs";
+static const char* jkIntervalPhysiPlanInterval = "Interval";
+static const char* jkIntervalPhysiPlanOffset = "Offset";
+static const char* jkIntervalPhysiPlanSliding = "Sliding";
+static const char* jkIntervalPhysiPlanFill = "Fill";
+
+static int32_t physiIntervalNodeToJson(const void* pObj, SJson* pJson) {
+  const SIntervalPhysiNode* pNode = (const SIntervalPhysiNode*)pObj;
+
+  int32_t code = physicPlanNodeToJson(pObj, pJson);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = nodeListToJson(pJson, jkIntervalPhysiPlanExprs, pNode->pExprs);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = nodeListToJson(pJson, jkIntervalPhysiPlanFuncs, pNode->pFuncs);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonAddIntegerToObject(pJson, jkIntervalPhysiPlanInterval, pNode->interval);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonAddIntegerToObject(pJson, jkIntervalPhysiPlanOffset, pNode->offset);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonAddIntegerToObject(pJson, jkIntervalPhysiPlanSliding, pNode->sliding);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonAddObject(pJson, jkIntervalPhysiPlanFill, nodeToJson, pNode->pFill);
+  }
+
+  return code;
+}
+
+static int32_t jsonToPhysiIntervalNode(const SJson* pJson, void* pObj) {
+  SIntervalPhysiNode* pNode = (SIntervalPhysiNode*)pObj;
+
+  int32_t code = jsonToPhysicPlanNode(pJson, pObj);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = jsonToNodeList(pJson, jkIntervalPhysiPlanExprs, &pNode->pExprs);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = jsonToNodeList(pJson, jkIntervalPhysiPlanFuncs, &pNode->pFuncs);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonGetBigIntValue(pJson, jkIntervalPhysiPlanInterval, &pNode->interval);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonGetBigIntValue(pJson, jkIntervalPhysiPlanOffset, &pNode->offset);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonGetBigIntValue(pJson, jkIntervalPhysiPlanSliding, &pNode->sliding);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = jsonToNodeObject(pJson, jkIntervalPhysiPlanFill, (SNode**)&pNode->pFill);
+  }
+
+  return code;
+}
+
 static const char* jkDataSinkInputDataBlockDesc = "InputDataBlockDesc";
 
 static int32_t physicDataSinkNodeToJson(const void* pObj, SJson* pJson) {
@@ -1502,6 +1563,8 @@ static int32_t specificNodeToJson(const void* pObj, SJson* pJson) {
       return physiExchangeNodeToJson(pObj, pJson);
     case QUERY_NODE_PHYSICAL_PLAN_SORT:
       break;
+    case QUERY_NODE_PHYSICAL_PLAN_INTERVAL:
+      return physiIntervalNodeToJson(pObj, pJson);
     case QUERY_NODE_PHYSICAL_PLAN_DISPATCH:
       return physiDispatchNodeToJson(pObj, pJson);
     case QUERY_NODE_PHYSICAL_PLAN_INSERT:
diff --git a/source/libs/nodes/src/nodesUtilFuncs.c b/source/libs/nodes/src/nodesUtilFuncs.c
index 4055faf299..c524e62e5a 100644
--- a/source/libs/nodes/src/nodesUtilFuncs.c
+++ b/source/libs/nodes/src/nodesUtilFuncs.c
@@ -134,6 +134,8 @@ SNodeptr nodesMakeNode(ENodeType type) {
       return makeNode(type, sizeof(SVnodeModifLogicNode));
     case QUERY_NODE_LOGIC_PLAN_EXCHANGE:
       return makeNode(type, sizeof(SExchangeLogicNode));
+    case QUERY_NODE_LOGIC_PLAN_WINDOW:
+      return makeNode(type, sizeof(SWindowLogicNode));
     case QUERY_NODE_LOGIC_SUBPLAN:
       return makeNode(type, sizeof(SSubLogicPlan));
     case QUERY_NODE_LOGIC_PLAN:
@@ -156,6 +158,8 @@ SNodeptr nodesMakeNode(ENodeType type) {
       return makeNode(type, sizeof(SExchangePhysiNode));
     case QUERY_NODE_PHYSICAL_PLAN_SORT:
       return makeNode(type, sizeof(SNode));
+    case QUERY_NODE_PHYSICAL_PLAN_INTERVAL:
+      return makeNode(type, sizeof(SIntervalPhysiNode));
     case QUERY_NODE_PHYSICAL_PLAN_DISPATCH:
       return makeNode(type, sizeof(SDataDispatcherNode));
     case QUERY_NODE_PHYSICAL_PLAN_INSERT:
diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y
index 310da2e966..f4ed3d8597 100644
--- a/source/libs/parser/inc/sql.y
+++ b/source/libs/parser/inc/sql.y
@@ -198,7 +198,7 @@ col_name(A) ::= column_name(B).
 cmd ::= SHOW VGROUPS.                                                             { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_VGROUPS_STMT, NULL); }
 cmd ::= SHOW db_name(B) NK_DOT VGROUPS.                                           { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_VGROUPS_STMT, &B); }
 
-/************************************************ show vgroups ********************************************************/
+/************************************************ show mnodes *********************************************************/
 cmd ::= SHOW MNODES.                                                             { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_MNODES_STMT, NULL); }
 
 /************************************************ select **************************************************************/
diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c
index 4be4e25eb8..f6b8853017 100644
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@@ -708,9 +708,17 @@ static int32_t translateGroupBy(STranslateContext* pCxt, SNodeList* pGroupByList
   return translateExprList(pCxt, pGroupByList);
 }
 
+static int32_t doTranslateWindow(STranslateContext* pCxt, SNode* pWindow) {
+  return TSDB_CODE_SUCCESS;
+}
+
 static int32_t translateWindow(STranslateContext* pCxt, SNode* pWindow) {
   pCxt->currClause = SQL_CLAUSE_WINDOW;
-  return translateExpr(pCxt, pWindow);
+  int32_t code = translateExpr(pCxt, pWindow);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = doTranslateWindow(pCxt, pWindow);
+  }
+  return code;
 }
 
 static int32_t translatePartitionBy(STranslateContext* pCxt, SNodeList* pPartitionByList) {
diff --git a/source/libs/parser/test/parserAstTest.cpp b/source/libs/parser/test/parserAstTest.cpp
index f9a2bafe10..d30c21cc21 100644
--- a/source/libs/parser/test/parserAstTest.cpp
+++ b/source/libs/parser/test/parserAstTest.cpp
@@ -183,6 +183,13 @@ TEST_F(ParserTest, selectClause) {
   ASSERT_TRUE(run());
 }
 
+TEST_F(ParserTest, selectWindow) {
+  setDatabase("root", "test");
+
+  bind("SELECT count(*) FROM t1 interval(10s)");
+  ASSERT_TRUE(run());
+}
+
 TEST_F(ParserTest, selectSyntaxError) {
   setDatabase("root", "test");
 
diff --git a/source/libs/planner/src/planLogicCreater.c b/source/libs/planner/src/planLogicCreater.c
index 543bc05554..7520ea3c9e 100644
--- a/source/libs/planner/src/planLogicCreater.c
+++ b/source/libs/planner/src/planLogicCreater.c
@@ -257,18 +257,6 @@ static SNodeList* createColumnByRewriteExps(SLogicPlanContext* pCxt, SNodeList*
   return cxt.pList;
 }
 
-static SLogicNode* createWindowLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect) {
-  if (NULL == pSelect->pWindow) {
-    return NULL;
-  }
-
-  SWindowLogicNode* pAgg = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW);
-  CHECK_ALLOC(pAgg, NULL);
-  pAgg->node.id = pCxt->planNodeId++;
-
-
-}
-
 static SLogicNode* createAggLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect) {
   SNodeList* pAggFuncs = NULL;
   CHECK_CODE(nodesCollectFuncs(pSelect, fmIsAggFunc, &pAggFuncs), NULL);
@@ -316,6 +304,50 @@ static SLogicNode* createAggLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSel
   return (SLogicNode*)pAgg;
 }
 
+static SLogicNode* createWindowLogicNodeByInterval(SLogicPlanContext* pCxt, SIntervalWindowNode* pInterval, SSelectStmt* pSelect) {
+  SWindowLogicNode* pWindow = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW);
+  CHECK_ALLOC(pWindow, NULL);
+  pWindow->node.id = pCxt->planNodeId++;
+
+  pWindow->winType = WINDOW_TYPE_INTERVAL;
+  pWindow->interval = ((SValueNode*)pInterval->pInterval)->datum.i;
+  pWindow->offset = (NULL != pInterval->pOffset ? ((SValueNode*)pInterval->pOffset)->datum.i : 0);
+  pWindow->sliding = (NULL != pInterval->pSliding ? ((SValueNode*)pInterval->pSliding)->datum.i : 0);
+  if (NULL != pInterval->pFill) {
+    pWindow->pFill = nodesCloneNode(pInterval->pFill);
+    CHECK_ALLOC(pWindow->pFill, (SLogicNode*)pWindow);
+  }
+
+  SNodeList* pFuncs = NULL;
+  CHECK_CODE(nodesCollectFuncs(pSelect, fmIsAggFunc, &pFuncs), NULL);
+  if (NULL != pFuncs) {
+    pWindow->pFuncs = nodesCloneList(pFuncs);
+    CHECK_ALLOC(pWindow->pFuncs, (SLogicNode*)pWindow);
+  }
+
+  CHECK_CODE(rewriteExpr(pWindow->node.id, 1, pWindow->pFuncs, pSelect, SQL_CLAUSE_WINDOW), (SLogicNode*)pWindow);
+
+  pWindow->node.pTargets = createColumnByRewriteExps(pCxt, pWindow->pFuncs);
+  CHECK_ALLOC(pWindow->node.pTargets, (SLogicNode*)pWindow);
+
+  return (SLogicNode*)pWindow;
+}
+
+static SLogicNode* createWindowLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect) {
+  if (NULL == pSelect->pWindow) {
+    return NULL;
+  }
+
+  switch (nodeType(pSelect->pWindow)) {
+    case QUERY_NODE_INTERVAL_WINDOW:
+      return createWindowLogicNodeByInterval(pCxt, (SIntervalWindowNode*)pSelect->pWindow, pSelect);    
+    default:
+      break;
+  }
+
+  return NULL;
+}
+
 static SNodeList* createColumnByProjections(SLogicPlanContext* pCxt, SNodeList* pExprs) {
   SNodeList* pList = nodesMakeList();
   CHECK_ALLOC(pList, NULL);
diff --git a/source/libs/planner/src/planPhysiCreater.c b/source/libs/planner/src/planPhysiCreater.c
index 5af26b3e32..7b7dd26df1 100644
--- a/source/libs/planner/src/planPhysiCreater.c
+++ b/source/libs/planner/src/planPhysiCreater.c
@@ -473,14 +473,58 @@ static SPhysiNode* createExchangePhysiNode(SPhysiPlanContext* pCxt, SExchangeLog
   return (SPhysiNode*)pExchange;
 }
 
+static SPhysiNode* createIntervalPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChildren, SWindowLogicNode* pWindowLogicNode) {
+  SIntervalPhysiNode* pInterval = (SIntervalPhysiNode*)makePhysiNode(pCxt, QUERY_NODE_PHYSICAL_PLAN_INTERVAL);
+  CHECK_ALLOC(pInterval, NULL);
+
+  pInterval->interval = pWindowLogicNode->interval;
+  pInterval->offset = pWindowLogicNode->offset;
+  pInterval->sliding = pWindowLogicNode->sliding;
+  pInterval->pFill = nodesCloneNode(pWindowLogicNode->pFill);
+
+  SNodeList* pPrecalcExprs = NULL;
+  SNodeList* pFuncs = NULL;
+  CHECK_CODE(rewritePrecalcExprs(pCxt, pWindowLogicNode->pFuncs, &pPrecalcExprs, &pFuncs), (SPhysiNode*)pInterval);
+
+  SDataBlockDescNode* pChildTupe = (((SPhysiNode*)nodesListGetNode(pChildren, 0))->pOutputDataBlockDesc);
+  // push down expression to pOutputDataBlockDesc of child node
+  if (NULL != pPrecalcExprs) {
+    pInterval->pExprs = setListSlotId(pCxt, pChildTupe->dataBlockId, -1, pPrecalcExprs);
+    CHECK_ALLOC(pInterval->pExprs, (SPhysiNode*)pInterval);
+    CHECK_CODE(addDataBlockDesc(pCxt, pInterval->pExprs, pChildTupe), (SPhysiNode*)pInterval);
+  }
+
+  if (NULL != pFuncs) {
+    pInterval->pFuncs = setListSlotId(pCxt, pChildTupe->dataBlockId, -1, pFuncs);
+    CHECK_ALLOC(pInterval->pFuncs, (SPhysiNode*)pInterval);
+    CHECK_CODE(addDataBlockDesc(pCxt, pInterval->pFuncs, pInterval->node.pOutputDataBlockDesc), (SPhysiNode*)pInterval);
+  }
+
+  CHECK_CODE(setSlotOutput(pCxt, pWindowLogicNode->node.pTargets, pInterval->node.pOutputDataBlockDesc), (SPhysiNode*)pInterval);
+
+  return (SPhysiNode*)pInterval;
+}
+
+static SPhysiNode* createWindowPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChildren, SWindowLogicNode* pWindowLogicNode) {
+  switch (pWindowLogicNode->winType) {
+    case WINDOW_TYPE_INTERVAL:
+      return createIntervalPhysiNode(pCxt, pChildren, pWindowLogicNode);
+    case WINDOW_TYPE_SESSION:
+    case WINDOW_TYPE_STATE:
+      break;
+    default:
+      break;
+  }
+  return NULL;
+}
+
 static SPhysiNode* createPhysiNode(SPhysiPlanContext* pCxt, SSubplan* pSubplan, SLogicNode* pLogicPlan) {
   SNodeList* pChildren = nodesMakeList();
   CHECK_ALLOC(pChildren, NULL);
 
   SNode* pLogicChild;
   FOREACH(pLogicChild, pLogicPlan->pChildren) {
-    SNode* pChildPhyNode = (SNode*)createPhysiNode(pCxt, pSubplan, (SLogicNode*)pLogicChild);
-    if (TSDB_CODE_SUCCESS != nodesListAppend(pChildren, pChildPhyNode)) {
+    if (TSDB_CODE_SUCCESS != nodesListStrictAppend(pChildren, createPhysiNode(pCxt, pSubplan, (SLogicNode*)pLogicChild))) {
       pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY;
       nodesDestroyList(pChildren);
       return NULL;
@@ -504,6 +548,9 @@ static SPhysiNode* createPhysiNode(SPhysiPlanContext* pCxt, SSubplan* pSubplan,
     case QUERY_NODE_LOGIC_PLAN_EXCHANGE:
       pPhyNode = createExchangePhysiNode(pCxt, (SExchangeLogicNode*)pLogicPlan);
       break;
+    case QUERY_NODE_LOGIC_PLAN_WINDOW:
+      pPhyNode = createWindowPhysiNode(pCxt, pChildren, (SWindowLogicNode*)pLogicPlan);
+      break;
     default:
       break;
   }
diff --git a/source/libs/planner/test/plannerTest.cpp b/source/libs/planner/test/plannerTest.cpp
index 3748d37d74..b2760c2c4d 100644
--- a/source/libs/planner/test/plannerTest.cpp
+++ b/source/libs/planner/test/plannerTest.cpp
@@ -166,3 +166,10 @@ TEST_F(PlannerTest, subquery) {
   bind("SELECT count(*) FROM (SELECT c1 + c3 a, c1 + count(*) b FROM t1 where c2 = 'abc' GROUP BY c1, c3) where a > 100 group by b");
   ASSERT_TRUE(run());
 }
+
+TEST_F(PlannerTest, interval) {
+  setDatabase("root", "test");
+
+  bind("SELECT count(*) FROM t1 interval(10s)");
+  ASSERT_TRUE(run());
+}

From 40962d26f6754ad7fded49d02803a5cced21284a Mon Sep 17 00:00:00 2001
From: Xiaoyu Wang <xiaoyuwang@taosdata.com>
Date: Sun, 13 Mar 2022 17:16:14 -0400
Subject: [PATCH 07/16] TD-13990 interval plan implement

---
 tests/script/tsim/db/basic1.sim | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/script/tsim/db/basic1.sim b/tests/script/tsim/db/basic1.sim
index 21e26784bf..b203022e1d 100644
--- a/tests/script/tsim/db/basic1.sim
+++ b/tests/script/tsim/db/basic1.sim
@@ -3,6 +3,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/exec.sh -n dnode1 -s start
 sql connect
 
+sleep 1000
 print =============== create database
 sql create database d1 vgroups 2
 sql show databases

From 50512c353183b730e9560133f6a6b1265dfa529c Mon Sep 17 00:00:00 2001
From: Xiaoyu Wang <xiaoyuwang@taosdata.com>
Date: Sun, 13 Mar 2022 17:23:02 -0400
Subject: [PATCH 08/16] TD-13990 interval plan implement

---
 tests/script/tsim/db/basic1.sim | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/script/tsim/db/basic1.sim b/tests/script/tsim/db/basic1.sim
index b203022e1d..0753b1af9e 100644
--- a/tests/script/tsim/db/basic1.sim
+++ b/tests/script/tsim/db/basic1.sim
@@ -3,7 +3,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/exec.sh -n dnode1 -s start
 sql connect
 
-sleep 1000
+sleep 3000
 print =============== create database
 sql create database d1 vgroups 2
 sql show databases

From 3f360a2b0130fc29ad36362696abb48d1a841b55 Mon Sep 17 00:00:00 2001
From: Xiaoyu Wang <xiaoyuwang@taosdata.com>
Date: Sun, 13 Mar 2022 17:39:42 -0400
Subject: [PATCH 09/16] TD-13990 merge 3.0

---
 tests/script/tsim/db/basic1.sim | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/script/tsim/db/basic1.sim b/tests/script/tsim/db/basic1.sim
index 0753b1af9e..21e26784bf 100644
--- a/tests/script/tsim/db/basic1.sim
+++ b/tests/script/tsim/db/basic1.sim
@@ -3,7 +3,6 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/exec.sh -n dnode1 -s start
 sql connect
 
-sleep 3000
 print =============== create database
 sql create database d1 vgroups 2
 sql show databases

From bc37d5828e2fe3cab39bd1c47799b2c0dd2c5aa8 Mon Sep 17 00:00:00 2001
From: plum-lihui <huili@taosdata.com>
Date: Mon, 14 Mar 2022 13:38:22 +0800
Subject: [PATCH 10/16] [modify for tests]

---
 tests/script/sh/massiveTable/compileVersion.sh | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/tests/script/sh/massiveTable/compileVersion.sh b/tests/script/sh/massiveTable/compileVersion.sh
index 787da09b85..c6c92bf724 100755
--- a/tests/script/sh/massiveTable/compileVersion.sh
+++ b/tests/script/sh/massiveTable/compileVersion.sh
@@ -45,10 +45,6 @@ function gitPullBranchInfo () {
   git pull origin $branch_name ||:
   echo "==== git pull $branch_name end ===="
   git pull --recurse-submodules
-  cd tests
-  git checkout $branch_name
-  git pull
-  cd ..
 }
 
 function compileTDengineVersion() {

From 0deef5aa1ea0a9732059f2576a42c4d1cc7441d4 Mon Sep 17 00:00:00 2001
From: ubuntu <ubuntu@ubuntu-OptiPlex-7060>
Date: Mon, 14 Mar 2022 16:03:01 +0800
Subject: [PATCH 11/16] update trans

---
 source/libs/transport/inc/transComm.h |  21 +++++-
 source/libs/transport/src/trans.c     |  27 ++++++-
 source/libs/transport/src/transCli.c  | 104 ++++++++++++--------------
 source/libs/transport/src/transSrv.c  |  29 ++++---
 4 files changed, 106 insertions(+), 75 deletions(-)

diff --git a/source/libs/transport/inc/transComm.h b/source/libs/transport/inc/transComm.h
index f2ac77fe61..06d5a7da91 100644
--- a/source/libs/transport/inc/transComm.h
+++ b/source/libs/transport/inc/transComm.h
@@ -120,6 +120,10 @@ typedef struct {
   // SEpSet*          pSet;      // for synchronous API
 } SRpcReqContext;
 
+typedef SRpcMsg  STransMsg;
+typedef SRpcInfo STrans;  
+typedef SRpcConnInfo STransHandleInfo;
+
 typedef struct {
   SEpSet epSet;    // ip list provided by app
   void*  ahandle;  // handle provided by app
@@ -134,7 +138,7 @@ typedef struct {
   int8_t  connType;  // connection type
   int64_t rid;       // refId returned by taosAddRef
 
-  SRpcMsg* pRsp;  // for synchronous API
+  STransMsg* pRsp;  // for synchronous API
   tsem_t*  pSem;  // for synchronous API
 
   int      hThrdIdx;
@@ -143,6 +147,7 @@ typedef struct {
   // SEpSet*          pSet;      // for synchronous API
 } STransConnCtx;
 
+
 #pragma pack(push, 1)
 
 typedef struct {
@@ -243,10 +248,24 @@ bool transReadComplete(SConnBuffer* connBuf);
 
 int transSetConnOption(uv_tcp_t* stream);
 
+
 void transRefSrvHandle(void* handle);
 void transUnrefSrvHandle(void* handle);
 
 void transRefCliHandle(void* handle);
 void transUnrefCliHandle(void* handle);
 
+
+void transSendRequest(void *shandle, const char *ip, uint32_t port, STransMsg *pMsg);
+void transSendRecv(void* shandle, const char *ip, uint32_t port, STransMsg *pMsg, STransMsg *pRsp);
+void transSendResponse(const STransMsg* pMsg);
+int transGetConnInfo(void *thandle, STransHandleInfo *pInfo);
+
+
+void* transInitServer(uint32_t ip, uint32_t port, char* label, int numOfThreads, void* fp, void* shandle);
+void* transInitClient(uint32_t ip, uint32_t port, char* label, int numOfThreads, void* fp, void* shandle);
+
+void transCloseClient(void *arg);
+void transCloseServer(void *arg);
+
 #endif
diff --git a/source/libs/transport/src/trans.c b/source/libs/transport/src/trans.c
index 4d244665c7..015018f73f 100644
--- a/source/libs/transport/src/trans.c
+++ b/source/libs/transport/src/trans.c
@@ -18,8 +18,9 @@
 #include "transComm.h"
 
 void* (*taosInitHandle[])(uint32_t ip, uint32_t port, char* label, int numOfThreads, void* fp, void* shandle) = {
-    taosInitServer, taosInitClient};
-void (*taosCloseHandle[])(void* arg) = {taosCloseServer, taosCloseClient};
+    transInitServer, transInitClient};
+
+void (*taosCloseHandle[])(void* arg) = {transCloseServer, transCloseClient};
 
 void* rpcOpen(const SRpcInit* pInit) {
   SRpcInfo* pRpc = calloc(1, sizeof(SRpcInfo));
@@ -34,11 +35,12 @@ void* rpcOpen(const SRpcInit* pInit) {
   pRpc->cfp = pInit->cfp;
   pRpc->afp = pInit->afp;
   pRpc->pfp = pInit->pfp;
+  pRpc->mfp = pInit->mfp;
 
   if (pInit->connType == TAOS_CONN_SERVER) {
     pRpc->numOfThreads = pInit->numOfThreads > TSDB_MAX_RPC_THREADS ? TSDB_MAX_RPC_THREADS : pInit->numOfThreads;
   } else {
-    pRpc->numOfThreads = pInit->numOfThreads;
+    pRpc->numOfThreads = pInit->numOfThreads > TSDB_MAX_RPC_THREADS ? TSDB_MAX_RPC_THREADS : pInit->numOfThreads;
   }
 
   pRpc->connType = pInit->connType;
@@ -116,6 +118,24 @@ int32_t rpcInit() {
   return 0;
 }
 
+void rpcSendRequest(void *shandle, const SEpSet *pEpSet, SRpcMsg* pMsg, int64_t *pRid) {
+  char*    ip = (char*)(pEpSet->eps[pEpSet->inUse].fqdn);
+  uint32_t port = pEpSet->eps[pEpSet->inUse].port;
+  transSendRequest(shandle, ip, port, pMsg);   
+}
+void rpcSendRecv(void* shandle, SEpSet *pEpSet, SRpcMsg *pMsg, SRpcMsg *pRsp) {
+  char*    ip = (char*)(pEpSet->eps[pEpSet->inUse].fqdn);
+  uint32_t port = pEpSet->eps[pEpSet->inUse].port;
+  transSendRecv(shandle, ip, port, pMsg, pRsp);
+}
+
+void rpcSendResponse(const SRpcMsg *pMsg) {
+  transSendResponse(pMsg);  
+}
+int rpcGetConnInfo(void *thandle, SRpcConnInfo *pInfo) {
+  return transGetConnInfo((void *)thandle, pInfo);
+}
+
 void rpcCleanup(void) {
   // impl later
   //
@@ -129,6 +149,7 @@ void rpcRefHandle(void* handle, int8_t type) {
   assert(type == TAOS_CONN_SERVER || type == TAOS_CONN_CLIENT);
   (*taosRefHandle[type])(handle);
 }
+
 void rpcUnrefHandle(void* handle, int8_t type) {
   assert(type == TAOS_CONN_SERVER || type == TAOS_CONN_CLIENT);
   (*taosUnRefHandle[type])(handle);
diff --git a/source/libs/transport/src/transCli.c b/source/libs/transport/src/transCli.c
index ce3c1c2dc8..c55d699e4f 100644
--- a/source/libs/transport/src/transCli.c
+++ b/source/libs/transport/src/transCli.c
@@ -42,7 +42,7 @@ typedef struct SCliConn {
 
 typedef struct SCliMsg {
   STransConnCtx* ctx;
-  SRpcMsg        msg;
+  STransMsg        msg;
   queue          q;
   uint64_t       st;
 } SCliMsg;
@@ -105,9 +105,9 @@ static void cliHandleExcept(SCliConn* conn);
 static void cliHandleReq(SCliMsg* pMsg, SCliThrdObj* pThrd);
 static void cliHandleQuit(SCliMsg* pMsg, SCliThrdObj* pThrd);
 static void cliSendQuit(SCliThrdObj* thrd);
-static void destroyUserdata(SRpcMsg* userdata);
+static void destroyUserdata(STransMsg* userdata);
 
-static int cliRBChoseIdx(SRpcInfo* pTransInst);
+static int cliRBChoseIdx(STrans* pTransInst);
 
 static void destroyCmsg(SCliMsg* cmsg);
 static void transDestroyConnCtx(STransConnCtx* ctx);
@@ -118,7 +118,7 @@ static void         destroyThrdObj(SCliThrdObj* pThrd);
 #define CONN_HOST_THREAD_INDEX(conn) (conn ? ((SCliConn*)conn)->hThrdIdx : -1)
 #define CONN_PERSIST_TIME(para) (para * 1000 * 10)
 
-#define CONN_GET_INST_LABEL(conn) (((SRpcInfo*)(((SCliThrdObj*)conn->hostThrd)->pTransInst))->label)
+#define CONN_GET_INST_LABEL(conn) (((STrans*)(((SCliThrdObj*)conn->hostThrd)->pTransInst))->label)
 #define CONN_HANDLE_THREAD_QUIT(conn, thrd) \
   do {                                      \
     if (thrd->quit) {                       \
@@ -135,14 +135,14 @@ static void         destroyThrdObj(SCliThrdObj* pThrd);
     }                            \
   } while (0);
 
-#define CONN_PERSIST_BY_APP(conn) do { if (conn->persist == false) { conn->persist = true; transRefCliHandle(conn);}} while(0)
+#define CONN_SET_PERSIST_BY_APP(conn) do { if (conn->persist == false) { conn->persist = true; transRefCliHandle(conn);}} while(0)
 #define CONN_NO_PERSIST_BY_APP(conn) ((conn)->persist == false)
 
 static void* cliWorkThread(void* arg);
 
-static void  cliHandleResp(SCliConn* conn) {
+void  cliHandleResp(SCliConn* conn) {
   SCliThrdObj* pThrd = conn->hostThrd;
-  SRpcInfo*    pTransInst = pThrd->pTransInst;
+  STrans*    pTransInst = pThrd->pTransInst;
 
   STransMsgHead* pHead = (STransMsgHead*)(conn->readBuf.buf);
   pHead->code = htonl(pHead->code);
@@ -151,7 +151,7 @@ static void  cliHandleResp(SCliConn* conn) {
   // buf's mem alread translated to rpcMsg.pCont
   transClearBuffer(&conn->readBuf);
 
-  SRpcMsg rpcMsg = {0};
+  STransMsg rpcMsg = {0};
   rpcMsg.contLen = transContLenFromMsg(pHead->msgLen);
   rpcMsg.pCont = transContFromHead((char*)pHead);
   rpcMsg.code = pHead->code;
@@ -172,7 +172,7 @@ static void  cliHandleResp(SCliConn* conn) {
 
   if (pTransInst->pfp != NULL && (*pTransInst->pfp)(pTransInst->parent, rpcMsg.msgType)) {
     rpcMsg.handle = conn;
-    CONN_PERSIST_BY_APP(conn);
+    CONN_SET_PERSIST_BY_APP(conn);
     tDebug("%s cli conn %p ref by app", CONN_GET_INST_LABEL(conn), conn);
   }
 
@@ -204,7 +204,8 @@ static void  cliHandleResp(SCliConn* conn) {
     // uv_timer_start((uv_timer_t*)&pThrd->timer, cliTimeoutCb, CONN_PERSIST_TIME(pRpc->idleTime) / 2, 0);
   }
 }
-static void cliHandleExcept(SCliConn* pConn) {
+
+void cliHandleExcept(SCliConn* pConn) {
   if (pConn->data == NULL) {
      if (pConn->broken == true || CONN_NO_PERSIST_BY_APP(pConn)) {
         transUnrefCliHandle(pConn);
@@ -212,12 +213,12 @@ static void cliHandleExcept(SCliConn* pConn) {
      }
   }
   SCliThrdObj* pThrd = pConn->hostThrd;
-  SRpcInfo*    pTransInst = pThrd->pTransInst;
+  STrans*    pTransInst = pThrd->pTransInst;
 
   SCliMsg*       pMsg = pConn->data;
   STransConnCtx *pCtx = pMsg ? pMsg->ctx : NULL;
 
-  SRpcMsg rpcMsg = {0};
+  STransMsg rpcMsg = {0};
   rpcMsg.code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
   rpcMsg.msgType = pMsg ? pMsg->msg.msgType + 1 : 0;
   rpcMsg.ahandle = NULL; 
@@ -243,9 +244,9 @@ static void cliHandleExcept(SCliConn* pConn) {
   transUnrefCliHandle(pConn);
 }
 
-static void cliTimeoutCb(uv_timer_t* handle) {
+void cliTimeoutCb(uv_timer_t* handle) {
   SCliThrdObj* pThrd = handle->data;
-  SRpcInfo*    pRpc = pThrd->pTransInst;
+  STrans*    pRpc = pThrd->pTransInst;
   int64_t      currentTime = pThrd->nextTimeout;
   tTrace("%s, cli conn timeout, try to remove expire conn from conn pool", pRpc->label);
 
@@ -267,11 +268,12 @@ static void cliTimeoutCb(uv_timer_t* handle) {
   pThrd->nextTimeout = taosGetTimestampMs() + CONN_PERSIST_TIME(pRpc->idleTime);
   uv_timer_start(handle, cliTimeoutCb, CONN_PERSIST_TIME(pRpc->idleTime) / 2, 0);
 }
-static void* createConnPool(int size) {
+
+void* createConnPool(int size) {
   // thread local, no lock
   return taosHashInit(size, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
 }
-static void* destroyConnPool(void* pool) {
+void* destroyConnPool(void* pool) {
   SConnList* connList = taosHashIterate((SHashObj*)pool, NULL);
   while (connList != NULL) {
     while (!QUEUE_IS_EMPTY(&connList->conn)) {
@@ -316,7 +318,7 @@ static void addConnToPool(void* pool, char* ip, uint32_t port, SCliConn* conn) {
   tstrncpy(key + strlen(key), (char*)(&port), sizeof(port));
   tTrace("cli conn %p added to conn pool, read buf cap: %d", conn, conn->readBuf.cap);
 
-  SRpcInfo* pRpc = ((SCliThrdObj*)conn->hostThrd)->pTransInst;
+  STrans* pRpc = ((SCliThrdObj*)conn->hostThrd)->pTransInst;
 
   conn->expireTime = taosGetTimestampMs() + CONN_PERSIST_TIME(pRpc->idleTime);
   SConnList* plist = taosHashGet((SHashObj*)pool, key, strlen(key));
@@ -411,16 +413,16 @@ static void cliSendCb(uv_write_t* req, int status) {
   uv_read_start((uv_stream_t*)pConn->stream, cliAllocBufferCb, cliRecvCb);
 }
 
-static void cliSend(SCliConn* pConn) {
+void cliSend(SCliConn* pConn) {
   CONN_HANDLE_BROKEN(pConn);
 
   SCliMsg*       pCliMsg = pConn->data;
   STransConnCtx* pCtx = pCliMsg->ctx;
 
   SCliThrdObj* pThrd = pConn->hostThrd;
-  SRpcInfo*    pTransInst = pThrd->pTransInst;
+  STrans*    pTransInst = pThrd->pTransInst;
 
-  SRpcMsg* pMsg = (SRpcMsg*)(&pCliMsg->msg);
+  STransMsg* pMsg = (STransMsg*)(&pCliMsg->msg);
 
   STransMsgHead* pHead = transHeadFromCont(pMsg->pCont);
   int            msgLen = transMsgLenFromCont(pMsg->contLen);
@@ -458,7 +460,8 @@ static void cliSend(SCliConn* pConn) {
 _RETURE:
   return;
 }
-static void cliConnCb(uv_connect_t* req, int status) {
+
+void cliConnCb(uv_connect_t* req, int status) {
   // impl later
   SCliConn* pConn = req->data;
   if (status != 0) {
@@ -488,7 +491,8 @@ static void cliHandleQuit(SCliMsg* pMsg, SCliThrdObj* pThrd) {
   pThrd->quit = true;
   uv_stop(pThrd->loop);
 }
-static SCliConn* cliGetConn(SCliMsg* pMsg, SCliThrdObj* pThrd) {
+
+SCliConn* cliGetConn(SCliMsg* pMsg, SCliThrdObj* pThrd) {
   SCliConn* conn = NULL;
   if (pMsg->msg.handle != NULL) {
     conn = (SCliConn*)(pMsg->msg.handle);
@@ -502,13 +506,14 @@ static SCliConn* cliGetConn(SCliMsg* pMsg, SCliThrdObj* pThrd) {
   }
   return conn;
 }
-static void cliHandleReq(SCliMsg* pMsg, SCliThrdObj* pThrd) {
+
+void cliHandleReq(SCliMsg* pMsg, SCliThrdObj* pThrd) {
   uint64_t et = taosGetTimestampUs();
   uint64_t el = et - pMsg->st;
-  tTrace("%s cli msg tran time cost: %" PRIu64 "us", ((SRpcInfo*)pThrd->pTransInst)->label, el);
+  tTrace("%s cli msg tran time cost: %" PRIu64 "us", ((STrans*)pThrd->pTransInst)->label, el);
 
   STransConnCtx* pCtx = pMsg->ctx;
-  SRpcInfo*      pTransInst = pThrd->pTransInst;
+  STrans*      pTransInst = pThrd->pTransInst;
 
   SCliConn* conn = cliGetConn(pMsg, pThrd);
   if (conn != NULL) {
@@ -567,10 +572,10 @@ static void* cliWorkThread(void* arg) {
   uv_run(pThrd->loop, UV_RUN_DEFAULT);
 }
 
-void* taosInitClient(uint32_t ip, uint32_t port, char* label, int numOfThreads, void* fp, void* shandle) {
+void* transInitClient(uint32_t ip, uint32_t port, char* label, int numOfThreads, void* fp, void* shandle) {
   SCliObj* cli = calloc(1, sizeof(SCliObj));
 
-  SRpcInfo* pRpc = shandle;
+  STrans* pRpc = shandle;
   memcpy(cli->label, label, strlen(label));
   cli->numOfThreads = numOfThreads;
   cli->pThreadObj = (SCliThrdObj**)calloc(cli->numOfThreads, sizeof(SCliThrdObj*));
@@ -589,7 +594,7 @@ void* taosInitClient(uint32_t ip, uint32_t port, char* label, int numOfThreads,
   return cli;
 }
 
-static void destroyUserdata(SRpcMsg* userdata) {
+static void destroyUserdata(STransMsg* userdata) {
   if (userdata->pCont == NULL) {
     return;
   }
@@ -645,12 +650,20 @@ static void transDestroyConnCtx(STransConnCtx* ctx) {
   free(ctx);
 }
 //
-static void cliSendQuit(SCliThrdObj* thrd) {
+void cliSendQuit(SCliThrdObj* thrd) {
   // cli can stop gracefully
   SCliMsg* msg = calloc(1, sizeof(SCliMsg));
   transSendAsync(thrd->asyncPool, &msg->q);
 }
-void taosCloseClient(void* arg) {
+int cliRBChoseIdx(STrans* pTransInst) {
+  int64_t index = pTransInst->index;
+  if (pTransInst->index++ >= pTransInst->numOfThreads) {
+    pTransInst->index = 0;
+  }
+  return index % pTransInst->numOfThreads;
+}
+
+void transCloseClient(void* arg) {
   SCliObj* cli = arg;
   for (int i = 0; i < cli->numOfThreads; i++) {
     cliSendQuit(cli->pThreadObj[i]);
@@ -659,13 +672,6 @@ void taosCloseClient(void* arg) {
   free(cli->pThreadObj);
   free(cli);
 }
-static int cliRBChoseIdx(SRpcInfo* pTransInst) {
-  int64_t index = pTransInst->index;
-  if (pTransInst->index++ >= pTransInst->numOfThreads) {
-    pTransInst->index = 0;
-  }
-  return index % pTransInst->numOfThreads;
-}
 void transRefCliHandle(void* handle) {
   if (handle == NULL) {
     return;
@@ -681,17 +687,11 @@ void transUnrefCliHandle(void* handle) {
   if (ref == 0) {
     cliDestroyConn((SCliConn*)handle, true);
   }
-
-  // unref cli handle
 }
-void rpcSendRequest(void* shandle, const SEpSet* pEpSet, SRpcMsg* pMsg, int64_t* pRid) {
-  // impl later
-  char*    ip = (char*)(pEpSet->eps[pEpSet->inUse].fqdn);
-  uint32_t port = pEpSet->eps[pEpSet->inUse].port;
 
-  SRpcInfo* pTransInst = (SRpcInfo*)shandle;
-
-  int index = CONN_HOST_THREAD_INDEX(pMsg->handle);
+void transSendRequest(void *shandle, const char *ip, uint32_t port, STransMsg *pMsg) {
+  STrans* pTransInst = (STrans*)shandle;
+  int index = CONN_HOST_THREAD_INDEX((SCliConn *)pMsg->handle);
   if (index == -1) {
     index = cliRBChoseIdx(pTransInst);
   }
@@ -718,13 +718,8 @@ void rpcSendRequest(void* shandle, const SEpSet* pEpSet, SRpcMsg* pMsg, int64_t*
   SCliThrdObj* thrd = ((SCliObj*)pTransInst->tcphandle)->pThreadObj[index];
   transSendAsync(thrd->asyncPool, &(cliMsg->q));
 }
-
-void rpcSendRecv(void* shandle, SEpSet* pEpSet, SRpcMsg* pReq, SRpcMsg* pRsp) {
-  char*    ip = (char*)(pEpSet->eps[pEpSet->inUse].fqdn);
-  uint32_t port = pEpSet->eps[pEpSet->inUse].port;
-
-  SRpcInfo* pTransInst = (SRpcInfo*)shandle;
-
+void transSendRecv(void* shandle, const char *ip, uint32_t port, STransMsg *pReq, STransMsg *pRsp) {
+  STrans* pTransInst = (STrans*)shandle;
   int index = CONN_HOST_THREAD_INDEX(pReq->handle);
   if (index == -1) {
     index = cliRBChoseIdx(pTransInst);
@@ -751,7 +746,6 @@ void rpcSendRecv(void* shandle, SEpSet* pEpSet, SRpcMsg* pReq, SRpcMsg* pRsp) {
   tsem_wait(pSem);
   tsem_destroy(pSem);
   free(pSem);
-
-  return;
 }
+
 #endif
diff --git a/source/libs/transport/src/transSrv.c b/source/libs/transport/src/transSrv.c
index c4c3d9ed0a..f9c014902c 100644
--- a/source/libs/transport/src/transSrv.c
+++ b/source/libs/transport/src/transSrv.c
@@ -37,8 +37,7 @@ typedef struct SSrvConn {
 
   struct sockaddr_in addr;
   struct sockaddr_in locaddr;
-  // SRpcMsg sendMsg;
-  // del later
+
   char secured;
   int  spi;
   char info[64];
@@ -49,7 +48,7 @@ typedef struct SSrvConn {
 
 typedef struct SSrvMsg {
   SSrvConn* pConn;
-  SRpcMsg   msg;
+  STransMsg   msg;
   queue     q;
 } SSrvMsg;
 
@@ -207,20 +206,20 @@ static void uvHandleReq(SSrvConn* pConn) {
 
   pConn->inType = pHead->msgType;
 
-  SRpcInfo* pRpc = (SRpcInfo*)p->shandle;
+  STrans* pRpc = (STrans*)p->shandle;
   pHead->code = htonl(pHead->code);
 
   int32_t dlen = 0;
   if (transDecompressMsg(NULL, 0, NULL)) {
     // add compress later
-    // pHead = rpcDecompressRpcMsg(pHead);
+    // pHead = rpcDecompresSTransMsg(pHead);
   } else {
     pHead->msgLen = htonl(pHead->msgLen);
     // impl later
     //
   }
 
-  SRpcMsg rpcMsg;
+  STransMsg rpcMsg;
   rpcMsg.contLen = transContLenFromMsg(pHead->msgLen);
   rpcMsg.pCont = pHead->content;
   rpcMsg.msgType = pHead->msgType;
@@ -319,7 +318,7 @@ static void uvPrepareSendData(SSrvMsg* smsg, uv_buf_t* wb) {
   tTrace("server conn %p prepare to send resp", smsg->pConn);
 
   SSrvConn* pConn = smsg->pConn;
-  SRpcMsg*  pMsg = &smsg->msg;
+  STransMsg*  pMsg = &smsg->msg;
   if (pMsg->pCont == 0) {
     pMsg->pCont = (void*)rpcMallocCont(0);
     pMsg->contLen = 0;
@@ -547,7 +546,7 @@ static bool addHandleToWorkloop(void* arg) {
     return false;
   }
 
-  // SRpcInfo* pRpc = pThrd->shandle;
+  // STrans* pRpc = pThrd->shandle;
   uv_pipe_init(pThrd->loop, pThrd->pipe, 1);
   uv_pipe_open(pThrd->pipe, pThrd->fd);
 
@@ -668,7 +667,7 @@ static int transAddAuthPart(SSrvConn* pConn, char* msg, int msgLen) {
   return msgLen;
 }
 
-void* taosInitServer(uint32_t ip, uint32_t port, char* label, int numOfThreads, void* fp, void* shandle) {
+void* transInitServer(uint32_t ip, uint32_t port, char* label, int numOfThreads, void* fp, void* shandle) {
   SServerObj* srv = calloc(1, sizeof(SServerObj));
   srv->loop = (uv_loop_t*)malloc(sizeof(uv_loop_t));
   srv->numOfThreads = numOfThreads;
@@ -720,7 +719,7 @@ void* taosInitServer(uint32_t ip, uint32_t port, char* label, int numOfThreads,
 
   return srv;
 End:
-  taosCloseServer(srv);
+  transCloseServer(srv);
   return NULL;
 }
 
@@ -740,7 +739,7 @@ void sendQuitToWorkThrd(SWorkThrdObj* pThrd) {
   transSendAsync(pThrd->asyncPool, &srvMsg->q);
 }
 
-void taosCloseServer(void* arg) {
+void transCloseServer(void* arg) {
   // impl later
   SServerObj* srv = arg;
   for (int i = 0; i < srv->numOfThreads; i++) {
@@ -786,7 +785,7 @@ void transUnrefSrvHandle(void* handle) {
   }
   // unref srv handle
 }
-void rpcSendResponse(const SRpcMsg* pMsg) {
+void transSendResponse(const STransMsg* pMsg) {
   if (pMsg->handle == NULL) {
     return;
   }
@@ -799,14 +798,12 @@ void rpcSendResponse(const SRpcMsg* pMsg) {
   tTrace("server conn %p start to send resp", pConn);
   transSendAsync(pThrd->asyncPool, &srvMsg->q);
 }
-
-int rpcGetConnInfo(void* thandle, SRpcConnInfo* pInfo) {
+int transGetConnInfo(void *thandle, STransHandleInfo *pInfo) {
   SSrvConn* pConn = thandle;
-
   struct sockaddr_in addr = pConn->addr;
+
   pInfo->clientIp = (uint32_t)(addr.sin_addr.s_addr);
   pInfo->clientPort = ntohs(addr.sin_port);
-
   tstrncpy(pInfo->user, pConn->user, sizeof(pInfo->user));
   return 0;
 }

From ed788d3991f3b93aeeac8b040d2ddb32619d8c08 Mon Sep 17 00:00:00 2001
From: yihaoDeng <luomoxyz@126.com>
Date: Mon, 14 Mar 2022 16:11:17 +0800
Subject: [PATCH 12/16] formate

---
 source/libs/transport/inc/transComm.h | 20 ++++-----
 source/libs/transport/src/transCli.c  | 62 +++++++++++++++------------
 source/libs/transport/src/transSrv.c  | 10 ++---
 3 files changed, 47 insertions(+), 45 deletions(-)

diff --git a/source/libs/transport/inc/transComm.h b/source/libs/transport/inc/transComm.h
index 06d5a7da91..99f890d3a0 100644
--- a/source/libs/transport/inc/transComm.h
+++ b/source/libs/transport/inc/transComm.h
@@ -120,8 +120,8 @@ typedef struct {
   // SEpSet*          pSet;      // for synchronous API
 } SRpcReqContext;
 
-typedef SRpcMsg  STransMsg;
-typedef SRpcInfo STrans;  
+typedef SRpcMsg      STransMsg;
+typedef SRpcInfo     STrans;
 typedef SRpcConnInfo STransHandleInfo;
 
 typedef struct {
@@ -139,7 +139,7 @@ typedef struct {
   int64_t rid;       // refId returned by taosAddRef
 
   STransMsg* pRsp;  // for synchronous API
-  tsem_t*  pSem;  // for synchronous API
+  tsem_t*    pSem;  // for synchronous API
 
   int      hThrdIdx;
   char*    ip;
@@ -147,7 +147,6 @@ typedef struct {
   // SEpSet*          pSet;      // for synchronous API
 } STransConnCtx;
 
-
 #pragma pack(push, 1)
 
 typedef struct {
@@ -248,24 +247,21 @@ bool transReadComplete(SConnBuffer* connBuf);
 
 int transSetConnOption(uv_tcp_t* stream);
 
-
 void transRefSrvHandle(void* handle);
 void transUnrefSrvHandle(void* handle);
 
 void transRefCliHandle(void* handle);
 void transUnrefCliHandle(void* handle);
 
-
-void transSendRequest(void *shandle, const char *ip, uint32_t port, STransMsg *pMsg);
-void transSendRecv(void* shandle, const char *ip, uint32_t port, STransMsg *pMsg, STransMsg *pRsp);
+void transSendRequest(void* shandle, const char* ip, uint32_t port, STransMsg* pMsg);
+void transSendRecv(void* shandle, const char* ip, uint32_t port, STransMsg* pMsg, STransMsg* pRsp);
 void transSendResponse(const STransMsg* pMsg);
-int transGetConnInfo(void *thandle, STransHandleInfo *pInfo);
-
+int  transGetConnInfo(void* thandle, STransHandleInfo* pInfo);
 
 void* transInitServer(uint32_t ip, uint32_t port, char* label, int numOfThreads, void* fp, void* shandle);
 void* transInitClient(uint32_t ip, uint32_t port, char* label, int numOfThreads, void* fp, void* shandle);
 
-void transCloseClient(void *arg);
-void transCloseServer(void *arg);
+void transCloseClient(void* arg);
+void transCloseServer(void* arg);
 
 #endif
diff --git a/source/libs/transport/src/transCli.c b/source/libs/transport/src/transCli.c
index c55d699e4f..4af02a982e 100644
--- a/source/libs/transport/src/transCli.c
+++ b/source/libs/transport/src/transCli.c
@@ -42,7 +42,7 @@ typedef struct SCliConn {
 
 typedef struct SCliMsg {
   STransConnCtx* ctx;
-  STransMsg        msg;
+  STransMsg      msg;
   queue          q;
   uint64_t       st;
 } SCliMsg;
@@ -122,7 +122,7 @@ static void         destroyThrdObj(SCliThrdObj* pThrd);
 #define CONN_HANDLE_THREAD_QUIT(conn, thrd) \
   do {                                      \
     if (thrd->quit) {                       \
-      cliHandleExcept(conn);             \
+      cliHandleExcept(conn);                \
       goto _RETURE;                         \
     }                                       \
   } while (0)
@@ -130,19 +130,25 @@ static void         destroyThrdObj(SCliThrdObj* pThrd);
 #define CONN_HANDLE_BROKEN(conn) \
   do {                           \
     if (conn->broken) {          \
-      cliHandleExcept(conn);  \
+      cliHandleExcept(conn);     \
       goto _RETURE;              \
     }                            \
   } while (0);
 
-#define CONN_SET_PERSIST_BY_APP(conn) do { if (conn->persist == false) { conn->persist = true; transRefCliHandle(conn);}} while(0)
+#define CONN_SET_PERSIST_BY_APP(conn) \
+  do {                                \
+    if (conn->persist == false) {     \
+      conn->persist = true;           \
+      transRefCliHandle(conn);        \
+    }                                 \
+  } while (0)
 #define CONN_NO_PERSIST_BY_APP(conn) ((conn)->persist == false)
 
 static void* cliWorkThread(void* arg);
 
-void  cliHandleResp(SCliConn* conn) {
+void cliHandleResp(SCliConn* conn) {
   SCliThrdObj* pThrd = conn->hostThrd;
-  STrans*    pTransInst = pThrd->pTransInst;
+  STrans*      pTransInst = pThrd->pTransInst;
 
   STransMsgHead* pHead = (STransMsgHead*)(conn->readBuf.buf);
   pHead->code = htonl(pHead->code);
@@ -156,16 +162,16 @@ void  cliHandleResp(SCliConn* conn) {
   rpcMsg.pCont = transContFromHead((char*)pHead);
   rpcMsg.code = pHead->code;
   rpcMsg.msgType = pHead->msgType;
-  rpcMsg.ahandle = NULL; 
+  rpcMsg.ahandle = NULL;
 
-  SCliMsg* pMsg = conn->data;
-  STransConnCtx *pCtx = pMsg ? pMsg->ctx : NULL;
+  SCliMsg*       pMsg = conn->data;
+  STransConnCtx* pCtx = pMsg ? pMsg->ctx : NULL;
   if (pMsg == NULL && !CONN_NO_PERSIST_BY_APP(conn)) {
     rpcMsg.ahandle = pTransInst->mfp ? (*pTransInst->mfp)(pTransInst->parent, rpcMsg.msgType) : NULL;
   } else {
-    rpcMsg.ahandle = pCtx ? pCtx->ahandle : NULL;  
+    rpcMsg.ahandle = pCtx ? pCtx->ahandle : NULL;
   }
-  //if (rpcMsg.ahandle == NULL) {
+  // if (rpcMsg.ahandle == NULL) {
   //  tDebug("%s cli conn %p handle except", CONN_GET_INST_LABEL(conn), conn);
   //  return;
   //}
@@ -207,26 +213,26 @@ void  cliHandleResp(SCliConn* conn) {
 
 void cliHandleExcept(SCliConn* pConn) {
   if (pConn->data == NULL) {
-     if (pConn->broken == true || CONN_NO_PERSIST_BY_APP(pConn)) {
-        transUnrefCliHandle(pConn);
-        return;
-     }
+    if (pConn->broken == true || CONN_NO_PERSIST_BY_APP(pConn)) {
+      transUnrefCliHandle(pConn);
+      return;
+    }
   }
   SCliThrdObj* pThrd = pConn->hostThrd;
-  STrans*    pTransInst = pThrd->pTransInst;
+  STrans*      pTransInst = pThrd->pTransInst;
 
   SCliMsg*       pMsg = pConn->data;
-  STransConnCtx *pCtx = pMsg ? pMsg->ctx : NULL;
+  STransConnCtx* pCtx = pMsg ? pMsg->ctx : NULL;
 
   STransMsg rpcMsg = {0};
   rpcMsg.code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
   rpcMsg.msgType = pMsg ? pMsg->msg.msgType + 1 : 0;
-  rpcMsg.ahandle = NULL; 
+  rpcMsg.ahandle = NULL;
 
   if (pMsg == NULL && !CONN_NO_PERSIST_BY_APP(pConn)) {
     rpcMsg.ahandle = pTransInst->mfp ? (*pTransInst->mfp)(pTransInst->parent, rpcMsg.msgType) : NULL;
   } else {
-    rpcMsg.ahandle = pCtx ? pCtx->ahandle : NULL;  
+    rpcMsg.ahandle = pCtx ? pCtx->ahandle : NULL;
   }
 
   if (pCtx == NULL || pCtx->pSem == NULL) {
@@ -246,7 +252,7 @@ void cliHandleExcept(SCliConn* pConn) {
 
 void cliTimeoutCb(uv_timer_t* handle) {
   SCliThrdObj* pThrd = handle->data;
-  STrans*    pRpc = pThrd->pTransInst;
+  STrans*      pRpc = pThrd->pTransInst;
   int64_t      currentTime = pThrd->nextTimeout;
   tTrace("%s, cli conn timeout, try to remove expire conn from conn pool", pRpc->label);
 
@@ -420,7 +426,7 @@ void cliSend(SCliConn* pConn) {
   STransConnCtx* pCtx = pCliMsg->ctx;
 
   SCliThrdObj* pThrd = pConn->hostThrd;
-  STrans*    pTransInst = pThrd->pTransInst;
+  STrans*      pTransInst = pThrd->pTransInst;
 
   STransMsg* pMsg = (STransMsg*)(&pCliMsg->msg);
 
@@ -513,7 +519,7 @@ void cliHandleReq(SCliMsg* pMsg, SCliThrdObj* pThrd) {
   tTrace("%s cli msg tran time cost: %" PRIu64 "us", ((STrans*)pThrd->pTransInst)->label, el);
 
   STransConnCtx* pCtx = pMsg->ctx;
-  STrans*      pTransInst = pThrd->pTransInst;
+  STrans*        pTransInst = pThrd->pTransInst;
 
   SCliConn* conn = cliGetConn(pMsg, pThrd);
   if (conn != NULL) {
@@ -534,7 +540,7 @@ void cliHandleReq(SCliMsg* pMsg, SCliThrdObj* pThrd) {
     tTrace("%s cli conn %p try to connect to %s:%d", pTransInst->label, conn, pMsg->ctx->ip, pMsg->ctx->port);
     uv_tcp_connect(&conn->connReq, (uv_tcp_t*)(conn->stream), (const struct sockaddr*)&addr, cliConnCb);
   }
-  
+
   conn->hThrdIdx = pCtx->hThrdIdx;
 }
 static void cliAsyncCb(uv_async_t* handle) {
@@ -543,7 +549,7 @@ static void cliAsyncCb(uv_async_t* handle) {
   SCliMsg*     pMsg = NULL;
 
   // batch process to avoid to lock/unlock frequently
-  queue        wq;
+  queue wq;
   pthread_mutex_lock(&item->mtx);
   QUEUE_MOVE(&item->qmsg, &wq);
   pthread_mutex_unlock(&item->mtx);
@@ -689,9 +695,9 @@ void transUnrefCliHandle(void* handle) {
   }
 }
 
-void transSendRequest(void *shandle, const char *ip, uint32_t port, STransMsg *pMsg) {
+void transSendRequest(void* shandle, const char* ip, uint32_t port, STransMsg* pMsg) {
   STrans* pTransInst = (STrans*)shandle;
-  int index = CONN_HOST_THREAD_INDEX((SCliConn *)pMsg->handle);
+  int     index = CONN_HOST_THREAD_INDEX((SCliConn*)pMsg->handle);
   if (index == -1) {
     index = cliRBChoseIdx(pTransInst);
   }
@@ -718,9 +724,9 @@ void transSendRequest(void *shandle, const char *ip, uint32_t port, STransMsg *p
   SCliThrdObj* thrd = ((SCliObj*)pTransInst->tcphandle)->pThreadObj[index];
   transSendAsync(thrd->asyncPool, &(cliMsg->q));
 }
-void transSendRecv(void* shandle, const char *ip, uint32_t port, STransMsg *pReq, STransMsg *pRsp) {
+void transSendRecv(void* shandle, const char* ip, uint32_t port, STransMsg* pReq, STransMsg* pRsp) {
   STrans* pTransInst = (STrans*)shandle;
-  int index = CONN_HOST_THREAD_INDEX(pReq->handle);
+  int     index = CONN_HOST_THREAD_INDEX(pReq->handle);
   if (index == -1) {
     index = cliRBChoseIdx(pTransInst);
   }
diff --git a/source/libs/transport/src/transSrv.c b/source/libs/transport/src/transSrv.c
index f9c014902c..c236a69f4e 100644
--- a/source/libs/transport/src/transSrv.c
+++ b/source/libs/transport/src/transSrv.c
@@ -48,7 +48,7 @@ typedef struct SSrvConn {
 
 typedef struct SSrvMsg {
   SSrvConn* pConn;
-  STransMsg   msg;
+  STransMsg msg;
   queue     q;
 } SSrvMsg;
 
@@ -317,8 +317,8 @@ static void uvPrepareSendData(SSrvMsg* smsg, uv_buf_t* wb) {
   // impl later;
   tTrace("server conn %p prepare to send resp", smsg->pConn);
 
-  SSrvConn* pConn = smsg->pConn;
-  STransMsg*  pMsg = &smsg->msg;
+  SSrvConn*  pConn = smsg->pConn;
+  STransMsg* pMsg = &smsg->msg;
   if (pMsg->pCont == 0) {
     pMsg->pCont = (void*)rpcMallocCont(0);
     pMsg->contLen = 0;
@@ -798,8 +798,8 @@ void transSendResponse(const STransMsg* pMsg) {
   tTrace("server conn %p start to send resp", pConn);
   transSendAsync(pThrd->asyncPool, &srvMsg->q);
 }
-int transGetConnInfo(void *thandle, STransHandleInfo *pInfo) {
-  SSrvConn* pConn = thandle;
+int transGetConnInfo(void* thandle, STransHandleInfo* pInfo) {
+  SSrvConn*          pConn = thandle;
   struct sockaddr_in addr = pConn->addr;
 
   pInfo->clientIp = (uint32_t)(addr.sin_addr.s_addr);

From 65870538fd90fc575a3abbe61cb8dfc317b2cf1f Mon Sep 17 00:00:00 2001
From: Cary Xu <klxu@taosdata.com>
Date: Mon, 14 Mar 2022 17:38:10 +0800
Subject: [PATCH 13/16] test insert and query

---
 source/dnode/vnode/inc/tsdb.h             |   7 +-
 source/dnode/vnode/src/inc/tsdbDBDef.h    |   1 +
 source/dnode/vnode/src/inc/tsdbSma.h      |  17 +-
 source/dnode/vnode/src/tsdb/tsdbBDBImpl.c |  43 ++-
 source/dnode/vnode/src/tsdb/tsdbSma.c     | 308 +++++++++++++++-------
 source/dnode/vnode/src/tsdb/tsdbWrite.c   |   5 +-
 source/dnode/vnode/test/tsdbSmaTest.cpp   |  69 ++++-
 7 files changed, 314 insertions(+), 136 deletions(-)

diff --git a/source/dnode/vnode/inc/tsdb.h b/source/dnode/vnode/inc/tsdb.h
index 25bac86f71..87edfb8dde 100644
--- a/source/dnode/vnode/inc/tsdb.h
+++ b/source/dnode/vnode/inc/tsdb.h
@@ -95,7 +95,6 @@ int    tsdbCommit(STsdb *pTsdb);
  * @return int32_t
  */
 int32_t tsdbInsertTSmaData(STsdb *pTsdb, char *msg);
-
 int32_t tsdbUpdateSmaWindow(STsdb *pTsdb, int8_t smaType, char *msg);
 
 /**
@@ -107,6 +106,12 @@ int32_t tsdbUpdateSmaWindow(STsdb *pTsdb, int8_t smaType, char *msg);
  */
 int32_t tsdbInsertRSmaData(STsdb *pTsdb, char *msg);
 
+// TODO: This is the basic params, and should wrap the params to a queryHandle.
+int32_t tsdbGetTSmaData(STsdb *pTsdb, STSmaDataWrapper *pData, int64_t indexUid, int64_t interval,
+                            int8_t intervalUnit, tb_uid_t tableUid, col_id_t colId, TSKEY querySkey,
+                            int32_t nMaxResult);
+
+
 // STsdbCfg
 int  tsdbOptionsInit(STsdbCfg *);
 void tsdbOptionsClear(STsdbCfg *);
diff --git a/source/dnode/vnode/src/inc/tsdbDBDef.h b/source/dnode/vnode/src/inc/tsdbDBDef.h
index 7740dd0fab..2e37b0ba45 100644
--- a/source/dnode/vnode/src/inc/tsdbDBDef.h
+++ b/source/dnode/vnode/src/inc/tsdbDBDef.h
@@ -35,6 +35,7 @@ void    tsdbCloseDBF(SDBFile* pDBF);
 int32_t tsdbOpenBDBEnv(DB_ENV** ppEnv, const char* path);
 void    tsdbCloseBDBEnv(DB_ENV* pEnv);
 int32_t tsdbSaveSmaToDB(SDBFile* pDBF, void* key, uint32_t keySize, void* data, uint32_t dataSize);
+void*   tsdbGetSmaDataByKey(SDBFile* pDBF, void* key, uint32_t keySize, uint32_t* valueSize);
 
 #ifdef __cplusplus
 }
diff --git a/source/dnode/vnode/src/inc/tsdbSma.h b/source/dnode/vnode/src/inc/tsdbSma.h
index c54fdf85a3..649b5a2d47 100644
--- a/source/dnode/vnode/src/inc/tsdbSma.h
+++ b/source/dnode/vnode/src/inc/tsdbSma.h
@@ -27,29 +27,18 @@ struct SSmaEnv {
 };
 
 #define SMA_ENV_LOCK(env)       ((env)->lock)
+#define SMA_ENV_ENV(env)        ((env)->dbEnv)
 #define SMA_ENV_PATH(env)       ((env)->path)
 #define SMA_ENV_STAT(env)       ((env)->pStat)
 #define SMA_ENV_STAT_ITEMS(env) ((env)->pStat->smaStatItems)
 
-// insert/update interface
-int32_t tsdbInsertTSmaDataImpl(STsdb *pTsdb, char *msg);
-int32_t tsdbInsertRSmaDataImpl(STsdb *pTsdb, char *msg);
-
-// query interface
-// TODO: This is the basic params, and should wrap the params to a queryHandle.
-int32_t tsdbGetTSmaDataImpl(STsdb *pTsdb, STSmaDataWrapper *pData, STimeWindow *queryWin, int32_t nMaxResult);
-
-// management interface
-int32_t tsdbUpdateExpiredWindow(STsdb *pTsdb, int8_t smaType, char *msg);
-void    tsdbDestroySmaEnv(SSmaEnv *pSmaEnv);
-void *  tsdbFreeSmaEnv(SSmaEnv *pSmaEnv);
+void  tsdbDestroySmaEnv(SSmaEnv *pSmaEnv);
+void *tsdbFreeSmaEnv(SSmaEnv *pSmaEnv);
 #if 0
 int32_t tsdbGetTSmaStatus(STsdb *pTsdb, STSma *param, void *result);
 int32_t tsdbRemoveTSmaData(STsdb *pTsdb, STSma *param, STimeWindow *pWin);
 #endif
 
-
-
 // internal func
 static FORCE_INLINE int32_t tsdbEncodeTSmaKey(tb_uid_t tableUid, col_id_t colId, TSKEY tsKey, void **pData) {
   int32_t len = 0;
diff --git a/source/dnode/vnode/src/tsdb/tsdbBDBImpl.c b/source/dnode/vnode/src/tsdb/tsdbBDBImpl.c
index 4fc415cfd1..cf3351c5d8 100644
--- a/source/dnode/vnode/src/tsdb/tsdbBDBImpl.c
+++ b/source/dnode/vnode/src/tsdb/tsdbBDBImpl.c
@@ -29,7 +29,7 @@ static void tsdbCloseBDBDb(DB *pDB);
 
 #define BDB_PERR(info, code) fprintf(stderr, "%s:%d " info " reason: %s\n", __FILE__, __LINE__, db_strerror(code))
 
-int tsdbOpenDBF(TDBEnv pEnv, SDBFile *pDBF) {
+int32_t tsdbOpenDBF(TDBEnv pEnv, SDBFile *pDBF) {
   // TDBEnv is shared by a group of SDBFile
   if (!pEnv) {
     terrno = TSDB_CODE_INVALID_PTR;
@@ -46,18 +46,12 @@ int tsdbOpenDBF(TDBEnv pEnv, SDBFile *pDBF) {
   return 0;
 }
 
-static void *tsdbFreeDBF(SDBFile *pDBF) {
-  if (pDBF) {
-    free(pDBF);
-  }
-  return NULL;
-}
-
 void tsdbCloseDBF(SDBFile *pDBF) {
   if (pDBF->pDB) {
     tsdbCloseBDBDb(pDBF->pDB);
-    pDBF->pDB = tsdbFreeDBF(pDBF);
+    pDBF->pDB = NULL;
   }
+  tfree(pDBF->path);
 }
 
 int32_t tsdbOpenBDBEnv(DB_ENV **ppEnv, const char *path) {
@@ -145,4 +139,35 @@ int32_t tsdbSaveSmaToDB(SDBFile *pDBF, void *key, uint32_t keySize, void *data,
   // TODO: unlock
 
   return 0;
+}
+
+void *tsdbGetSmaDataByKey(SDBFile *pDBF, void* key, uint32_t keySize, uint32_t *valueSize) {
+  void *result = NULL;
+  DBT   key1 = {0};
+  DBT   value1 = {0};
+  int   ret;
+
+  // Set key/value
+  key1.data = key;
+  key1.size = keySize;
+
+  // Query
+  // TODO: lock
+  ret = pDBF->pDB->get(pDBF->pDB, NULL, &key1, &value1, 0);
+  // TODO: unlock
+  if (ret != 0) {
+    return NULL;
+  }
+
+  result = calloc(1, value1.size);
+
+  if (result == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
+
+  *valueSize = value1.size;
+  memcpy(result, value1.data, value1.size);
+
+  return result;
 }
\ No newline at end of file
diff --git a/source/dnode/vnode/src/tsdb/tsdbSma.c b/source/dnode/vnode/src/tsdb/tsdbSma.c
index f96ea644b4..0dbcb29f80 100644
--- a/source/dnode/vnode/src/tsdb/tsdbSma.c
+++ b/source/dnode/vnode/src/tsdb/tsdbSma.c
@@ -15,6 +15,7 @@
 
 #include "tsdbDef.h"
 
+#undef SMA_PRINT_DEBUG_LOG
 #define SMA_STORAGE_TSDB_DAYS   30
 #define SMA_STORAGE_TSDB_TIMES  30
 #define SMA_STORAGE_SPLIT_HOURS 24
@@ -31,24 +32,23 @@ typedef enum {
 } ESmaStorageLevel;
 
 typedef struct {
-  STsdb *  pTsdb;
-  SDBFile *pDFile;
-  int32_t  interval;  // interval with the precision of DB
-  // TODO
+  STsdb * pTsdb;
+  SDBFile dFile;
+  int32_t interval;  // interval with the precision of DB
 } STSmaWriteH;
 
 typedef struct {
   int32_t iter;
+  int32_t fid;
 } SmaFsIter;
 typedef struct {
   STsdb *   pTsdb;
-  char *    pDFile;     // TODO: use the real DFile type, not char*
+  SDBFile   dFile;
   int32_t   interval;   // interval with the precision of DB
   int32_t   blockSize;  // size of SMA block item
   int8_t    storageLevel;
   int8_t    days;
   SmaFsIter smaFsIter;
-  // TODO
 } STSmaReadH;
 
 typedef struct {
@@ -69,23 +69,30 @@ struct SSmaStat {
 };
 
 // declaration of static functions
+static int32_t tsdbInsertTSmaDataImpl(STsdb *pTsdb, char *msg);
+static int32_t tsdbInsertRSmaDataImpl(STsdb *pTsdb, char *msg);
+// TODO: This is the basic params, and should wrap the params to a queryHandle.
+static int32_t tsdbGetTSmaDataImpl(STsdb *pTsdb, STSmaDataWrapper *pData, int64_t indexUid, int64_t interval,
+                                   int8_t intervalUnit, tb_uid_t tableUid, col_id_t colId, TSKEY querySkey,
+                                   int32_t nMaxResult);
+static int32_t tsdbUpdateExpiredWindow(STsdb *pTsdb, int8_t smaType, char *msg);
+
 static int32_t  tsdbInitSmaStat(SSmaStat **pSmaStat);
 static int32_t  tsdbDestroySmaState(SSmaStat *pSmaStat);
 static SSmaEnv *tsdbNewSmaEnv(const STsdb *pTsdb, const char *path);
 static int32_t  tsdbInitSmaEnv(STsdb *pTsdb, const char *path, SSmaEnv **pEnv);
 static int32_t  tsdbInitTSmaWriteH(STSmaWriteH *pSmaH, STsdb *pTsdb, STSmaDataWrapper *pData);
 static void     tsdbDestroyTSmaWriteH(STSmaWriteH *pSmaH);
-static int32_t  tsdbInitTSmaReadH(STSmaReadH *pSmaH, STsdb *pTsdb, STSmaDataWrapper *pData);
+static int32_t  tsdbInitTSmaReadH(STSmaReadH *pSmaH, STsdb *pTsdb, int64_t interval, int8_t intervalUnit);
 static int32_t  tsdbGetSmaStorageLevel(int64_t interval, int8_t intervalUnit);
 static int32_t  tsdbInsertTSmaDataSection(STSmaWriteH *pSmaH, STSmaDataWrapper *pData);
-static int32_t tsdbInsertTSmaBlocks(STSmaWriteH *pSmaH, void *smaKey, uint32_t keyLen, void *pData, uint32_t dataLen);
+static int32_t  tsdbInsertTSmaBlocks(STSmaWriteH *pSmaH, void *smaKey, uint32_t keyLen, void *pData, uint32_t dataLen);
 
 static int64_t tsdbGetIntervalByPrecision(int64_t interval, uint8_t intervalUnit, int8_t precision);
-static int32_t tsdbGetTSmaDays(STSmaWriteH *pSmaH, int32_t storageLevel);
+static int32_t tsdbGetTSmaDays(STsdb *pTsdb, int64_t interval, int32_t storageLevel);
 static int32_t tsdbSetTSmaDataFile(STSmaWriteH *pSmaH, STSmaDataWrapper *pData, int32_t storageLevel, int32_t fid);
-static int32_t tsdbInitTSmaReadH(STSmaReadH *pSmaH, STsdb *pTsdb, STSmaDataWrapper *pData);
-static int32_t tsdbInitTSmaFile(STSmaReadH *pReadH, STimeWindow *queryWin);
-static bool    tsdbSetAndOpenTSmaFile(STSmaReadH *pReadH, STimeWindow *queryWin);
+static int32_t tsdbInitTSmaFile(STSmaReadH *pSmaH, TSKEY skey);
+static bool    tsdbSetAndOpenTSmaFile(STSmaReadH *pReadH, TSKEY *queryKey);
 
 static SSmaEnv *tsdbNewSmaEnv(const STsdb *pTsdb, const char *path) {
   SSmaEnv *pEnv = NULL;
@@ -408,25 +415,35 @@ static int32_t tsdbGetSmaStorageLevel(int64_t interval, int8_t intervalUnit) {
 }
 
 /**
- * @brief Insert TSma data blocks to B+Tree
+ * @brief Insert TSma data blocks to DB File build by B+Tree
  *
- * @param bTree
+ * @param pSmaH
  * @param smaKey
+ * @param keyLen
  * @param pData
  * @param dataLen
  * @return int32_t
  */
 static int32_t tsdbInsertTSmaBlocks(STSmaWriteH *pSmaH, void *smaKey, uint32_t keyLen, void *pData, uint32_t dataLen) {
-  SDBFile *pDBFile = pSmaH->pDFile;
+  SDBFile *pDBFile = &pSmaH->dFile;
 
   // TODO: insert sma data blocks into B+Tree
-  tsdbDebug("insert sma data blocks into %s: smaKey %" PRIx64 "-%" PRIu16 "-%" PRIx64 ", dataLen %d", pDBFile->path,
-            *(uint64_t *)smaKey, *(uint16_t *)POINTER_SHIFT(smaKey, 8), *(int64_t *)POINTER_SHIFT(smaKey, 10), dataLen);
+  tsdbDebug("vgId:%d insert sma data blocks into %s: smaKey %" PRIx64 "-%" PRIu16 "-%" PRIx64 ", dataLen %d",
+           REPO_ID(pSmaH->pTsdb), pDBFile->path, *(tb_uid_t *)smaKey, *(uint16_t *)POINTER_SHIFT(smaKey, 8),
+           *(int64_t *)POINTER_SHIFT(smaKey, 10), dataLen);
 
-  if(tsdbSaveSmaToDB(pDBFile, smaKey, keyLen, pData, dataLen) != 0){
+  if (tsdbSaveSmaToDB(pDBFile, smaKey, keyLen, pData, dataLen) != 0) {
     return TSDB_CODE_FAILED;
   }
 
+#ifdef SMA_PRINT_DEBUG_LOG
+  uint32_t valueSize = 0;
+  void *   data = tsdbGetSmaDataByKey(pDBFile, smaKey, keyLen, &valueSize);
+  ASSERT(data != NULL);
+  for (uint32_t v = 0; v < valueSize; v += 8) {
+    tsdbWarn("vgId:%d sma data - val[%d] is %" PRIi64, REPO_ID(pSmaH->pTsdb), v, *(int64_t *)POINTER_SHIFT(data, v));
+  }
+#endif
   return TSDB_CODE_SUCCESS;
 }
 
@@ -458,41 +475,41 @@ static int64_t tsdbGetIntervalByPrecision(int64_t interval, uint8_t intervalUnit
     }
   }
 
-  switch (intervalUnit) {
-    case TD_TIME_UNIT_MILLISEC:
-      if (TSDB_TIME_PRECISION_MILLI == precision) {
-        return interval;
-      } else if (TSDB_TIME_PRECISION_MICRO == precision) {
-        return interval * 1e3;
-      } else {  //  nano second
-        return interval * 1e6;
-      }
-      break;
-    case TD_TIME_UNIT_MICROSEC:
-      if (TSDB_TIME_PRECISION_MILLI == precision) {
+  switch (precision) {
+    case TSDB_TIME_PRECISION_MILLI:
+      if (TD_TIME_UNIT_MICROSEC == intervalUnit) {  // us
         return interval / 1e3;
-      } else if (TSDB_TIME_PRECISION_MICRO == precision) {
-        return interval;
-      } else {  //  nano second
-        return interval * 1e3;
-      }
-      break;
-    case TD_TIME_UNIT_NANOSEC:
-      if (TSDB_TIME_PRECISION_MILLI == precision) {
+      } else if (TD_TIME_UNIT_NANOSEC == intervalUnit) {  //  nano second
         return interval / 1e6;
-      } else if (TSDB_TIME_PRECISION_MICRO == precision) {
-        return interval / 1e3;
-      } else {  // nano second
+      } else {
         return interval;
       }
       break;
-    default:
-      if (TSDB_TIME_PRECISION_MILLI == precision) {
+    case TSDB_TIME_PRECISION_MICRO:
+      if (TD_TIME_UNIT_MICROSEC == intervalUnit) {  // us
+        return interval;
+      } else if (TD_TIME_UNIT_NANOSEC == intervalUnit) {  //  nano second
+        return interval / 1e3;
+      } else {
         return interval * 1e3;
-      } else if (TSDB_TIME_PRECISION_MICRO == precision) {
+      }
+      break;
+    case TSDB_TIME_PRECISION_NANO:
+      if (TD_TIME_UNIT_MICROSEC == intervalUnit) {
+        return interval * 1e3;
+      } else if (TD_TIME_UNIT_NANOSEC == intervalUnit) {  // nano second
+        return interval;
+      } else {
         return interval * 1e6;
-      } else {  // nano second
-        return interval * 1e9;
+      }
+      break;
+    default:                                        // ms
+      if (TD_TIME_UNIT_MICROSEC == intervalUnit) {  // us
+        return interval / 1e3;
+      } else if (TD_TIME_UNIT_NANOSEC == intervalUnit) {  //  nano second
+        return interval / 1e6;
+      } else {
+        return interval;
       }
       break;
   }
@@ -551,37 +568,38 @@ static int32_t tsdbInsertTSmaDataSection(STSmaWriteH *pSmaH, STSmaDataWrapper *p
 static int32_t tsdbInitTSmaWriteH(STSmaWriteH *pSmaH, STsdb *pTsdb, STSmaDataWrapper *pData) {
   pSmaH->pTsdb = pTsdb;
   pSmaH->interval = tsdbGetIntervalByPrecision(pData->interval, pData->intervalUnit, REPO_CFG(pTsdb)->precision);
-  pSmaH->pDFile = (SDBFile *)calloc(1, sizeof(SDBFile *));
-  if (!pSmaH->pDFile) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return TSDB_CODE_FAILED;
-  }
   return TSDB_CODE_SUCCESS;
 }
 
 static void tsdbDestroyTSmaWriteH(STSmaWriteH *pSmaH) {
   if (pSmaH) {
-    if (pSmaH->pDFile) {
-      tsdbCloseDBF(pSmaH->pDFile);
-    }
+    tsdbCloseDBF(&pSmaH->dFile);
   }
 }
 
 static int32_t tsdbSetTSmaDataFile(STSmaWriteH *pSmaH, STSmaDataWrapper *pData, int32_t storageLevel, int32_t fid) {
   STsdb *pTsdb = pSmaH->pTsdb;
-  ASSERT(pSmaH->pDFile->path == NULL && pSmaH->pDFile->pDB == NULL);
+  ASSERT(pSmaH->dFile.path == NULL && pSmaH->dFile.pDB == NULL);
   char tSmaFile[TSDB_FILENAME_LEN] = {0};
   snprintf(tSmaFile, TSDB_FILENAME_LEN, "v%df%d.tsma", REPO_ID(pTsdb), fid);
-  pSmaH->pDFile->path = strdup(tSmaFile);
+  pSmaH->dFile.path = strdup(tSmaFile);
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t tsdbGetTSmaDays(STSmaWriteH *pSmaH, int32_t storageLevel) {
-  STsdbCfg *pCfg = REPO_CFG(pSmaH->pTsdb);
+/**
+ * @brief
+ *
+ * @param pTsdb
+ * @param interval Interval calculated by DB's precision
+ * @param storageLevel
+ * @return int32_t
+ */
+static int32_t tsdbGetTSmaDays(STsdb *pTsdb, int64_t interval, int32_t storageLevel) {
+  STsdbCfg *pCfg = REPO_CFG(pTsdb);
   int32_t   daysPerFile = pCfg->daysPerFile;
 
   if (storageLevel == SMA_STORAGE_LEVEL_TSDB) {
-    int32_t days = 30 * (pSmaH->interval / tsTickPerDay[pCfg->precision]);
+    int32_t days = SMA_STORAGE_TSDB_TIMES * (interval / tsTickPerDay[pCfg->precision]);
     daysPerFile = days > SMA_STORAGE_TSDB_DAYS ? days : SMA_STORAGE_TSDB_DAYS;
   }
 
@@ -600,7 +618,7 @@ static int32_t tsdbGetTSmaDays(STSmaWriteH *pSmaH, int32_t storageLevel) {
  * @param msg
  * @return int32_t
  */
-int32_t tsdbInsertTSmaDataImpl(STsdb *pTsdb, char *msg) {
+static int32_t tsdbInsertTSmaDataImpl(STsdb *pTsdb, char *msg) {
   STsdbCfg *        pCfg = REPO_CFG(pTsdb);
   STSmaDataWrapper *pData = (STSmaDataWrapper *)msg;
 
@@ -624,16 +642,16 @@ int32_t tsdbInsertTSmaDataImpl(STsdb *pTsdb, char *msg) {
 
   // Step 1: Judge the storage level and days
   int32_t storageLevel = tsdbGetSmaStorageLevel(pData->interval, pData->intervalUnit);
-  int32_t daysPerFile = tsdbGetTSmaDays(&tSmaH, storageLevel);
+  int32_t daysPerFile = tsdbGetTSmaDays(pTsdb, tSmaH.interval, storageLevel);
   int32_t fid = (int32_t)(TSDB_KEY_FID(pData->skey, daysPerFile, pCfg->precision));
 
   // Step 2: Set the DFile for storage of SMA index, and iterate/split the TSma data and store to B+Tree index file
   //         - Set and open the DFile or the B+Tree file
   // TODO: tsdbStartTSmaCommit();
   tsdbSetTSmaDataFile(&tSmaH, pData, storageLevel, fid);
-  if (tsdbOpenDBF(pTsdb->pTSmaEnv->dbEnv, tSmaH.pDFile) != 0) {
+  if (tsdbOpenDBF(pTsdb->pTSmaEnv->dbEnv, &tSmaH.dFile) != 0) {
     tsdbWarn("vgId:%d open DB file %s failed since %s", REPO_ID(pTsdb),
-             tSmaH.pDFile->path ? tSmaH.pDFile->path : "path is NULL", tstrerror(terrno));
+             tSmaH.dFile.path ? tSmaH.dFile.path : "path is NULL", tstrerror(terrno));
     tsdbDestroyTSmaWriteH(&tSmaH);
     return TSDB_CODE_FAILED;
   }
@@ -657,12 +675,12 @@ static int32_t tsdbSetRSmaDataFile(STSmaWriteH *pSmaH, STSmaDataWrapper *pData,
 
   char tSmaFile[TSDB_FILENAME_LEN] = {0};
   snprintf(tSmaFile, TSDB_FILENAME_LEN, "v%df%d.rsma", REPO_ID(pTsdb), fid);
-  pSmaH->pDFile->path = strdup(tSmaFile);
+  pSmaH->dFile.path = strdup(tSmaFile);
 
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t tsdbInsertRSmaDataImpl(STsdb *pTsdb, char *msg) {
+static int32_t tsdbInsertRSmaDataImpl(STsdb *pTsdb, char *msg) {
   STsdbCfg *        pCfg = REPO_CFG(pTsdb);
   STSmaDataWrapper *pData = (STSmaDataWrapper *)msg;
   STSmaWriteH       tSmaH = {0};
@@ -698,35 +716,35 @@ int32_t tsdbInsertRSmaDataImpl(STsdb *pTsdb, char *msg) {
 }
 
 /**
- * @brief Init of tSma ReadH
+ * @brief
  *
  * @param pSmaH
  * @param pTsdb
- * @param param
- * @param pData
+ * @param interval
+ * @param intervalUnit
  * @return int32_t
  */
-static int32_t tsdbInitTSmaReadH(STSmaReadH *pSmaH, STsdb *pTsdb, STSmaDataWrapper *pData) {
+static int32_t tsdbInitTSmaReadH(STSmaReadH *pSmaH, STsdb *pTsdb, int64_t interval, int8_t intervalUnit) {
   pSmaH->pTsdb = pTsdb;
-  pSmaH->interval = tsdbGetIntervalByPrecision(pData->interval, pData->intervalUnit, REPO_CFG(pTsdb)->precision);
-  // pSmaH->blockSize = param->numOfFuncIds * sizeof(int64_t);
+  pSmaH->interval = tsdbGetIntervalByPrecision(interval, intervalUnit, REPO_CFG(pTsdb)->precision);
+  pSmaH->storageLevel = tsdbGetSmaStorageLevel(interval, intervalUnit);
+  pSmaH->days = tsdbGetTSmaDays(pTsdb, pSmaH->interval, pSmaH->storageLevel);
 }
 
 /**
  * @brief Init of tSma FS
  *
  * @param pReadH
- * @param param
- * @param queryWin
+ * @param skey
  * @return int32_t
  */
-static int32_t tsdbInitTSmaFile(STSmaReadH *pReadH, STimeWindow *queryWin) {
-  int32_t storageLevel = 0;  // tsdbGetSmaStorageLevel(param->interval, param->intervalUnit);
-  int32_t daysPerFile =
-      storageLevel == SMA_STORAGE_LEVEL_TSDB ? SMA_STORAGE_TSDB_DAYS : REPO_CFG(pReadH->pTsdb)->daysPerFile;
-  pReadH->storageLevel = storageLevel;
-  pReadH->days = daysPerFile;
-  pReadH->smaFsIter.iter = 0;
+static int32_t tsdbInitTSmaFile(STSmaReadH *pSmaH, TSKEY skey) {
+  int32_t fid = (int32_t)(TSDB_KEY_FID(skey, pSmaH->days, REPO_CFG(pSmaH->pTsdb)->precision));
+  char    tSmaFile[TSDB_FILENAME_LEN] = {0};
+  snprintf(tSmaFile, TSDB_FILENAME_LEN, "v%df%d.tsma", REPO_ID(pSmaH->pTsdb), fid);
+  pSmaH->dFile.path = strdup(tSmaFile);
+  pSmaH->smaFsIter.iter = 0;
+  pSmaH->smaFsIter.fid = fid;
 }
 
 /**
@@ -738,17 +756,18 @@ static int32_t tsdbInitTSmaFile(STSmaReadH *pReadH, STimeWindow *queryWin) {
  * @return true
  * @return false
  */
-static bool tsdbSetAndOpenTSmaFile(STSmaReadH *pReadH, STimeWindow *queryWin) {
+static bool tsdbSetAndOpenTSmaFile(STSmaReadH *pReadH, TSKEY *queryKey) {
   SArray *smaFs = pReadH->pTsdb->fs->cstatus->sf;
   int32_t nSmaFs = taosArrayGetSize(smaFs);
 
-  pReadH->pDFile = NULL;
+  tsdbCloseDBF(&pReadH->dFile);
 
+#if 0
   while (pReadH->smaFsIter.iter < nSmaFs) {
     void *pSmaFile = taosArrayGet(smaFs, pReadH->smaFsIter.iter);
     if (pSmaFile) {  // match(indexName, queryWindow)
       // TODO: select the file by index_name ...
-      pReadH->pDFile = pSmaFile;
+      pReadH->dFile = pSmaFile;
       ++pReadH->smaFsIter.iter;
       break;
     }
@@ -759,41 +778,82 @@ static bool tsdbSetAndOpenTSmaFile(STSmaReadH *pReadH, STimeWindow *queryWin) {
     tsdbDebug("vg%d: smaFile %s matched", REPO_ID(pReadH->pTsdb), "[pSmaFile dir]");
     return true;
   }
+#endif
 
   return false;
 }
 
 /**
- * @brief Return the data between queryWin and fill the pData.
+ * @brief
  *
- * @param pTsdb
- * @param param
+ * @param pTsdb Return the data between queryWin and fill the pData.
  * @param pData
- * @param queryWin
+ * @param indexUid
+ * @param interval
+ * @param intervalUnit
+ * @param tableUid
+ * @param colId
+ * @param pQuerySKey
  * @param nMaxResult The query invoker should control the nMaxResult need to return to avoid OOM.
  * @return int32_t
  */
-int32_t tsdbGetTSmaDataImpl(STsdb *pTsdb, STSmaDataWrapper *pData, STimeWindow *queryWin, int32_t nMaxResult) {
-  SSmaStatItem *pItem =
-      (SSmaStatItem *)taosHashGet(SMA_ENV_STAT_ITEMS(pTsdb->pTSmaEnv), &pData->indexUid, sizeof(pData->indexUid));
+static int32_t tsdbGetTSmaDataImpl(STsdb *pTsdb, STSmaDataWrapper *pData, int64_t indexUid, int64_t interval,
+                                   int8_t intervalUnit, tb_uid_t tableUid, col_id_t colId, TSKEY querySkey,
+                                   int32_t nMaxResult) {
+  SSmaStatItem *pItem = (SSmaStatItem *)taosHashGet(SMA_ENV_STAT_ITEMS(pTsdb->pTSmaEnv), &indexUid, sizeof(indexUid));
   if (pItem == NULL) {
     // mark all window as expired and notify query module to query raw TS data.
     return TSDB_CODE_SUCCESS;
   }
 
-  int32_t nQueryWin = 0;
+#if 0
+  int32_t nQueryWin = taosArrayGetSize(pQuerySKey);
   for (int32_t n = 0; n < nQueryWin; ++n) {
-    TSKEY thisWindow = n;
-    if (taosHashGet(pItem->expiredWindows, &thisWindow, sizeof(thisWindow)) != NULL) {
+    TSKEY skey = taosArrayGet(pQuerySKey, n);
+    if (taosHashGet(pItem->expiredWindows, &skey, sizeof(TSKEY)) != NULL) {
       // TODO: mark this window as expired.
     }
   }
-
+#endif
+#if 0
+  if (taosHashGet(pItem->expiredWindows, &querySkey, sizeof(TSKEY)) != NULL) {
+    // TODO: mark this window as expired.
+  }
+#endif
   STSmaReadH tReadH = {0};
-  tsdbInitTSmaReadH(&tReadH, pTsdb, pData);
+  tsdbInitTSmaReadH(&tReadH, pTsdb, interval, intervalUnit);
+  tsdbCloseDBF(&tReadH.dFile);
 
-  tsdbInitTSmaFile(&tReadH, queryWin);
+  tsdbInitTSmaFile(&tReadH, querySkey);
+  if (tsdbOpenDBF(SMA_ENV_ENV(pTsdb->pTSmaEnv), &tReadH.dFile) != 0) {
+    tsdbWarn("vgId:%d open DBF %s failed since %s", REPO_ID(pTsdb), tReadH.dFile.path, tstrerror(terrno));
+    return TSDB_CODE_FAILED;
+  }
 
+  char  smaKey[SMA_KEY_LEN] = {0};
+  void *pSmaKey = &smaKey;
+  tsdbEncodeTSmaKey(tableUid, colId, querySkey, (void **)&pSmaKey);
+
+  tsdbDebug("vgId:%d get sma data from %s: smaKey %" PRIx64 "-%" PRIu16 "-%" PRIx64 ", keyLen %d", REPO_ID(pTsdb),
+           tReadH.dFile.path, *(tb_uid_t *)smaKey, *(uint16_t *)POINTER_SHIFT(smaKey, 8),
+           *(int64_t *)POINTER_SHIFT(smaKey, 10), SMA_KEY_LEN);
+
+  void *   result = NULL;
+  uint32_t valueSize = 0;
+  if ((result = tsdbGetSmaDataByKey(&tReadH.dFile, smaKey, SMA_KEY_LEN, &valueSize)) == NULL) {
+    tsdbWarn("vgId:%d get sma data failed from smaIndex %" PRIi64 ", smaKey %" PRIx64 "-%" PRIu16 "-%" PRIx64
+             " since %s",
+             REPO_ID(pTsdb), indexUid, *(tb_uid_t *)smaKey, *(uint16_t *)POINTER_SHIFT(smaKey, 8),
+             *(int64_t *)POINTER_SHIFT(smaKey, 10), tstrerror(terrno));
+    tsdbCloseDBF(&tReadH.dFile);
+    return TSDB_CODE_FAILED;
+  }
+#ifdef SMA_PRINT_DEBUG_LOG
+  for (uint32_t v = 0; v < valueSize; v += 8) {
+    tsdbWarn("vgId:%d v[%d]=%" PRIi64, REPO_ID(pTsdb), v, *(int64_t *)POINTER_SHIFT(result, v));
+  }
+#endif
+#if 0
   int32_t nResult = 0;
   int64_t lastKey = 0;
 
@@ -815,8 +875,9 @@ int32_t tsdbGetTSmaDataImpl(STsdb *pTsdb, STSmaDataWrapper *pData, STimeWindow *
       }
     }
   }
-
+#endif
   // read data from file and fill the result
+  tsdbCloseDBF(&tReadH.dFile);
   return TSDB_CODE_SUCCESS;
 }
 
@@ -854,4 +915,55 @@ int32_t tsdbRemoveTSmaData(STsdb *pTsdb, void *smaIndex, STimeWindow *pWin) {
   // }
   return TSDB_CODE_SUCCESS;
 }
-#endif
\ No newline at end of file
+#endif
+
+/**
+ * @brief Insert/Update tSma(Time-range-wise SMA) data from stream computing engine
+ *
+ * @param pTsdb
+ * @param param
+ * @param msg
+ * @return int32_t
+ * TODO: Who is responsible for resource allocate and release?
+ */
+int32_t tsdbInsertTSmaData(STsdb *pTsdb, char *msg) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  if ((code = tsdbInsertTSmaDataImpl(pTsdb, msg)) < 0) {
+    tsdbWarn("vgId:%d insert tSma data failed since %s", REPO_ID(pTsdb), tstrerror(terrno));
+  }
+  return code;
+}
+
+int32_t tsdbUpdateSmaWindow(STsdb *pTsdb, int8_t smaType, char *msg) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  if ((code = tsdbUpdateExpiredWindow(pTsdb, smaType, msg)) < 0) {
+    tsdbWarn("vgId:%d update expired sma window failed since %s", REPO_ID(pTsdb), tstrerror(terrno));
+  }
+  return code;
+}
+
+/**
+ * @brief Insert Time-range-wise Rollup Sma(RSma) data
+ *
+ * @param pTsdb
+ * @param param
+ * @param msg
+ * @return int32_t
+ */
+int32_t tsdbInsertRSmaData(STsdb *pTsdb, char *msg) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  if ((code = tsdbInsertRSmaDataImpl(pTsdb, msg)) < 0) {
+    tsdbWarn("vgId:%d insert rSma data failed since %s", REPO_ID(pTsdb), tstrerror(terrno));
+  }
+  return code;
+}
+
+int32_t tsdbGetTSmaData(STsdb *pTsdb, STSmaDataWrapper *pData, int64_t indexUid, int64_t interval, int8_t intervalUnit,
+                        tb_uid_t tableUid, col_id_t colId, TSKEY querySkey, int32_t nMaxResult) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  if ((code = tsdbGetTSmaDataImpl(pTsdb, pData, indexUid, interval, intervalUnit, tableUid, colId, querySkey,
+                                  nMaxResult)) < 0) {
+    tsdbWarn("vgId:%d get tSma data failed since %s", REPO_ID(pTsdb), tstrerror(terrno));
+  }
+  return code;
+}
\ No newline at end of file
diff --git a/source/dnode/vnode/src/tsdb/tsdbWrite.c b/source/dnode/vnode/src/tsdb/tsdbWrite.c
index 9cccea9853..3ccb483fe4 100644
--- a/source/dnode/vnode/src/tsdb/tsdbWrite.c
+++ b/source/dnode/vnode/src/tsdb/tsdbWrite.c
@@ -34,6 +34,7 @@ int tsdbInsertData(STsdb *pTsdb, SSubmitReq *pMsg, SSubmitRsp *pRsp) {
   return tsdbMemTableInsert(pTsdb, pTsdb->mem, pMsg, NULL);
 }
 
+#if 0
 /**
  * @brief Insert/Update tSma(Time-range-wise SMA) data from stream computing engine
  * 
@@ -73,4 +74,6 @@ int32_t tsdbInsertRSmaData(STsdb *pTsdb, char *msg) {
     tsdbWarn("vgId:%d insert rSma data failed since %s", REPO_ID(pTsdb), tstrerror(terrno));
   }
   return code;
-}
\ No newline at end of file
+}
+
+#endif
\ No newline at end of file
diff --git a/source/dnode/vnode/test/tsdbSmaTest.cpp b/source/dnode/vnode/test/tsdbSmaTest.cpp
index f815291c77..18dca33bda 100644
--- a/source/dnode/vnode/test/tsdbSmaTest.cpp
+++ b/source/dnode/vnode/test/tsdbSmaTest.cpp
@@ -33,7 +33,7 @@ int main(int argc, char **argv) {
   return RUN_ALL_TESTS();
 }
 
-TEST(testCase, tSmaEncodeDecodeTest) {
+TEST(testCase, tSma_Meta_Encode_Decode_Test) {
   // encode
   STSma tSma = {0};
   tSma.version = 0;
@@ -87,8 +87,9 @@ TEST(testCase, tSmaEncodeDecodeTest) {
   tdDestroyTSma(&tSma);
   tdDestroyTSmaWrapper(&dstTSmaWrapper);
 }
+
 #if 1
-TEST(testCase, tSma_DB_Put_Get_Del_Test) {
+TEST(testCase, tSma_metaDB_Put_Get_Del_Test) {
   const char *   smaIndexName1 = "sma_index_test_1";
   const char *   smaIndexName2 = "sma_index_test_2";
   const char *   timezone = "Asia/Shanghai";
@@ -220,16 +221,21 @@ TEST(testCase, tSma_DB_Put_Get_Del_Test) {
 #endif
 
 #if 1
-TEST(testCase, tSmaInsertTest) {
-  // prepare meta
+TEST(testCase, tSma_Data_Insert_Query_Test) {
+  // step 1: prepare meta
   const char *   smaIndexName1 = "sma_index_test_1";
   const char *   timezone = "Asia/Shanghai";
   const char *   expr = "select count(a,b, top 20), from table interval 1d, sliding 1h;";
-  const char *   tagsFilter = "I'm tags filter";
+  const char *   tagsFilter = "where tags.location='Beijing' and tags.district='ChaoYang'";
   const char *   smaTestDir = "./smaTest";
   const tb_uid_t tbUid = 1234567890;
   const int64_t  indexUid1 = 2000000001;
+  const int64_t  interval1 = 1;
+  const int8_t   intervalUnit1 = TD_TIME_UNIT_DAY;
   const uint32_t nCntTSma = 2;
+  TSKEY          skey1 = 1646987196;
+  const int64_t  testSmaData1 = 100;
+  const int64_t  testSmaData2 = 200;
   // encode
   STSma tSma = {0};
   tSma.version = 0;
@@ -261,7 +267,7 @@ TEST(testCase, tSmaInsertTest) {
   // save index 1
   EXPECT_EQ(metaSaveSmaToDB(pMeta, pSmaCfg), 0);
 
-  // insert data
+  // step 2: insert data
   STSmaDataWrapper *pSmaData = NULL;
   STsdb             tsdb = {0};
   STsdbCfg *        pCfg = &tsdb.config;
@@ -276,6 +282,21 @@ TEST(testCase, tSmaInsertTest) {
   tsdb.config.update = TD_ROW_OVERWRITE_UPDATE;
   tsdb.config.compression = TWO_STAGE_COMP;
 
+  switch (tsdb.config.precision) {
+    case TSDB_TIME_PRECISION_MILLI:
+      skey1 *= 1e3;
+      break;
+    case TSDB_TIME_PRECISION_MICRO:
+      skey1 *= 1e6;
+      break;
+    case TSDB_TIME_PRECISION_NANO:
+      skey1 *= 1e9;
+      break;
+    default:  // ms
+      skey1 *= 1e3;
+      break;
+  }
+
   char *msg = (char *)calloc(100, 1);
   EXPECT_EQ(tsdbUpdateSmaWindow(&tsdb, TSDB_SMA_TYPE_TIME_RANGE, msg), 0);
 
@@ -286,21 +307,21 @@ TEST(testCase, tSmaInsertTest) {
   void *  buf = NULL;
   EXPECT_EQ(tsdbMakeRoom(&buf, allocStep), 0);
   int32_t  bufSize = taosTSizeof(buf);
-  int32_t  numOfTables = 5;
-  col_id_t numOfCols = 10;
+  int32_t  numOfTables = 10;
+  col_id_t numOfCols = 4096;
   EXPECT_GT(numOfCols, 0);
 
   pSmaData = (STSmaDataWrapper *)buf;
   printf(">> allocate [%d] time to %d and addr is %p\n", ++allocCnt, bufSize, pSmaData);
-  pSmaData->skey = 1646987196000;
-  pSmaData->interval = 10;
-  pSmaData->intervalUnit = TD_TIME_UNIT_MINUTE;
+  pSmaData->skey = skey1;
+  pSmaData->interval = interval1;
+  pSmaData->intervalUnit = intervalUnit1;
   pSmaData->indexUid = indexUid1;
 
   int32_t len = sizeof(STSmaDataWrapper);
   for (int32_t t = 0; t < numOfTables; ++t) {
     STSmaTbData *pTbData = (STSmaTbData *)POINTER_SHIFT(pSmaData, len);
-    pTbData->tableUid = t;
+    pTbData->tableUid = tbUid + t;
 
     int32_t tableDataLen = sizeof(STSmaTbData);
     for (col_id_t c = 0; c < numOfCols; ++c) {
@@ -313,8 +334,17 @@ TEST(testCase, tSmaInsertTest) {
       }
       STSmaColData *pColData = (STSmaColData *)POINTER_SHIFT(pSmaData, len + tableDataLen);
       pColData->colId = c + PRIMARYKEY_TIMESTAMP_COL_ID;
-      pColData->blockSize = ((c & 1) == 0) ? 8 : 16;
+
       // TODO: fill col data
+      if ((c & 1) == 0) {
+        pColData->blockSize = 8;
+        memcpy(pColData->data, &testSmaData1, 8);
+      } else {
+        pColData->blockSize = 16;
+        memcpy(pColData->data, &testSmaData1, 8);
+        memcpy(POINTER_SHIFT(pColData->data, 8), &testSmaData2, 8);
+      }
+
       tableDataLen += (sizeof(STSmaColData) + pColData->blockSize);
     }
     pTbData->dataLen = (tableDataLen - sizeof(STSmaTbData));
@@ -328,6 +358,19 @@ TEST(testCase, tSmaInsertTest) {
   // execute
   EXPECT_EQ(tsdbInsertTSmaData(&tsdb, (char *)pSmaData), TSDB_CODE_SUCCESS);
 
+  // step 3: query
+  uint32_t checkDataCnt = 0;
+  for (int32_t t = 0; t < numOfTables; ++t) {
+    for (col_id_t c = 0; c < numOfCols; ++c) {
+      EXPECT_EQ(tsdbGetTSmaData(&tsdb, NULL, indexUid1, interval1, intervalUnit1, tbUid + t,
+                                c + PRIMARYKEY_TIMESTAMP_COL_ID, skey1, 1),
+                TSDB_CODE_SUCCESS);
+      ++checkDataCnt;
+    }
+  }
+  
+  printf("%s:%d The sma data check count for insert and query is %" PRIu32 "\n", __FILE__, __LINE__, checkDataCnt);
+
   // release data
   taosTZfree(buf);
   // release meta

From 7d070abbe6a1448a70e86286a6497e9673b5e5a7 Mon Sep 17 00:00:00 2001
From: Cary Xu <klxu@taosdata.com>
Date: Mon, 14 Mar 2022 17:43:25 +0800
Subject: [PATCH 14/16] resource release

---
 source/dnode/vnode/src/tsdb/tsdbSma.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/source/dnode/vnode/src/tsdb/tsdbSma.c b/source/dnode/vnode/src/tsdb/tsdbSma.c
index 0dbcb29f80..7335e4f585 100644
--- a/source/dnode/vnode/src/tsdb/tsdbSma.c
+++ b/source/dnode/vnode/src/tsdb/tsdbSma.c
@@ -848,6 +848,7 @@ static int32_t tsdbGetTSmaDataImpl(STsdb *pTsdb, STSmaDataWrapper *pData, int64_
     tsdbCloseDBF(&tReadH.dFile);
     return TSDB_CODE_FAILED;
   }
+  tfree(result);
 #ifdef SMA_PRINT_DEBUG_LOG
   for (uint32_t v = 0; v < valueSize; v += 8) {
     tsdbWarn("vgId:%d v[%d]=%" PRIi64, REPO_ID(pTsdb), v, *(int64_t *)POINTER_SHIFT(result, v));

From 9aa0a8444897dd0eace2c41e2f19e7a37189b8da Mon Sep 17 00:00:00 2001
From: plum-lihui <huili@taosdata.com>
Date: Mon, 14 Mar 2022 18:43:40 +0800
Subject: [PATCH 15/16] [add db options]

---
 tests/script/tsim/db/basic6.sim | 25 +++++++++++++++++++------
 1 file changed, 19 insertions(+), 6 deletions(-)

diff --git a/tests/script/tsim/db/basic6.sim b/tests/script/tsim/db/basic6.sim
index eb12da2ccb..08ce9955b8 100644
--- a/tests/script/tsim/db/basic6.sim
+++ b/tests/script/tsim/db/basic6.sim
@@ -14,13 +14,19 @@ $st = $stPrefix . $i
 $tb = $tbPrefix . $i
 
 print =============== step1
-sql create database $db replica 1 days 20 keep 2000 cache 16 vgroups 4
+# quorum  presicion 
+sql create database $db vgroups 8 replica 1 days 20 keep 3650 cache 32 blocks 12 minrows 80 maxrows 10000 wal 2 fsync 1000 comp 0 cachelast 2 precision 'us'
 sql show databases
-print $data00 $data01 $data02 $data03 $data04 $data05 $data06 $data07
+print $data0_1  $data1_1  $data2_1  $data3_1  $data4_1 $data5_1  $data6_1  $data7_1  $data8_1  $data9_1
+print $data00 $data01 $data02 $data03 $data04 $data05 $data06 $data07 $data08 $data09
+
+if $rows != 1 then 
+  return -1
+endi
 if $data00 != $db then 
   return -1
 endi
-if $data02 != 4 then 
+if $data02 != 8 then 
   return -1
 endi
 if $data03 != 0 then 
@@ -32,16 +38,23 @@ endi
 if $data06 != 20 then 
   return -1
 endi
-if $data08 != 16 then 
+if $data07 != 3650,3650,3650 then 
+  return -1
+endi
+if $data08 != 32 then 
+  return -1
+endi
+if $data09 != 12 then 
   return -1
 endi
  
 print =============== step2
-sql create database $db
+sql_error create database $db
+sql create database if not exists $db
 sql show databases
 if $rows != 1 then 
   return -1
-endi 
+endi
 
 print =============== step3
 sql drop database $db

From 5c7b09f7068f7b3dc3be50f681b2c86e3616ce82 Mon Sep 17 00:00:00 2001
From: plum-lihui <huili@taosdata.com>
Date: Mon, 14 Mar 2022 19:14:37 +0800
Subject: [PATCH 16/16] [add normal table case]

---
 tests/script/tsim/table/basic1.sim | 71 ++++++++++++++++++++++++++++--
 1 file changed, 67 insertions(+), 4 deletions(-)

diff --git a/tests/script/tsim/table/basic1.sim b/tests/script/tsim/table/basic1.sim
index 9e94c3a311..09e6ede77d 100644
--- a/tests/script/tsim/table/basic1.sim
+++ b/tests/script/tsim/table/basic1.sim
@@ -61,10 +61,50 @@ if $rows != 7 then
 endi
 
 print $data00 $data01 $data02
-print $data10 $data11 $data22
-print $data20 $data11 $data22
+print $data10 $data11 $data12
+print $data20 $data21 $data22
+
+print =============== create normal table
+sql create database ndb
+sql use ndb
+sql create table nt0 (ts timestamp, i int)
+sql create table if not exists nt0 (ts timestamp, i int)
+sql create table nt1 (ts timestamp, i int)
+sql create table if not exists nt1 (ts timestamp, i int)
+sql create table if not exists nt3 (ts timestamp, i int)
+
+sql show tables
+if $rows != 3 then 
+  return -1
+endi
+
+sql insert into nt0 values(now+1s, 1)(now+2s, 2)(now+3s, 3)
+sql insert into nt1 values(now+1s, 1)(now+2s, 2)(now+3s, 3)
+
+sql select * from nt1
+if $rows != 3 then 
+  return -1
+endi
+
+print $data00 $data01
+print $data10 $data11
+print $data20 $data21
+
+if $data01 != 1 then 
+  return -1
+endi
+
+if $data11 != 2 then 
+  return -1
+endi
+
+if $data21 != 3 then 
+  return -1
+endi
+
 
 print =============== insert data
+sql use d1
 sql insert into c1 values(now+1s, 1)
 sql insert into c1 values(now+2s, 2)
 sql insert into c1 values(now+3s, 3)
@@ -95,7 +135,7 @@ endi
 
 print $data00 $data01
 print $data10 $data11
-print $data20 $data11
+print $data20 $data21
 
 if $data01 != 1 then 
   return -1
@@ -160,7 +200,7 @@ endi
 
 print $data00 $data01
 print $data10 $data11
-print $data20 $data11
+print $data20 $data21
 
 if $data01 != 1 then 
   return -1
@@ -210,4 +250,27 @@ if $rows != 21 then
   return -1
 endi
 
+print =============== query data from normal table after restart dnode
+sql use ndb
+sql select * from nt1
+if $rows != 3 then 
+  return -1
+endi
+
+print $data00 $data01
+print $data10 $data11
+print $data20 $data21
+
+if $data01 != 1 then 
+  return -1
+endi
+
+if $data11 != 2 then 
+  return -1
+endi
+
+if $data21 != 3 then 
+  return -1
+endi
+
 system sh/exec.sh -n dnode1 -s stop -x SIGINT