Merge remote-tracking branch 'origin/3.0' into feature/3.0_wxy

example/src/tmq.c

@@ -14,7 +14,9 @@
  */
 
 #include <assert.h>
+#include <signal.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include "taos.h"
@@ -24,7 +26,7 @@ static void msg_process(TAOS_RES* msg) {
   char buf[1024];
   memset(buf, 0, 1024);
   printf("topic: %s\n", tmq_get_topic_name(msg));
-  printf("vg:%d\n", tmq_get_vgroup_id(msg));
+  printf("vg: %d\n", tmq_get_vgroup_id(msg));
   while (1) {
     TAOS_ROW row = taos_fetch_row(msg);
     if (row == NULL) break;
@@ -141,7 +143,7 @@ int32_t create_topic() {
 }
 
 void tmq_commit_cb_print(tmq_t* tmq, tmq_resp_err_t resp, tmq_topic_vgroup_list_t* offsets, void* param) {
-  printf("commit %d\n", resp);
+  printf("commit %d tmq %p offsets %p param %p\n", resp, tmq, offsets, param);
 }
 
 tmq_t* build_consumer() {
@@ -232,6 +234,7 @@ void sync_consume_loop(tmq_t* tmq, tmq_list_t* topics) {
       msg_process(tmqmessage);
       taos_free_result(tmqmessage);
 
+      tmq_commit(tmq, NULL, 1);
       /*if ((++msg_count % MIN_COMMIT_COUNT) == 0) tmq_commit(tmq, NULL, 0);*/
     }
   }

include/common/taosdef.h

@@ -71,13 +71,19 @@ typedef enum {
   TSDB_SMA_STAT_DROPPED = 2,   // sma dropped
 } ETsdbSmaStat;                // bit operation
 
-
 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;
 
+typedef enum {
+  TSDB_RSMA_RETENTION_0 = 0,
+  TSDB_RSMA_RETENTION_1 = 1,
+  TSDB_RSMA_RETENTION_2 = 2,
+  TSDB_RSMA_RETENTION_MAX = 3
+} ERSmaRetention;
+
 extern char *qtypeStr[];
 
 #define TSDB_PORT_HTTP      11

include/common/tmsg.h

@@ -1524,6 +1524,7 @@ typedef struct {
 int32_t tEncodeSRSmaParam(SCoder* pCoder, const SRSmaParam* pRSmaParam);
 int32_t tDecodeSRSmaParam(SCoder* pCoder, SRSmaParam* pRSmaParam);
 
+// TDMT_VND_CREATE_STB ==============
 typedef struct SVCreateStbReq {
   const char*    name;
   tb_uid_t       suid;
@@ -1536,17 +1537,14 @@ typedef struct SVCreateStbReq {
 int tEncodeSVCreateStbReq(SCoder* pCoder, const SVCreateStbReq* pReq);
 int tDecodeSVCreateStbReq(SCoder* pCoder, SVCreateStbReq* pReq);
 
+// TDMT_VND_DROP_STB ==============
 typedef struct SVDropStbReq {
-  // data
+  const char* name;
-#ifdef WINDOWS
+  tb_uid_t    suid;
-  size_t avoidCompilationErrors;
-#endif
-
 } SVDropStbReq;
 
-typedef struct SVCreateStbRsp {
+int32_t tEncodeSVDropStbReq(SCoder* pCoder, const SVDropStbReq* pReq);
-  int code;
+int32_t tDecodeSVDropStbReq(SCoder* pCoder, SVDropStbReq* pReq);
-} SVCreateStbRsp;
 
 typedef struct SVCreateTbReq {
   tb_uid_t    uid;
@@ -1603,19 +1601,37 @@ int tDecodeSVCreateTbBatchRsp(SCoder* pCoder, SVCreateTbBatchRsp* pRsp);
 int32_t tSerializeSVCreateTbBatchRsp(void* buf, int32_t bufLen, SVCreateTbBatchRsp* pRsp);
 int32_t tDeserializeSVCreateTbBatchRsp(void* buf, int32_t bufLen, SVCreateTbBatchRsp* pRsp);
 
+// TDMT_VND_DROP_TABLE =================
 typedef struct {
-  int64_t  ver;
+  const char* name;
-  char*    name;
+  int8_t      igNotExists;
-  uint8_t  type;
-  tb_uid_t suid;
 } SVDropTbReq;
 
 typedef struct {
-  int tmp;  // TODO: to avoid compile error
+  int32_t code;
 } SVDropTbRsp;
 
-int32_t tSerializeSVDropTbReq(void** buf, SVDropTbReq* pReq);
+typedef struct {
-void*   tDeserializeSVDropTbReq(void* buf, SVDropTbReq* pReq);
+  int32_t nReqs;
+  union {
+    SVDropTbReq* pReqs;
+    SArray*      pArray;
+  };
+} SVDropTbBatchReq;
+
+int32_t tEncodeSVDropTbBatchReq(SCoder* pCoder, const SVDropTbBatchReq* pReq);
+int32_t tDecodeSVDropTbBatchReq(SCoder* pCoder, SVDropTbBatchReq* pReq);
+
+typedef struct {
+  int32_t nRsps;
+  union {
+    SVDropTbRsp* pRsps;
+    SArray*      pArray;
+  };
+} SVDropTbBatchRsp;
+
+int32_t tEncodeSVDropTbBatchRsp(SCoder* pCoder, const SVDropTbBatchRsp* pRsp);
+int32_t tDecodeSVDropTbBatchRsp(SCoder* pCoder, SVDropTbBatchRsp* pRsp);
 
 typedef struct {
   SMsgHead head;

include/common/tmsgdef.h

@@ -170,9 +170,9 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_VND_UPDATE_TAG_VAL, "vnode-update-tag-val", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_TABLE_META, "vnode-table-meta", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_TABLES_META, "vnode-tables-meta", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_VND_CREATE_STB, "vnode-create-stb", SVCreateTbReq, SVCreateTbRsp)
+  TD_DEF_MSG_TYPE(TDMT_VND_CREATE_STB, "vnode-create-stb", SVCreateStbReq, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_ALTER_STB, "vnode-alter-stb", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_VND_DROP_STB, "vnode-drop-stb", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_DROP_STB, "vnode-drop-stb", SVDropStbReq, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_MQ_CONSUME, "vnode-mq-consume", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_MQ_QUERY, "vnode-mq-query", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_MQ_CONNECT, "vnode-mq-connect", NULL, NULL)

include/dnode/mnode/sdb/sdb.h

@@ -107,10 +107,9 @@ typedef enum {
 typedef enum {
   SDB_STATUS_INIT = 0,
   SDB_STATUS_CREATING = 1,
-  SDB_STATUS_UPDATING = 2,
+  SDB_STATUS_DROPPING = 2,
-  SDB_STATUS_DROPPING = 3,
+  SDB_STATUS_DROPPED = 3,
   SDB_STATUS_READY = 4,
-  SDB_STATUS_DROPPED = 5
 } ESdbStatus;
 
 typedef enum {

include/libs/nodes/querynodes.h

@@ -88,6 +88,7 @@ typedef struct SValueNode {
     double   d;
     char*    p;
   } datum;
+  int64_t typeData;
   char unit;
 } SValueNode;
 
@@ -314,6 +315,7 @@ bool nodesIsTimeorderQuery(const SNode* pQuery);
 bool nodesIsTimelineQuery(const SNode* pQuery);
 
 void* nodesGetValueFromNode(SValueNode* pNode);
+int32_t nodesSetValueNodeValue(SValueNode* pNode, void *value);
 char* nodesGetStrValueFromNode(SValueNode* pNode);
 char* getFillModeString(EFillMode mode);
 void  valueNodeToVariant(const SValueNode* pNode, SVariant* pVal);

include/util/taoserror.h

@@ -87,6 +87,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_MSG_NOT_PROCESSED             TAOS_DEF_ERROR_CODE(0, 0x0113)
 #define TSDB_CODE_CFG_NOT_FOUND                 TAOS_DEF_ERROR_CODE(0, 0x0114)
 #define TSDB_CODE_REPEAT_INIT                   TAOS_DEF_ERROR_CODE(0, 0x0115)
+#define TSDB_CODE_DUP_KEY                       TAOS_DEF_ERROR_CODE(0, 0x0116)
 
 #define TSDB_CODE_REF_NO_MEMORY                 TAOS_DEF_ERROR_CODE(0, 0x0140)
 #define TSDB_CODE_REF_FULL                      TAOS_DEF_ERROR_CODE(0, 0x0141)
@@ -318,6 +319,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_VND_TB_NOT_EXIST              TAOS_DEF_ERROR_CODE(0, 0x0515)
 #define TSDB_CODE_VND_SMA_NOT_EXIST             TAOS_DEF_ERROR_CODE(0, 0x0516)
 #define TSDB_CODE_VND_HASH_MISMATCH             TAOS_DEF_ERROR_CODE(0, 0x0517)
+#define TSDB_CODE_VND_TABLE_NOT_EXIST           TAOS_DEF_ERROR_CODE(0, 0x0518)
 
 // tsdb
 #define TSDB_CODE_TDB_INVALID_TABLE_ID          TAOS_DEF_ERROR_CODE(0, 0x0600)
@@ -616,6 +618,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_OFFSET_LESS_ZERO          TAOS_DEF_ERROR_CODE(0, 0x2637)
 #define TSDB_CODE_PAR_SLIMIT_LEAK_PARTITION_BY  TAOS_DEF_ERROR_CODE(0, 0x2638)
 #define TSDB_CODE_PAR_INVALID_TOPIC_QUERY       TAOS_DEF_ERROR_CODE(0, 0x2639)
+#define TSDB_CODE_PAR_INVALID_DROP_STABLE       TAOS_DEF_ERROR_CODE(0, 0x263A)
 
 //planner
 #define TSDB_CODE_PLAN_INTERNAL_ERROR           TAOS_DEF_ERROR_CODE(0, 0x2700)

include/util/tencode.h

@@ -79,17 +79,6 @@ typedef struct {
 #define TD_CODER_CURRENT(CODER)                        ((CODER)->data + (CODER)->pos)
 #define TD_CODER_MOVE_POS(CODER, MOVE)                 ((CODER)->pos += (MOVE))
 #define TD_CODER_CHECK_CAPACITY_FAILED(CODER, EXPSIZE) (((CODER)->size - (CODER)->pos) < (EXPSIZE))
-// #define TCODER_MALLOC(PCODER, SIZE)                                         \
-//   ({                                                                        \
-//     void*      ptr = NULL;                                                  \
-//     SCoderMem* pMem = (SCoderMem*)taosMemoryMalloc(sizeof(*pMem) + (SIZE)); \
-//     if (pMem) {                                                             \
-//       pMem->next = (PCODER)->mList;                                         \
-//       (PCODER)->mList = pMem;                                               \
-//       ptr = (void*)&pMem[1];                                                \
-//     }                                                                       \
-//     ptr;                                                                    \
-//   })
 static FORCE_INLINE void* tCoderMalloc(SCoder* pCoder, int32_t size) {
   void*      ptr = NULL;
   SCoderMem* pMem = (SCoderMem*)taosMemoryMalloc(sizeof(SCoderMem*) + size);
@@ -102,8 +91,9 @@ static FORCE_INLINE void* tCoderMalloc(SCoder* pCoder, int32_t size) {
 }
 
 #define tEncodeSize(E, S, SIZE, RET)                           \
-  do{                                                          \
+  do {                                                         \
     SCoder coder = {0};                                        \
+    RET = 0;                                                   \
     tCoderInit(&coder, TD_LITTLE_ENDIAN, NULL, 0, TD_ENCODER); \
     if ((E)(&coder, S) == 0) {                                 \
       SIZE = coder.pos;                                        \
@@ -111,7 +101,7 @@ static FORCE_INLINE void* tCoderMalloc(SCoder* pCoder, int32_t size) {
       RET = -1;                                                \
     }                                                          \
     tCoderClear(&coder);                                       \
-  }while(0)
+  } while (0)
 // #define tEncodeSize(E, S, SIZE)                                \
 //   ({                                                           \
 //     SCoder coder = {0};                                        \

include/util/tskiplist.h

@@ -52,72 +52,21 @@ typedef struct SSkipListNode {
 #define SL_NODE_GET_FORWARD_POINTER(n, l)  (n)->forwards[(l)]
 #define SL_NODE_GET_BACKWARD_POINTER(n, l) (n)->forwards[(n)->level + (l)]
 
-/*
- * @version 0.3
- * @date   2017/11/12
- * the simple version of skip list.
- *
- * for multi-thread safe purpose, we employ TdThreadRwlock to guarantee to generate
- * deterministic result. Later, we will remove the lock in SkipList to further enhance the performance.
- * In this case, one should use the concurrent skip list (by using michael-scott algorithm) instead of
- * this simple version in a multi-thread environment, to achieve higher performance of read/write operations.
- *
- * Note: Duplicated primary key situation.
- * In case of duplicated primary key, two ways can be employed to handle this situation:
- * 1. add as normal insertion without special process.
- * 2. add an overflow pointer at each list node, all nodes with the same key will be added in the overflow pointer.
- *    In this case, the total steps of each search will be reduced significantly.
- *    Currently, we implement the skip list in a line with the first means, maybe refactor it soon.
- *
- *    Memory consumption: the memory alignment causes many memory wasted. So, employ a memory
- *    pool will significantly reduce the total memory consumption, as well as the calloc/malloc operation costs.
- *
- */
-
-// state struct, record following information:
-// number of links in each level.
-// avg search steps, for latest 1000 queries
-// avg search rsp time, for latest 1000 queries
-// total memory size
-typedef struct tSkipListState {
-  // in bytes, sizeof(SSkipList)+sizeof(SSkipListNode)*SSkipList->nSize
-  uint64_t nTotalMemSize;
-  uint64_t nLevelNodeCnt[MAX_SKIP_LIST_LEVEL];
-  uint64_t queryCount;  // total query count
-
-  /*
-   * only record latest 1000 queries
-   * when the value==1000, = 0,
-   * nTotalStepsForQueries = 0,
-   * nTotalElapsedTimeForQueries = 0
-   */
-  uint64_t nRecQueries;
-  uint16_t nTotalStepsForQueries;
-  uint64_t nTotalElapsedTimeForQueries;
-
-  uint16_t nInsertObjs;
-  uint16_t nTotalStepsForInsert;
-  uint64_t nTotalElapsedTimeForInsert;
-} tSkipListState;
-
 typedef enum { SSkipListPutSuccess = 0, SSkipListPutEarlyStop = 1, SSkipListPutSkipOne = 2 } SSkipListPutStatus;
 
 typedef struct SSkipList {
-  uint32_t          seed;
+  uint32_t           seed;
-  __compar_fn_t     comparFn;
+  __compar_fn_t      comparFn;
-  __sl_key_fn_t     keyFn;
+  __sl_key_fn_t      keyFn;
-  TdThreadRwlock *lock;
+  TdThreadRwlock    *lock;
-  uint16_t          len;
+  uint16_t           len;
-  uint8_t           maxLevel;
+  uint8_t            maxLevel;
-  uint8_t           flags;
+  uint8_t            flags;
-  uint8_t           type;  // static info above
+  uint8_t            type;  // static info above
-  uint8_t           level;
+  uint8_t            level;
-  uint32_t          size;
+  uint32_t           size;
-  SSkipListNode    *pHead;  // point to the first element
+  SSkipListNode     *pHead;  // point to the first element
-  SSkipListNode    *pTail;  // point to the last element
+  SSkipListNode     *pTail;  // point to the last element
-#if SKIP_LIST_RECORD_PERFORMANCE
-  tSkipListState state;  // skiplist state
-#endif
   tGenericSavedFunc *insertHandleFn;
 } SSkipList;
 

source/client/inc/clientStmt.h

@@ -46,11 +46,12 @@ typedef struct SStmtTableCache {
   void*             boundTags;
 } SStmtTableCache;
 
-typedef struct SQueryFields {
+typedef struct SStmtQueryResInfo {
   TAOS_FIELD*    fields;
   TAOS_FIELD*    userFields;
   uint32_t       numOfCols;
-} SQueryFields;
+  int32_t        precision;
+} SStmtQueryResInfo;
 
 typedef struct SStmtBindInfo {
   bool         needParse;
@@ -72,17 +73,17 @@ typedef struct SStmtExecInfo {
 } SStmtExecInfo;
 
 typedef struct SStmtSQLInfo {
-  STMT_TYPE     type;
+  STMT_TYPE         type;
-  STMT_STATUS   status;
+  STMT_STATUS       status;
-  bool          autoCreate;
+  bool              autoCreate;
-  uint64_t      runTimes;
+  uint64_t          runTimes;
-  SHashObj*     pTableCache;   //SHash<SStmtTableCache>
+  SHashObj*         pTableCache;   //SHash<SStmtTableCache>
-  SQuery*       pQuery;
+  SQuery*           pQuery;
-  char*         sqlStr;
+  char*             sqlStr;
-  int32_t       sqlLen;
+  int32_t           sqlLen;
-  SArray*       nodeList;
+  SArray*           nodeList;
-  SQueryPlan*   pQueryPlan;
+  SQueryPlan*       pQueryPlan;
-  SQueryFields  fields;
+  SStmtQueryResInfo queryRes;
 } SStmtSQLInfo;
 
 typedef struct STscStmt {

source/client/src/clientStmt.c

@@ -74,17 +74,44 @@ int32_t stmtGetTbName(TAOS_STMT *stmt, char **tbName) {
 }
 
 int32_t stmtBackupQueryFields(STscStmt* pStmt) {
-  SQueryFields *pFields = &pStmt->sql.fields;
+  SStmtQueryResInfo *pRes = &pStmt->sql.queryRes;
-  int32_t size = pFields->numOfCols * sizeof(TAOS_FIELD);
+  pRes->numOfCols = pStmt->exec.pRequest->body.resInfo.numOfCols;
+  pRes->precision = pStmt->exec.pRequest->body.resInfo.precision;
   
-  pFields->numOfCols = pStmt->exec.pRequest->body.resInfo.numOfCols;
+  int32_t size = pRes->numOfCols * sizeof(TAOS_FIELD);
-  pFields->fields = taosMemoryMalloc(size);
+  pRes->fields = taosMemoryMalloc(size);
-  pFields->userFields = taosMemoryMalloc(size);
+  pRes->userFields = taosMemoryMalloc(size);
-  if (NULL == pFields->fields || NULL == pFields->userFields) {
+  if (NULL == pRes->fields || NULL == pRes->userFields) {
     STMT_ERR_RET(TSDB_CODE_TSC_OUT_OF_MEMORY);
   }
-  memcpy(pFields->fields, pStmt->exec.pRequest->body.resInfo.fields, size);
+  memcpy(pRes->fields, pStmt->exec.pRequest->body.resInfo.fields, size);
-  memcpy(pFields->userFields, pStmt->exec.pRequest->body.resInfo.userFields, size);
+  memcpy(pRes->userFields, pStmt->exec.pRequest->body.resInfo.userFields, size);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t stmtRestoreQueryFields(STscStmt* pStmt) {
+  SStmtQueryResInfo *pRes = &pStmt->sql.queryRes;
+  int32_t size = pRes->numOfCols * sizeof(TAOS_FIELD);
+  
+  pStmt->exec.pRequest->body.resInfo.numOfCols = pRes->numOfCols;
+  pStmt->exec.pRequest->body.resInfo.precision = pRes->precision;
+
+  if (NULL == pStmt->exec.pRequest->body.resInfo.fields) {
+    pStmt->exec.pRequest->body.resInfo.fields = taosMemoryMalloc(size);
+    if (NULL == pStmt->exec.pRequest->body.resInfo.fields) {
+      STMT_ERR_RET(TSDB_CODE_TSC_OUT_OF_MEMORY);
+    }
+    memcpy(pStmt->exec.pRequest->body.resInfo.fields, pRes->fields, size);
+  }
+
+  if (NULL == pStmt->exec.pRequest->body.resInfo.userFields) {
+    pStmt->exec.pRequest->body.resInfo.userFields = taosMemoryMalloc(size);
+    if (NULL == pStmt->exec.pRequest->body.resInfo.userFields) {
+      STMT_ERR_RET(TSDB_CODE_TSC_OUT_OF_MEMORY);
+    }
+    memcpy(pStmt->exec.pRequest->body.resInfo.userFields, pRes->userFields, size);
+  }
 
   return TSDB_CODE_SUCCESS;
 }
@@ -235,6 +262,8 @@ int32_t stmtCleanExecInfo(STscStmt* pStmt, bool keepTable, bool freeRequest) {
 }
 
 int32_t stmtCleanSQLInfo(STscStmt* pStmt) {
+  taosMemoryFree(pStmt->sql.queryRes.fields);
+  taosMemoryFree(pStmt->sql.queryRes.userFields);
   taosMemoryFree(pStmt->sql.sqlStr);
   qDestroyQuery(pStmt->sql.pQuery);
   qDestroyQueryPlan(pStmt->sql.pQueryPlan);
@@ -497,6 +526,8 @@ int stmtBindBatch(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind, int32_t colIdx) {
       pStmt->sql.pQueryPlan = pStmt->exec.pRequest->body.pDag;
       pStmt->exec.pRequest->body.pDag = NULL;
       STMT_ERR_RET(stmtBackupQueryFields(pStmt));
+    } else {
+      STMT_ERR_RET(stmtRestoreQueryFields(pStmt));
     }
     
     STMT_RET(qStmtBindParam(pStmt->sql.pQueryPlan, bind, colIdx, pStmt->exec.pRequest->requestId));
@@ -509,7 +540,11 @@ int stmtBindBatch(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind, int32_t colIdx) {
   }
 
   if (colIdx < 0) {
-    qBindStmtColsValue(*pDataBlock, bind, pStmt->exec.pRequest->msgBuf, pStmt->exec.pRequest->msgBufLen);
+    int32_t code = qBindStmtColsValue(*pDataBlock, bind, pStmt->exec.pRequest->msgBuf, pStmt->exec.pRequest->msgBufLen);
+    if (code) {
+      tscError("qBindStmtColsValue failed, error:%s", tstrerror(code));
+      STMT_ERR_RET(code);
+    }
   } else {
     if (colIdx != (pStmt->bInfo.sBindLastIdx + 1) && colIdx != 0) {
       tscError("bind column index not in sequence");

source/client/src/tmq.c

@@ -377,7 +377,15 @@ int32_t tmqCommitCb(void* param, const SDataBuf* pMsg, int32_t code) {
   if (pParam->tmq->commitCb) {
     pParam->tmq->commitCb(pParam->tmq, pParam->rspErr, NULL, pParam->tmq->commitCbUserParam);
   }
-  if (!pParam->async) tsem_post(&pParam->rspSem);
+  if (!pParam->async)
+    tsem_post(&pParam->rspSem);
+  else {
+    tsem_destroy(&pParam->rspSem);
+    /*if (pParam->pArray) {*/
+    /*taosArrayDestroy(pParam->pArray);*/
+    /*}*/
+    taosMemoryFree(pParam);
+  }
   return 0;
 }
 
@@ -560,7 +568,7 @@ tmq_resp_err_t tmq_commit(tmq_t* tmq, const tmq_topic_vgroup_list_t* offsets, in
     tscError("failed to malloc request");
   }
 
-  SMqCommitCbParam* pParam = taosMemoryMalloc(sizeof(SMqCommitCbParam));
+  SMqCommitCbParam* pParam = taosMemoryCalloc(1, sizeof(SMqCommitCbParam));
   if (pParam == NULL) {
     return -1;
   }
@@ -575,6 +583,7 @@ tmq_resp_err_t tmq_commit(tmq_t* tmq, const tmq_topic_vgroup_list_t* offsets, in
   };
 
   SMsgSendInfo* sendInfo = buildMsgInfoImpl(pRequest);
+  sendInfo->requestObjRefId = 0;
   sendInfo->param = pParam;
   sendInfo->fp = tmqCommitCb;
   SEpSet epSet = getEpSet_s(&tmq->pTscObj->pAppInfo->mgmtEp);
@@ -585,13 +594,12 @@ tmq_resp_err_t tmq_commit(tmq_t* tmq, const tmq_topic_vgroup_list_t* offsets, in
   if (!async) {
     tsem_wait(&pParam->rspSem);
     resp = pParam->rspErr;
-  }
+    tsem_destroy(&pParam->rspSem);
+    taosMemoryFree(pParam);
 
-  tsem_destroy(&pParam->rspSem);
+    if (pArray) {
-  taosMemoryFree(pParam);
+      taosArrayDestroy(pArray);
-
+    }
-  if (pArray) {
-    taosArrayDestroy(pArray);
   }
 
   return resp;
@@ -1313,7 +1321,7 @@ const char* tmq_err2str(tmq_resp_err_t err) {
 const char* tmq_get_topic_name(TAOS_RES* res) {
   if (TD_RES_TMQ(res)) {
     SMqRspObj* pRspObj = (SMqRspObj*)res;
-    return pRspObj->topic;
+    return strchr(pRspObj->topic, '.') + 1;
   } else {
     return NULL;
   }

source/common/src/tmsg.c

@@ -490,21 +490,6 @@ int32_t tDeserializeSClientHbBatchRsp(void *buf, int32_t bufLen, SClientHbBatchR
   return 0;
 }
 
-int32_t tSerializeSVDropTbReq(void **buf, SVDropTbReq *pReq) {
-  int32_t tlen = 0;
-  tlen += taosEncodeFixedI64(buf, pReq->ver);
-  tlen += taosEncodeString(buf, pReq->name);
-  tlen += taosEncodeFixedU8(buf, pReq->type);
-  return tlen;
-}
-
-void *tDeserializeSVDropTbReq(void *buf, SVDropTbReq *pReq) {
-  buf = taosDecodeFixedI64(buf, &pReq->ver);
-  buf = taosDecodeString(buf, &pReq->name);
-  buf = taosDecodeFixedU8(buf, &pReq->type);
-  return buf;
-}
-
 int32_t tSerializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pReq) {
   SCoder encoder = {0};
   tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
@@ -3811,3 +3796,119 @@ int tDecodeSVCreateTbRsp(SCoder *pCoder, SVCreateTbRsp *pRsp) {
   tEndDecode(pCoder);
   return 0;
 }
+
+// TDMT_VND_DROP_TABLE =================
+static int32_t tEncodeSVDropTbReq(SCoder *pCoder, const SVDropTbReq *pReq) {
+  if (tStartEncode(pCoder) < 0) return -1;
+
+  if (tEncodeCStr(pCoder, pReq->name) < 0) return -1;
+  if (tEncodeI8(pCoder, pReq->igNotExists) < 0) return -1;
+
+  tEndEncode(pCoder);
+  return 0;
+}
+
+static int32_t tDecodeSVDropTbReq(SCoder *pCoder, SVDropTbReq *pReq) {
+  if (tStartDecode(pCoder) < 0) return -1;
+
+  if (tDecodeCStr(pCoder, &pReq->name) < 0) return -1;
+  if (tDecodeI8(pCoder, &pReq->igNotExists) < 0) return -1;
+
+  tEndDecode(pCoder);
+  return 0;
+}
+
+static int32_t tEncodeSVDropTbRsp(SCoder *pCoder, const SVDropTbRsp *pReq) {
+  if (tStartEncode(pCoder) < 0) return -1;
+
+  if (tEncodeI32(pCoder, pReq->code) < 0) return -1;
+
+  tEndEncode(pCoder);
+  return 0;
+}
+
+static int32_t tDecodeSVDropTbRsp(SCoder *pCoder, SVDropTbRsp *pReq) {
+  if (tStartDecode(pCoder) < 0) return -1;
+
+  if (tDecodeI32(pCoder, &pReq->code) < 0) return -1;
+
+  tEndDecode(pCoder);
+  return 0;
+}
+
+int32_t tEncodeSVDropTbBatchReq(SCoder *pCoder, const SVDropTbBatchReq *pReq) {
+  int32_t      nReqs = taosArrayGetSize(pReq->pArray);
+  SVDropTbReq *pDropTbReq;
+
+  if (tStartEncode(pCoder) < 0) return -1;
+
+  if (tEncodeI32v(pCoder, nReqs) < 0) return -1;
+  for (int iReq = 0; iReq < nReqs; iReq++) {
+    pDropTbReq = (SVDropTbReq *)taosArrayGet(pReq->pArray, iReq);
+    if (tEncodeSVDropTbReq(pCoder, pDropTbReq) < 0) return -1;
+  }
+
+  tEndEncode(pCoder);
+  return 0;
+}
+
+int32_t tDecodeSVDropTbBatchReq(SCoder *pCoder, SVDropTbBatchReq *pReq) {
+  if (tStartDecode(pCoder) < 0) return -1;
+
+  if (tDecodeI32v(pCoder, &pReq->nReqs) < 0) return -1;
+  pReq->pReqs = (SVDropTbReq *)tCoderMalloc(pCoder, sizeof(SVDropTbReq) * pReq->nReqs);
+  if (pReq->pReqs == NULL) return -1;
+  for (int iReq = 0; iReq < pReq->nReqs; iReq++) {
+    if (tDecodeSVDropTbReq(pCoder, pReq->pReqs + iReq) < 0) return -1;
+  }
+
+  tEndDecode(pCoder);
+  return 0;
+}
+
+int32_t tEncodeSVDropTbBatchRsp(SCoder *pCoder, const SVDropTbBatchRsp *pRsp) {
+  int32_t nRsps = taosArrayGetSize(pRsp->pArray);
+  if (tStartEncode(pCoder) < 0) return -1;
+
+  if (tEncodeI32v(pCoder, nRsps) < 0) return -1;
+  for (int iRsp = 0; iRsp < nRsps; iRsp++) {
+    if (tEncodeSVDropTbRsp(pCoder, (SVDropTbRsp *)taosArrayGet(pRsp->pArray, iRsp)) < 0) return -1;
+  }
+
+  tEndEncode(pCoder);
+  return 0;
+}
+
+int32_t tDecodeSVDropTbBatchRsp(SCoder *pCoder, SVDropTbBatchRsp *pRsp) {
+  if (tStartDecode(pCoder) < 0) return -1;
+
+  if (tDecodeI32v(pCoder, &pRsp->nRsps) < 0) return -1;
+  pRsp->pRsps = (SVDropTbRsp *)tCoderMalloc(pCoder, sizeof(SVDropTbRsp) * pRsp->nRsps);
+  if (pRsp->pRsps == NULL) return -1;
+  for (int iRsp = 0; iRsp < pRsp->nRsps; iRsp++) {
+    if (tDecodeSVDropTbRsp(pCoder, pRsp->pRsps + iRsp) < 0) return -1;
+  }
+
+  tEndDecode(pCoder);
+  return 0;
+}
+
+int32_t tEncodeSVDropStbReq(SCoder *pCoder, const SVDropStbReq *pReq) {
+  if (tStartEncode(pCoder) < 0) return -1;
+
+  if (tEncodeCStr(pCoder, pReq->name) < 0) return -1;
+  if (tEncodeI64(pCoder, pReq->suid) < 0) return -1;
+
+  tEndEncode(pCoder);
+  return 0;
+}
+
+int32_t tDecodeSVDropStbReq(SCoder *pCoder, SVDropStbReq *pReq) {
+  if (tStartDecode(pCoder) < 0) return -1;
+
+  if (tDecodeCStr(pCoder, &pReq->name) < 0) return -1;
+  if (tDecodeI64(pCoder, &pReq->suid) < 0) return -1;
+
+  tEndDecode(pCoder);
+  return 0;
+}

source/dnode/mgmt/implement/src/dmTransport.c

@@ -72,6 +72,7 @@ static void dmProcessRpcMsg(SMgmtWrapper *pWrapper, SRpcMsg *pRpc, SEpSet *pEpSe
   NodeMsgFp msgFp = NULL;
   uint16_t  msgType = pRpc->msgType;
   bool      needRelease = false;
+  bool      isReq = msgType & 1U;
 
   if (pEpSet && pEpSet->numOfEps > 0 && msgType == TDMT_MND_STATUS_RSP) {
     dmSetMnodeEpSet(pWrapper->pDnode, pEpSet);
@@ -85,13 +86,13 @@ static void dmProcessRpcMsg(SMgmtWrapper *pWrapper, SRpcMsg *pRpc, SEpSet *pEpSe
   if (dmBuildMsg(pMsg, pRpc) != 0) goto _OVER;
 
   if (pWrapper->procType == DND_PROC_SINGLE) {
-    dTrace("msg:%p, is created, type:%s handle:%p user:%s", pMsg, TMSG_INFO(msgType), pRpc->handle, pMsg->user);
+    dTrace("msg:%p, created, type:%s handle:%p user:%s", pMsg, TMSG_INFO(msgType), pRpc->handle, pMsg->user);
     code = (*msgFp)(pWrapper, pMsg);
   } else if (pWrapper->procType == DND_PROC_PARENT) {
-    dTrace("msg:%p, is created and put into child queue, type:%s handle:%p user:%s", pMsg, TMSG_INFO(msgType),
+    dTrace("msg:%p, created and put into child queue, type:%s handle:%p code:0x%04x user:%s contLen:%d", pMsg,
-           pRpc->handle, pMsg->user);
+           TMSG_INFO(msgType), pRpc->handle, pMsg->rpcMsg.code & 0XFFFF, pMsg->user, pRpc->contLen);
-    code = taosProcPutToChildQ(pWrapper->procObj, pMsg, sizeof(SNodeMsg), pRpc->pCont, pRpc->contLen, pRpc->handle,
+    code = taosProcPutToChildQ(pWrapper->procObj, pMsg, sizeof(SNodeMsg), pRpc->pCont, pRpc->contLen,
-                               pRpc->refId, PROC_FUNC_REQ);
+                               (isReq && (pMsg->rpcMsg.code == 0)) ? pRpc->handle : NULL, pRpc->refId, PROC_FUNC_REQ);
   } else {
     dTrace("msg:%p, should not processed in child process, handle:%p user:%s", pMsg, pRpc->handle, pMsg->user);
     ASSERT(1);
@@ -100,12 +101,13 @@ static void dmProcessRpcMsg(SMgmtWrapper *pWrapper, SRpcMsg *pRpc, SEpSet *pEpSe
 _OVER:
   if (code == 0) {
     if (pWrapper->procType == DND_PROC_PARENT) {
-      dTrace("msg:%p, is freed in parent process", pMsg);
+      dTrace("msg:%p, freed in parent process", pMsg);
       taosFreeQitem(pMsg);
       rpcFreeCont(pRpc->pCont);
     }
   } else {
-    dError("msg:%p, type:%s failed to process since 0x%04x:%s", pMsg, TMSG_INFO(msgType), code & 0XFFFF, terrstr());
+    dError("msg:%p, type:%s handle:%p failed to process since 0x%04x:%s", pMsg, TMSG_INFO(msgType), pRpc->handle,
+           code & 0XFFFF, terrstr());
     if (msgType & 1U) {
       if (terrno != 0) code = terrno;
       if (code == TSDB_CODE_NODE_NOT_DEPLOYED || code == TSDB_CODE_NODE_OFFLINE) {
@@ -254,8 +256,17 @@ static void dmSendRpcRedirectRsp(SDnode *pDnode, const SRpcMsg *pReq) {
 
     epSet.eps[i].port = htons(epSet.eps[i].port);
   }
+  SRpcMsg resp;
+  SMEpSet msg = {.epSet = epSet};
+  int32_t len = tSerializeSMEpSet(NULL, 0, &msg);
+  resp.pCont = rpcMallocCont(len);
+  resp.contLen = len;
+  tSerializeSMEpSet(resp.pCont, len, &msg);
 
-  rpcSendRedirectRsp(pReq->handle, &epSet);
+  resp.code = TSDB_CODE_RPC_REDIRECT;
+  resp.handle = pReq->handle;
+  resp.refId = pReq->refId;
+  rpcSendResponse(&resp);
 }
 
 static inline void dmSendRpcRsp(SDnode *pDnode, const SRpcMsg *pRsp) {
@@ -350,29 +361,31 @@ static void dmConsumeChildQueue(SMgmtWrapper *pWrapper, SNodeMsg *pMsg, int16_t
 
 static void dmConsumeParentQueue(SMgmtWrapper *pWrapper, SRpcMsg *pMsg, int16_t msgLen, void *pCont, int32_t contLen,
                                  EProcFuncType ftype) {
+  int32_t code = pMsg->code & 0xFFFF;
   pMsg->pCont = pCont;
-  dTrace("msg:%p, get from parent queue, ftype:%d handle:%p code:0x%04x mtype:%d, app:%p", pMsg, ftype, pMsg->handle,
-         pMsg->code & 0xFFFF, pMsg->msgType, pMsg->ahandle);
 
-  switch (ftype) {
+  if (ftype == PROC_FUNC_REQ) {
-    case PROC_FUNC_REGIST:
+    dTrace("msg:%p, get from parent queue, send req:%s handle:%p code:0x%04x, app:%p", pMsg, TMSG_INFO(pMsg->msgType),
-      rpcRegisterBrokenLinkArg(pMsg);
+           pMsg->handle, code, pMsg->ahandle);
-      break;
+    dmSendRpcReq(pWrapper->pDnode, (SEpSet *)((char *)pMsg + sizeof(SRpcMsg)), pMsg);
-    case PROC_FUNC_RELEASE:
+  } else if (ftype == PROC_FUNC_RSP) {
-      taosProcRemoveHandle(pWrapper->procObj, pMsg->handle);
+    dTrace("msg:%p, get from parent queue, rsp handle:%p code:0x%04x, app:%p", pMsg, pMsg->handle, code, pMsg->ahandle);
-      rpcReleaseHandle(pMsg->handle, (int8_t)pMsg->code);
+    pMsg->refId = taosProcRemoveHandle(pWrapper->procObj, pMsg->handle);
-      rpcFreeCont(pCont);
+    dmSendRpcRsp(pWrapper->pDnode, pMsg);
-      break;
+  } else if (ftype == PROC_FUNC_REGIST) {
-    case PROC_FUNC_REQ:
+    dTrace("msg:%p, get from parent queue, regist handle:%p code:0x%04x, app:%p", pMsg, pMsg->handle, code,
-      dmSendRpcReq(pWrapper->pDnode, (SEpSet *)((char *)pMsg + sizeof(SRpcMsg)), pMsg);
+           pMsg->ahandle);
-      break;
+    rpcRegisterBrokenLinkArg(pMsg);
-    case PROC_FUNC_RSP:
+  } else if (ftype == PROC_FUNC_RELEASE) {
-      pMsg->refId = taosProcRemoveHandle(pWrapper->procObj, pMsg->handle);
+    dTrace("msg:%p, get from parent queue, release handle:%p code:0x%04x, app:%p", pMsg, pMsg->handle, code,
-      dmSendRpcRsp(pWrapper->pDnode, pMsg);
+           pMsg->ahandle);
-      break;
+    taosProcRemoveHandle(pWrapper->procObj, pMsg->handle);
-    default:
+    rpcReleaseHandle(pMsg->handle, (int8_t)pMsg->code);
-      break;
+    rpcFreeCont(pCont);
+  } else {
+    dError("msg:%p, invalid ftype:%d while get from parent queue, handle:%p", pMsg, ftype, pMsg->handle);
   }
+
   taosMemoryFree(pMsg);
 }
 

source/dnode/mgmt/mgmt_vnode/src/vmHandle.c

@@ -112,7 +112,9 @@ static void vmGenerateVnodeCfg(SCreateVnodeReq *pCreate, SVnodeCfg *pCfg) {
   pCfg->tsdbCfg.keep2 = 3650;
   pCfg->tsdbCfg.keep0 = 3650;
   pCfg->tsdbCfg.keep1 = 3650;
-  pCfg->tsdbCfg.retentions = pCreate->pRetensions;
+  for (size_t i = 0; i < taosArrayGetSize(pCreate->pRetensions); ++i) {
+    memcpy(&pCfg->tsdbCfg.retentions[i], taosArrayGet(pCreate->pRetensions, i), sizeof(SRetention));
+  }
   pCfg->walCfg.vgId = pCreate->vgId;
   pCfg->hashBegin = pCreate->hashBegin;
   pCfg->hashEnd = pCreate->hashEnd;

source/dnode/mgmt/mgmt_vnode/src/vmWorker.c

@@ -136,7 +136,7 @@ static void vmProcessWriteQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numO
   // sync integration response
   for (int i = 0; i < taosArrayGetSize(pArray); i++) {
     SNodeMsg *pMsg;
-    SRpcMsg * pRpc;
+    SRpcMsg  *pRpc;
 
     pMsg = *(SNodeMsg **)taosArrayGet(pArray, i);
     pRpc = &pMsg->rpcMsg;
@@ -175,7 +175,7 @@ static void vmProcessWriteQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numO
 
 static void vmProcessApplyQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numOfMsgs) {
   SVnodeObj *pVnode = pInfo->ahandle;
-  SNodeMsg * pMsg = NULL;
+  SNodeMsg  *pMsg = NULL;
   SRpcMsg    rsp;
 
   for (int32_t i = 0; i < numOfMsgs; ++i) {
@@ -218,7 +218,7 @@ static void vmProcessApplyQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numO
 
 static void vmProcessSyncQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numOfMsgs) {
   SVnodeObj *pVnode = pInfo->ahandle;
-  SNodeMsg * pMsg = NULL;
+  SNodeMsg  *pMsg = NULL;
 
   for (int32_t i = 0; i < numOfMsgs; ++i) {
     taosGetQitem(qall, (void **)&pMsg);
@@ -231,7 +231,7 @@ static void vmProcessSyncQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numOf
 
 static void vmProcessMergeQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numOfMsgs) {
   SVnodeObj *pVnode = pInfo->ahandle;
-  SNodeMsg * pMsg = NULL;
+  SNodeMsg  *pMsg = NULL;
 
   for (int32_t i = 0; i < numOfMsgs; ++i) {
     taosGetQitem(qall, (void **)&pMsg);
@@ -248,7 +248,7 @@ static void vmProcessMergeQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numO
 }
 
 static int32_t vmPutNodeMsgToQueue(SVnodesMgmt *pMgmt, SNodeMsg *pMsg, EQueueType qtype) {
-  SRpcMsg * pRpc = &pMsg->rpcMsg;
+  SRpcMsg  *pRpc = &pMsg->rpcMsg;
   SMsgHead *pHead = pRpc->pCont;
   pHead->contLen = ntohl(pHead->contLen);
   pHead->vgId = ntohl(pHead->vgId);
@@ -262,23 +262,23 @@ static int32_t vmPutNodeMsgToQueue(SVnodesMgmt *pMgmt, SNodeMsg *pMsg, EQueueTyp
   int32_t code = 0;
   switch (qtype) {
     case QUERY_QUEUE:
-      dTrace("msg:%p, will be written into vnode-query queue", pMsg);
+      dTrace("msg:%p, type:%s will be written into vnode-query queue", pMsg, TMSG_INFO(pRpc->msgType));
       taosWriteQitem(pVnode->pQueryQ, pMsg);
       break;
     case FETCH_QUEUE:
-      dTrace("msg:%p, will be written into vnode-fetch queue", pMsg);
+      dTrace("msg:%p, type:%s will be written into vnode-fetch queue", pMsg, TMSG_INFO(pRpc->msgType));
       taosWriteQitem(pVnode->pFetchQ, pMsg);
       break;
     case WRITE_QUEUE:
-      dTrace("msg:%p, will be written into vnode-write queue", pMsg);
+      dTrace("msg:%p, type:%s will be written into vnode-write queue", pMsg, TMSG_INFO(pRpc->msgType));
       taosWriteQitem(pVnode->pWriteQ, pMsg);
       break;
     case SYNC_QUEUE:
-      dTrace("msg:%p, will be written into vnode-sync queue", pMsg);
+      dTrace("msg:%p, type:%s will be written into vnode-sync queue", pMsg, TMSG_INFO(pRpc->msgType));
       taosWriteQitem(pVnode->pSyncQ, pMsg);
       break;
     case MERGE_QUEUE:
-      dTrace("msg:%p, will be written into vnode-merge queue", pMsg);
+      dTrace("msg:%p, type:%s will be written into vnode-merge queue", pMsg, TMSG_INFO(pRpc->msgType));
       taosWriteQitem(pVnode->pMergeQ, pMsg);
       break;
     default:
@@ -317,7 +317,7 @@ int32_t vmProcessMergeMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
 }
 
 int32_t vmProcessMgmtMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
-  SVnodesMgmt *  pMgmt = pWrapper->pMgmt;
+  SVnodesMgmt   *pMgmt = pWrapper->pMgmt;
   SSingleWorker *pWorker = &pMgmt->mgmtWorker;
   dTrace("msg:%p, will be written to vnode-mgmt queue, worker:%s", pMsg, pWorker->name);
   taosWriteQitem(pWorker->queue, pMsg);
@@ -325,7 +325,7 @@ int32_t vmProcessMgmtMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
 }
 
 int32_t vmProcessMonitorMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
-  SVnodesMgmt *  pMgmt = pWrapper->pMgmt;
+  SVnodesMgmt   *pMgmt = pWrapper->pMgmt;
   SSingleWorker *pWorker = &pMgmt->monitorWorker;
 
   dTrace("msg:%p, put into worker:%s", pMsg, pWorker->name);
@@ -335,7 +335,7 @@ int32_t vmProcessMonitorMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
 
 static int32_t vmPutRpcMsgToQueue(SMgmtWrapper *pWrapper, SRpcMsg *pRpc, EQueueType qtype) {
   SVnodesMgmt *pMgmt = pWrapper->pMgmt;
-  SMsgHead *   pHead = pRpc->pCont;
+  SMsgHead    *pHead = pRpc->pCont;
 
   SVnodeObj *pVnode = vmAcquireVnode(pMgmt, pHead->vgId);
   if (pVnode == NULL) return -1;

source/dnode/mnode/impl/inc/mndInt.h

@@ -47,7 +47,7 @@ typedef int32_t (*MndInitFp)(SMnode *pMnode);
 typedef void (*MndCleanupFp)(SMnode *pMnode);
 typedef int32_t (*ShowRetrieveFp)(SNodeMsg *pMsg, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
 typedef void (*ShowFreeIterFp)(SMnode *pMnode, void *pIter);
-typedef struct SQWorkerMgmt SQHandle;
+typedef struct SQWorker SQHandle;
 
 typedef struct {
   const char  *name;

source/dnode/mnode/impl/src/mndMnode.c

@@ -625,7 +625,7 @@ static int32_t mndRetrieveMnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *p
     colDataAppend(pColInfo, numOfRows, b1, false);
 
     const char *roles = syncStr(pObj->role);
-    char       *b2 = taosMemoryCalloc(1, strlen(roles) + VARSTR_HEADER_SIZE);
+    char       *b2 = taosMemoryCalloc(1, 12 + VARSTR_HEADER_SIZE);
     STR_WITH_MAXSIZE_TO_VARSTR(b2, roles, pShow->pMeta->pSchemas[cols].bytes);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

source/dnode/mnode/impl/src/mndStb.c

@@ -428,17 +428,23 @@ static void *mndBuildVCreateStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pSt
 }
 
 static void *mndBuildVDropStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pStb, int32_t *pContLen) {
-  SName name = {0};
+  SName        name = {0};
+  SVDropStbReq req = {0};
+  int32_t      contLen = 0;
+  int32_t      ret = 0;
+  SMsgHead    *pHead = NULL;
+  SCoder       coder = {0};
+
   tNameFromString(&name, pStb->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
 
-  SVDropTbReq req = {0};
-  req.ver = 0;
   req.name = (char *)tNameGetTableName(&name);
-  req.type = TD_SUPER_TABLE;
   req.suid = pStb->uid;
 
-  int32_t   contLen = tSerializeSVDropTbReq(NULL, &req) + sizeof(SMsgHead);
+  tEncodeSize(tEncodeSVDropStbReq, &req, contLen, ret);
-  SMsgHead *pHead = taosMemoryMalloc(contLen);
+  if (ret < 0) return NULL;
+
+  contLen += sizeof(SMsgHead);
+  pHead = taosMemoryMalloc(contLen);
   if (pHead == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
@@ -448,7 +454,10 @@ static void *mndBuildVDropStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pStb,
   pHead->vgId = htonl(pVgroup->vgId);
 
   void *pBuf = POINTER_SHIFT(pHead, sizeof(SMsgHead));
-  tSerializeSVDropTbReq(&pBuf, &req);
+
+  tCoderInit(&coder, TD_LITTLE_ENDIAN, pBuf, contLen - sizeof(SMsgHead), TD_ENCODER);
+  tEncodeSVDropStbReq(&coder, &req);
+  tCoderClear(&coder);
 
   *pContLen = contLen;
   return pHead;
@@ -670,8 +679,8 @@ static int32_t mndCreateStb(SMnode *pMnode, SNodeMsg *pReq, SMCreateStbReq *pCre
     memcpy(stbObj.pAst2, pCreate->pAst2, stbObj.ast2Len);
   }
 
-  stbObj.pColumns = taosMemoryMalloc(stbObj.numOfColumns * sizeof(SSchema));
+  stbObj.pColumns = taosMemoryCalloc(1, stbObj.numOfColumns * sizeof(SSchema));
-  stbObj.pTags = taosMemoryMalloc(stbObj.numOfTags * sizeof(SSchema));
+  stbObj.pTags = taosMemoryCalloc(1, stbObj.numOfTags * sizeof(SSchema));
   if (stbObj.pColumns == NULL || stbObj.pTags == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -1102,7 +1111,7 @@ static int32_t mndSetAlterStbRedoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pD
   SSdbRaw *pRedoRaw = mndStbActionEncode(pStb);
   if (pRedoRaw == NULL) return -1;
   if (mndTransAppendRedolog(pTrans, pRedoRaw) != 0) return -1;
-  if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_UPDATING) != 0) return -1;
+  if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_READY) != 0) return -1;
 
   return 0;
 }

source/dnode/mnode/impl/test/sdb/sdbTest.cpp

@@ -15,8 +15,31 @@
 
 class MndTestSdb : public ::testing::Test {
  protected:
-  static void SetUpTestSuite() {}
+  static void SetUpTestSuite() {
-  static void TearDownTestSuite() {}
+    dDebugFlag = 143;
+    vDebugFlag = 0;
+    mDebugFlag = 143;
+    cDebugFlag = 0;
+    jniDebugFlag = 0;
+    tmrDebugFlag = 135;
+    uDebugFlag = 135;
+    rpcDebugFlag = 143;
+    qDebugFlag = 0;
+    wDebugFlag = 0;
+    sDebugFlag = 0;
+    tsdbDebugFlag = 0;
+    tsLogEmbedded = 1;
+    tsAsyncLog = 0;
+
+    const char *path = "/tmp/td";
+    taosRemoveDir(path);
+    taosMkDir(path);
+    tstrncpy(tsLogDir, path, PATH_MAX);
+    if (taosInitLog("taosdlog", 1) != 0) {
+      printf("failed to init log file\n");
+    }
+  }
+  static void TearDownTestSuite() { taosCloseLog(); }
 
  public:
   void SetUp() override {}
@@ -26,6 +49,8 @@ class MndTestSdb : public ::testing::Test {
 typedef struct SMnode {
   int32_t v100;
   int32_t v200;
+  int32_t insertTimes;
+  int32_t deleteTimes;
   SSdb   *pSdb;
 } SMnode;
 
@@ -80,6 +105,48 @@ SSdbRaw *strEncode(SStrObj *pObj) {
   return pRaw;
 }
 
+SSdbRaw *i32Encode(SI32Obj *pObj) {
+  int32_t  dataPos = 0;
+  SSdbRaw *pRaw = sdbAllocRaw(SDB_VGROUP, 2, sizeof(SI32Obj));
+
+  sdbSetRawInt32(pRaw, dataPos, pObj->key);
+  dataPos += sizeof(pObj->key);
+  sdbSetRawInt8(pRaw, dataPos, pObj->v8);
+  dataPos += sizeof(pObj->v8);
+  sdbSetRawInt16(pRaw, dataPos, pObj->v16);
+  dataPos += sizeof(pObj->v16);
+  sdbSetRawInt32(pRaw, dataPos, pObj->v32);
+  dataPos += sizeof(pObj->v32);
+  sdbSetRawInt64(pRaw, dataPos, pObj->v64);
+  dataPos += sizeof(pObj->v64);
+  sdbSetRawBinary(pRaw, dataPos, pObj->vstr, sizeof(pObj->vstr));
+  dataPos += sizeof(pObj->vstr);
+  sdbSetRawDataLen(pRaw, dataPos);
+
+  return pRaw;
+}
+
+SSdbRaw *i64Encode(SI64Obj *pObj) {
+  int32_t  dataPos = 0;
+  SSdbRaw *pRaw = sdbAllocRaw(SDB_CONSUMER, 3, sizeof(SI64Obj));
+
+  sdbSetRawInt64(pRaw, dataPos, pObj->key);
+  dataPos += sizeof(pObj->key);
+  sdbSetRawInt8(pRaw, dataPos, pObj->v8);
+  dataPos += sizeof(pObj->v8);
+  sdbSetRawInt16(pRaw, dataPos, pObj->v16);
+  dataPos += sizeof(pObj->v16);
+  sdbSetRawInt32(pRaw, dataPos, pObj->v32);
+  dataPos += sizeof(pObj->v32);
+  sdbSetRawInt64(pRaw, dataPos, pObj->v64);
+  dataPos += sizeof(pObj->v64);
+  sdbSetRawBinary(pRaw, dataPos, pObj->vstr, sizeof(pObj->vstr));
+  dataPos += sizeof(pObj->vstr);
+  sdbSetRawDataLen(pRaw, dataPos);
+
+  return pRaw;
+}
+
 SSdbRow *strDecode(SSdbRaw *pRaw) {
   int8_t sver = 0;
   if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL;
@@ -108,9 +175,103 @@ SSdbRow *strDecode(SSdbRaw *pRaw) {
   return pRow;
 }
 
-int32_t strInsert(SSdb *pSdb, SStrObj *pObj) { return 0; }
+SSdbRow *i32Decode(SSdbRaw *pRaw) {
+  int8_t sver = 0;
+  if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL;
+  if (sver != 2) return NULL;
 
-int32_t strDelete(SSdb *pSdb, SStrObj *pObj, bool callFunc) { return 0; }
+  SSdbRow *pRow = sdbAllocRow(sizeof(SI32Obj));
+  if (pRow == NULL) return NULL;
+
+  SI32Obj *pObj = (SI32Obj *)sdbGetRowObj(pRow);
+  if (pObj == NULL) return NULL;
+
+  int32_t dataPos = 0;
+  sdbGetRawInt32(pRaw, dataPos, &pObj->key);
+  dataPos += sizeof(pObj->key);
+  sdbGetRawInt8(pRaw, dataPos, &pObj->v8);
+  dataPos += sizeof(pObj->v8);
+  sdbGetRawInt16(pRaw, dataPos, &pObj->v16);
+  dataPos += sizeof(pObj->v16);
+  sdbGetRawInt32(pRaw, dataPos, &pObj->v32);
+  dataPos += sizeof(pObj->v32);
+  sdbGetRawInt64(pRaw, dataPos, &pObj->v64);
+  dataPos += sizeof(pObj->v64);
+  sdbGetRawBinary(pRaw, dataPos, pObj->vstr, sizeof(pObj->vstr));
+  dataPos += sizeof(pObj->vstr);
+
+  return pRow;
+}
+
+SSdbRow *i64Decode(SSdbRaw *pRaw) {
+  int8_t sver = 0;
+  if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL;
+  if (sver != 3) return NULL;
+
+  SSdbRow *pRow = sdbAllocRow(sizeof(SI64Obj));
+  if (pRow == NULL) return NULL;
+
+  SI64Obj *pObj = (SI64Obj *)sdbGetRowObj(pRow);
+  if (pObj == NULL) return NULL;
+
+  int32_t dataPos = 0;
+  sdbGetRawInt64(pRaw, dataPos, &pObj->key);
+  dataPos += sizeof(pObj->key);
+  sdbGetRawInt8(pRaw, dataPos, &pObj->v8);
+  dataPos += sizeof(pObj->v8);
+  sdbGetRawInt16(pRaw, dataPos, &pObj->v16);
+  dataPos += sizeof(pObj->v16);
+  sdbGetRawInt32(pRaw, dataPos, &pObj->v32);
+  dataPos += sizeof(pObj->v32);
+  sdbGetRawInt64(pRaw, dataPos, &pObj->v64);
+  dataPos += sizeof(pObj->v64);
+  sdbGetRawBinary(pRaw, dataPos, pObj->vstr, sizeof(pObj->vstr));
+  dataPos += sizeof(pObj->vstr);
+
+  return pRow;
+}
+
+int32_t strInsert(SSdb *pSdb, SStrObj *pObj) {
+  SMnode *pMnode = pSdb->pMnode;
+  pMnode->insertTimes++;
+  return 0;
+}
+
+int32_t i32Insert(SSdb *pSdb, SI32Obj *pObj) {
+  SMnode *pMnode = pSdb->pMnode;
+  pMnode->insertTimes++;
+  return 0;
+}
+
+int32_t i64Insert(SSdb *pSdb, SI64Obj *pObj) {
+  SMnode *pMnode = pSdb->pMnode;
+  pMnode->insertTimes++;
+  return 0;
+}
+
+int32_t strDelete(SSdb *pSdb, SStrObj *pObj, bool callFunc) {
+  if (callFunc) {
+    SMnode *pMnode = pSdb->pMnode;
+    pMnode->deleteTimes++;
+  }
+  return 0;
+}
+
+int32_t i32Delete(SSdb *pSdb, SI32Obj *pObj, bool callFunc) {
+  if (callFunc) {
+    SMnode *pMnode = pSdb->pMnode;
+    pMnode->deleteTimes++;
+  }
+  return 0;
+}
+
+int32_t i64Delete(SSdb *pSdb, SI64Obj *pObj, bool callFunc) {
+  if (callFunc) {
+    SMnode *pMnode = pSdb->pMnode;
+    pMnode->deleteTimes++;
+  }
+  return 0;
+}
 
 int32_t strUpdate(SSdb *pSdb, SStrObj *pOld, SStrObj *pNew) {
   pOld->v8 = pNew->v8;
@@ -121,6 +282,24 @@ int32_t strUpdate(SSdb *pSdb, SStrObj *pOld, SStrObj *pNew) {
   return 0;
 }
 
+int32_t i32Update(SSdb *pSdb, SI32Obj *pOld, SI32Obj *pNew) {
+  pOld->v8 = pNew->v8;
+  pOld->v16 = pNew->v16;
+  pOld->v32 = pNew->v32;
+  pOld->v64 = pNew->v64;
+  strcpy(pOld->vstr, pNew->vstr);
+  return 0;
+}
+
+int32_t i64Update(SSdb *pSdb, SI64Obj *pOld, SI64Obj *pNew) {
+  pOld->v8 = pNew->v8;
+  pOld->v16 = pNew->v16;
+  pOld->v32 = pNew->v32;
+  pOld->v64 = pNew->v64;
+  strcpy(pOld->vstr, pNew->vstr);
+  return 0;
+}
+
 void strSetDefault(SStrObj *pObj, int32_t index) {
   memset(pObj, 0, sizeof(SStrObj));
   snprintf(pObj->key, sizeof(pObj->key), "k%d", index * 1000);
@@ -131,6 +310,26 @@ void strSetDefault(SStrObj *pObj, int32_t index) {
   snprintf(pObj->vstr, sizeof(pObj->vstr), "v%d", index * 1000);
 }
 
+void i32SetDefault(SI32Obj *pObj, int32_t index) {
+  memset(pObj, 0, sizeof(SI32Obj));
+  pObj->key = index;
+  pObj->v8 = index;
+  pObj->v16 = index;
+  pObj->v32 = index * 1000;
+  pObj->v64 = index * 1000;
+  snprintf(pObj->vstr, sizeof(pObj->vstr), "v%d", index * 1000);
+}
+
+void i64SetDefault(SI64Obj *pObj, int32_t index) {
+  memset(pObj, 0, sizeof(SI64Obj));
+  pObj->key = index;
+  pObj->v8 = index;
+  pObj->v16 = index;
+  pObj->v32 = index * 1000;
+  pObj->v64 = index * 1000;
+  snprintf(pObj->vstr, sizeof(pObj->vstr), "v%d", index * 1000);
+}
+
 int32_t strDefault(SMnode *pMnode) {
   SStrObj  strObj;
   SSdbRaw *pRaw = NULL;
@@ -144,6 +343,8 @@ int32_t strDefault(SMnode *pMnode) {
   pRaw = strEncode(&strObj);
   sdbSetRawStatus(pRaw, SDB_STATUS_READY);
   if (sdbWriteWithoutFree(pMnode->pSdb, pRaw) != 0) return -1;
+
+  EXPECT_EQ(sdbGetRawTotalSize(pRaw), 79);
   sdbFreeRaw(pRaw);
 
   return 0;
@@ -151,28 +352,32 @@ int32_t strDefault(SMnode *pMnode) {
 
 bool sdbTraverseSucc1(SMnode *pMnode, SStrObj *pObj, int32_t *p1, int32_t *p2, int32_t *p3) {
   if (pObj->v8 == 1) {
-    *p1 = *p2 + *p3 + pObj->v8;
+    *p1 += *p2 + *p3 + pObj->v8;
   }
   return true;
 }
 
 bool sdbTraverseSucc2(SMnode *pMnode, SStrObj *pObj, int32_t *p1, int32_t *p2, int32_t *p3) {
-  *p1 = *p2 + *p3 + pObj->v8;
+  *p1 += *p2 + *p3 + pObj->v8;
   return true;
 }
 
 bool sdbTraverseFail(SMnode *pMnode, SStrObj *pObj, int32_t *p1, int32_t *p2, int32_t *p3) {
-  *p1 = *p2 + *p3;
+  *p1 += *p2 + *p3;
   return false;
 }
 
-TEST_F(MndTestSdb, 01_Write) {
+TEST_F(MndTestSdb, 01_Write_Str) {
-  void    *pIter;
+  void    *pIter = NULL;
-  int32_t  num;
+  int32_t  num = 0;
-  SStrObj *pObj;
+  SStrObj *pObj = NULL;
-  SMnode   mnode;
+  SMnode   mnode = {0};
-  SSdb    *pSdb;
+  SSdb    *pSdb = NULL;
   SSdbOpt  opt = {0};
+  SStrObj  strObj = {0};
+  SI32Obj  i32Obj = {0};
+  SI64Obj  i64Obj = {0};
+  SSdbRaw *pRaw = NULL;
   int32_t  p1 = 0;
   int32_t  p2 = 111;
   int32_t  p3 = 222;
@@ -183,42 +388,64 @@ TEST_F(MndTestSdb, 01_Write) {
   opt.path = "/tmp/mnode_test_sdb";
   taosRemoveDir(opt.path);
 
-  SSdbTable strTable = {
+  SSdbTable strTable1;
-      SDB_USER,
+  memset(&strTable1, 0, sizeof(SSdbTable));
-      SDB_KEY_BINARY,
+  strTable1.sdbType = SDB_USER;
-      (SdbDeployFp)strDefault,
+  strTable1.keyType = SDB_KEY_BINARY;
-      (SdbEncodeFp)strEncode,
+  strTable1.deployFp = (SdbDeployFp)strDefault;
-      (SdbDecodeFp)strDecode,
+  strTable1.encodeFp = (SdbEncodeFp)strEncode;
-      (SdbInsertFp)strInsert,
+  strTable1.decodeFp = (SdbDecodeFp)strDecode;
-      (SdbUpdateFp)strUpdate,
+  strTable1.insertFp = (SdbInsertFp)strInsert;
-      (SdbDeleteFp)strDelete,
+  strTable1.updateFp = (SdbUpdateFp)strUpdate;
-  };
+  strTable1.deleteFp = (SdbDeleteFp)strDelete;
+
+  SSdbTable strTable2;
+  memset(&strTable2, 0, sizeof(SSdbTable));
+  strTable2.sdbType = SDB_VGROUP;
+  strTable2.keyType = SDB_KEY_INT32;
+  strTable2.encodeFp = (SdbEncodeFp)i32Encode;
+  strTable2.decodeFp = (SdbDecodeFp)i32Decode;
+  strTable2.insertFp = (SdbInsertFp)i32Insert;
+  strTable2.updateFp = (SdbUpdateFp)i32Update;
+  strTable2.deleteFp = (SdbDeleteFp)i32Delete;
+
+  SSdbTable strTable3;
+  memset(&strTable3, 0, sizeof(SSdbTable));
+  strTable3.sdbType = SDB_CONSUMER;
+  strTable3.keyType = SDB_KEY_INT64;
+  strTable3.encodeFp = (SdbEncodeFp)i64Encode;
+  strTable3.decodeFp = (SdbDecodeFp)i64Decode;
+  strTable3.insertFp = (SdbInsertFp)i64Insert;
+  strTable3.updateFp = (SdbUpdateFp)i64Update;
+  strTable3.deleteFp = (SdbDeleteFp)i64Delete;
 
   pSdb = sdbInit(&opt);
   mnode.pSdb = pSdb;
 
   ASSERT_NE(pSdb, nullptr);
-  ASSERT_EQ(sdbSetTable(pSdb, strTable), 0);
+  ASSERT_EQ(sdbSetTable(pSdb, strTable1), 0);
+  ASSERT_EQ(sdbSetTable(pSdb, strTable2), 0);
+  ASSERT_EQ(sdbSetTable(pSdb, strTable3), 0);
   ASSERT_EQ(sdbDeploy(pSdb), 0);
-#if 0
+
   pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k1000");
   ASSERT_NE(pObj, nullptr);
   EXPECT_STREQ(pObj->key, "k1000");
   EXPECT_STREQ(pObj->vstr, "v1000");
-  EXPECT_EQ(pObj->v8, 1);
+  ASSERT_EQ(pObj->v8, 1);
-  EXPECT_EQ(pObj->v16, 1);
+  ASSERT_EQ(pObj->v16, 1);
-  EXPECT_EQ(pObj->v32, 1000);
+  ASSERT_EQ(pObj->v32, 1000);
-  EXPECT_EQ(pObj->v64, 1000);
+  ASSERT_EQ(pObj->v64, 1000);
   sdbRelease(pSdb, pObj);
 
   pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k2000");
   ASSERT_NE(pObj, nullptr);
   EXPECT_STREQ(pObj->key, "k2000");
   EXPECT_STREQ(pObj->vstr, "v2000");
-  EXPECT_EQ(pObj->v8, 2);
+  ASSERT_EQ(pObj->v8, 2);
-  EXPECT_EQ(pObj->v16, 2);
+  ASSERT_EQ(pObj->v16, 2);
-  EXPECT_EQ(pObj->v32, 2000);
+  ASSERT_EQ(pObj->v32, 2000);
-  EXPECT_EQ(pObj->v64, 2000);
+  ASSERT_EQ(pObj->v64, 2000);
   sdbRelease(pSdb, pObj);
 
   pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k200");
@@ -233,7 +460,7 @@ TEST_F(MndTestSdb, 01_Write) {
     num++;
     sdbRelease(pSdb, pObj);
   } while (1);
-  EXPECT_EQ(num, 2);
+  ASSERT_EQ(num, 2);
 
   do {
     pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pObj);
@@ -248,51 +475,254 @@ TEST_F(MndTestSdb, 01_Write) {
   p1 = 0;
   p2 = 111;
   p3 = 222;
-  sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseSucc2, &p1, &p2, &p3);
+  sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseSucc1, &p1, &p2, &p3);
-  EXPECT_EQ(p1, 334);
+  ASSERT_EQ(p1, 334);
 
   p1 = 0;
   p2 = 111;
   p3 = 222;
   sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseSucc2, &p1, &p2, &p3);
-  EXPECT_EQ(p1, 669);
+  ASSERT_EQ(p1, 669);
 
   p1 = 0;
   p2 = 111;
   p3 = 222;
   sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseFail, &p1, &p2, &p3);
-  EXPECT_EQ(p1, 333);
+  ASSERT_EQ(p1, 333);
 
-  EXPECT_EQ(sdbGetSize(pSdb, SDB_USER), 2);
+  ASSERT_EQ(sdbGetSize(pSdb, SDB_USER), 2);
-  EXPECT_EQ(sdbGetMaxId(pSdb, SDB_USER), -1);
+  ASSERT_EQ(sdbGetMaxId(pSdb, SDB_USER), -1);
-  EXPECT_EQ(sdbGetTableVer(pSdb, SDB_USER), 2);
+  ASSERT_EQ(sdbGetTableVer(pSdb, SDB_USER), 2 );
-  EXPECT_EQ(sdbUpdateVer(pSdb, 0), 2);
+  ASSERT_EQ(sdbUpdateVer(pSdb, 0), -1);
-  EXPECT_EQ(sdbUpdateVer(pSdb, 1), 3);
+  ASSERT_EQ(sdbUpdateVer(pSdb, 1), 0);
-  EXPECT_EQ(sdbUpdateVer(pSdb, -1), 2);
+  ASSERT_EQ(sdbUpdateVer(pSdb, -1), -1);
+  ASSERT_EQ(mnode.insertTimes, 2);
+  ASSERT_EQ(mnode.deleteTimes, 0);
 
-  // insert, call func
+  {
+    // insert, call func
+    strSetDefault(&strObj, 3);
+    pRaw = strEncode(&strObj);
+    sdbSetRawStatus(pRaw, SDB_STATUS_READY);
+    ASSERT_EQ(sdbWrite(pSdb, pRaw), 0);
+    pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k3000");
+    ASSERT_NE(pObj, nullptr);
+    EXPECT_STREQ(pObj->key, "k3000");
+    EXPECT_STREQ(pObj->vstr, "v3000");
+    ASSERT_EQ(pObj->v8, 3);
+    ASSERT_EQ(pObj->v16, 3);
+    ASSERT_EQ(pObj->v32, 3000);
+    ASSERT_EQ(pObj->v64, 3000);
+    sdbRelease(pSdb, pObj);
 
-  // update, call func
+    ASSERT_EQ(sdbGetSize(pSdb, SDB_USER), 3);
+    ASSERT_EQ(sdbGetTableVer(pSdb, SDB_USER), 3);
+    ASSERT_EQ(sdbGetMaxId(pSdb, SDB_USER), -1);
 
-  // delete, call func 2
+    // update, call func
+    strSetDefault(&strObj, 3);
+    strObj.v8 = 4;
+    pRaw = strEncode(&strObj);
+    sdbSetRawStatus(pRaw, SDB_STATUS_READY);
+    ASSERT_EQ(sdbWrite(pSdb, pRaw), 0);
+    pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k3000");
+    ASSERT_NE(pObj, nullptr);
+    EXPECT_STREQ(pObj->key, "k3000");
+    EXPECT_STREQ(pObj->vstr, "v3000");
+    ASSERT_EQ(pObj->v8, 4);
+    ASSERT_EQ(pObj->v16, 3);
+    ASSERT_EQ(pObj->v32, 3000);
+    ASSERT_EQ(pObj->v64, 3000);
+    sdbRelease(pSdb, pObj);
+
+    ASSERT_EQ(sdbGetSize(pSdb, SDB_USER), 3);
+    ASSERT_EQ(sdbGetTableVer(pSdb, SDB_USER), 4);
+    ASSERT_EQ(sdbUpdateVer(pSdb, 0), -1);
+    ASSERT_EQ(sdbUpdateVer(pSdb, 1), 0);
+    ASSERT_EQ(sdbUpdateVer(pSdb, -1), -1);
+    ASSERT_EQ(mnode.insertTimes, 3);
+    ASSERT_EQ(mnode.deleteTimes, 0);
+
+    // delete, call func 2
+    strSetDefault(&strObj, 3);
+    strObj.v16 = 4;
+    pRaw = strEncode(&strObj);
+    sdbSetRawStatus(pRaw, SDB_STATUS_DROPPED);
+    ASSERT_EQ(sdbWrite(pSdb, pRaw), 0);
+    pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k3000");
+    ASSERT_EQ(pObj, nullptr);
+    ASSERT_EQ(sdbGetSize(pSdb, SDB_USER), 2);
+    ASSERT_EQ(sdbGetTableVer(pSdb, SDB_USER), 5);
+    ASSERT_EQ(mnode.insertTimes, 3);
+    ASSERT_EQ(mnode.deleteTimes, 1);
+  }
+
+  {
+    int32_t key = 4;
+    i32SetDefault(&i32Obj, key);
+    pRaw = i32Encode(&i32Obj);
+    sdbSetRawStatus(pRaw, SDB_STATUS_READY);
+    ASSERT_EQ(sdbWrite(pSdb, pRaw), 0);
+    SI32Obj *pI32Obj = (SI32Obj *)sdbAcquire(pSdb, SDB_VGROUP, &key);
+    ASSERT_NE(pI32Obj, nullptr);
+    ASSERT_EQ(pI32Obj->key, key);
+    ASSERT_EQ(pI32Obj->v8, 4);
+    ASSERT_EQ(pI32Obj->v16, 4);
+    ASSERT_EQ(pI32Obj->v32, 4000);
+    ASSERT_EQ(pI32Obj->v64, 4000);
+    sdbRelease(pSdb, pI32Obj);
+
+    ASSERT_EQ(sdbGetSize(pSdb, SDB_VGROUP), 1);
+    ASSERT_EQ(sdbGetTableVer(pSdb, SDB_VGROUP), 1);
+    ASSERT_EQ(sdbGetMaxId(pSdb, SDB_VGROUP), 5);
+
+    i32SetDefault(&i32Obj, key);
+    i32Obj.v8 = 5;
+    pRaw = i32Encode(&i32Obj);
+    sdbSetRawStatus(pRaw, SDB_STATUS_READY);
+    ASSERT_EQ(sdbWrite(pSdb, pRaw), 0);
+    pI32Obj = (SI32Obj *)sdbAcquire(pSdb, SDB_VGROUP, &key);
+    ASSERT_NE(pI32Obj, nullptr);
+    ASSERT_EQ(pI32Obj->key, key);
+    ASSERT_EQ(pI32Obj->v8, 5);
+    ASSERT_EQ(pI32Obj->v16, 4);
+    ASSERT_EQ(pI32Obj->v32, 4000);
+    ASSERT_EQ(pI32Obj->v64, 4000);
+    sdbRelease(pSdb, pI32Obj);
+
+    ASSERT_EQ(sdbGetSize(pSdb, SDB_VGROUP), 1);
+    ASSERT_EQ(sdbGetTableVer(pSdb, SDB_VGROUP), 2);
+    ASSERT_EQ(mnode.insertTimes, 4);
+    ASSERT_EQ(mnode.deleteTimes, 1);
+
+    // delete, call func 2
+    key = 4;
+    i32SetDefault(&i32Obj, key);
+    pRaw = i32Encode(&i32Obj);
+    sdbSetRawStatus(pRaw, SDB_STATUS_DROPPED);
+    ASSERT_EQ(sdbWrite(pSdb, pRaw), 0);
+    pI32Obj = (SI32Obj *)sdbAcquire(pSdb, SDB_VGROUP, &key);
+    ASSERT_EQ(pI32Obj, nullptr);
+    ASSERT_EQ(sdbGetSize(pSdb, SDB_VGROUP), 0);
+    ASSERT_EQ(sdbGetTableVer(pSdb, SDB_VGROUP), 3);
+    ASSERT_EQ(sdbGetMaxId(pSdb, SDB_VGROUP), 5);
+    ASSERT_EQ(mnode.insertTimes, 4);
+    ASSERT_EQ(mnode.deleteTimes, 2);
+
+    key = 6;
+    i32SetDefault(&i32Obj, key);
+    pRaw = i32Encode(&i32Obj);
+    sdbSetRawStatus(pRaw, SDB_STATUS_READY);
+    ASSERT_EQ(sdbWrite(pSdb, pRaw), 0);
+    pI32Obj = (SI32Obj *)sdbAcquire(pSdb, SDB_VGROUP, &key);
+    ASSERT_NE(pI32Obj, nullptr);
+    ASSERT_EQ(pI32Obj->key, key);
+    ASSERT_EQ(pI32Obj->v8, 6);
+    ASSERT_EQ(pI32Obj->v16, 6);
+    ASSERT_EQ(pI32Obj->v32, 6000);
+    ASSERT_EQ(pI32Obj->v64, 6000);
+    sdbRelease(pSdb, pI32Obj);
+
+    ASSERT_EQ(sdbGetSize(pSdb, SDB_VGROUP), 1);
+    ASSERT_EQ(sdbGetTableVer(pSdb, SDB_VGROUP), 4);
+    ASSERT_EQ(sdbGetMaxId(pSdb, SDB_VGROUP), 7);
+    ASSERT_EQ(mnode.insertTimes, 5);
+    ASSERT_EQ(mnode.deleteTimes, 2);
+  }
+
+  {
+    int64_t key = 4;
+    i64SetDefault(&i64Obj, key);
+    pRaw = i64Encode(&i64Obj);
+    sdbSetRawStatus(pRaw, SDB_STATUS_READY);
+    ASSERT_EQ(sdbWrite(pSdb, pRaw), 0);
+    SI64Obj *pI64Obj = (SI64Obj *)sdbAcquire(pSdb, SDB_CONSUMER, &key);
+    ASSERT_NE(pI64Obj, nullptr);
+    ASSERT_EQ(pI64Obj->key, key);
+    ASSERT_EQ(pI64Obj->v8, 4);
+    ASSERT_EQ(pI64Obj->v16, 4);
+    ASSERT_EQ(pI64Obj->v32, 4000);
+    ASSERT_EQ(pI64Obj->v64, 4000);
+    sdbRelease(pSdb, pI64Obj);
+
+    ASSERT_EQ(sdbGetSize(pSdb, SDB_CONSUMER), 1);
+    ASSERT_EQ(sdbGetTableVer(pSdb, SDB_CONSUMER), 1);
+    ASSERT_EQ(sdbGetMaxId(pSdb, SDB_CONSUMER), -1);
+
+    i64SetDefault(&i64Obj, key);
+    i64Obj.v8 = 5;
+    pRaw = i64Encode(&i64Obj);
+    sdbSetRawStatus(pRaw, SDB_STATUS_READY);
+    ASSERT_EQ(sdbWrite(pSdb, pRaw), 0);
+    pI64Obj = (SI64Obj *)sdbAcquire(pSdb, SDB_CONSUMER, &key);
+    ASSERT_NE(pI64Obj, nullptr);
+    ASSERT_EQ(pI64Obj->key, key);
+    ASSERT_EQ(pI64Obj->v8, 5);
+    ASSERT_EQ(pI64Obj->v16, 4);
+    ASSERT_EQ(pI64Obj->v32, 4000);
+    ASSERT_EQ(pI64Obj->v64, 4000);
+    sdbRelease(pSdb, pI64Obj);
+
+    ASSERT_EQ(sdbGetSize(pSdb, SDB_CONSUMER), 1);
+    ASSERT_EQ(sdbGetTableVer(pSdb, SDB_CONSUMER), 2);
+    ASSERT_EQ(mnode.insertTimes, 6);
+    ASSERT_EQ(mnode.deleteTimes, 2);
+
+    // delete, call func 2
+    key = 4;
+    i64SetDefault(&i64Obj, key);
+    pRaw = i64Encode(&i64Obj);
+    sdbSetRawStatus(pRaw, SDB_STATUS_DROPPED);
+    ASSERT_EQ(sdbWrite(pSdb, pRaw), 0);
+    pObj = (SStrObj *)sdbAcquire(pSdb, SDB_CONSUMER, &key);
+    ASSERT_EQ(pObj, nullptr);
+    ASSERT_EQ(sdbGetSize(pSdb, SDB_CONSUMER), 0);
+    ASSERT_EQ(sdbGetTableVer(pSdb, SDB_CONSUMER), 3);
+    ASSERT_EQ(sdbGetMaxId(pSdb, SDB_CONSUMER), -1);
+    ASSERT_EQ(mnode.insertTimes, 6);
+    ASSERT_EQ(mnode.deleteTimes, 3);
+
+    key = 7;
+    i64SetDefault(&i64Obj, key);
+    pRaw = i64Encode(&i64Obj);
+    sdbSetRawStatus(pRaw, SDB_STATUS_READY);
+    ASSERT_EQ(sdbWrite(pSdb, pRaw), 0);
+    pI64Obj = (SI64Obj *)sdbAcquire(pSdb, SDB_CONSUMER, &key);
+    ASSERT_NE(pI64Obj, nullptr);
+    ASSERT_EQ(pI64Obj->key, key);
+    ASSERT_EQ(pI64Obj->v8, 7);
+    ASSERT_EQ(pI64Obj->v16, 7);
+    ASSERT_EQ(pI64Obj->v32, 7000);
+    ASSERT_EQ(pI64Obj->v64, 7000);
+    sdbRelease(pSdb, pI64Obj);
+
+    ASSERT_EQ(sdbGetSize(pSdb, SDB_CONSUMER), 1);
+    ASSERT_EQ(sdbGetTableVer(pSdb, SDB_CONSUMER), 4);
+    ASSERT_EQ(sdbGetMaxId(pSdb, SDB_CONSUMER), -1);
+    ASSERT_EQ(mnode.insertTimes, 7);
+    ASSERT_EQ(mnode.deleteTimes, 3);
+  }
 
   // write version
-
+  ASSERT_EQ(sdbUpdateVer(pSdb, 1), 0);
-  // sdb Write ver
+  ASSERT_EQ(sdbUpdateVer(pSdb, 1), 1);
-
-  // sdbRead
-#endif
   ASSERT_EQ(sdbWriteFile(pSdb), 0);
+  ASSERT_EQ(sdbWriteFile(pSdb), 0);
+
   sdbCleanup(pSdb);
+  ASSERT_EQ(mnode.insertTimes, 7);
+  ASSERT_EQ(mnode.deleteTimes, 7);
 }
 
-TEST_F(MndTestSdb, 01_Read) {
+TEST_F(MndTestSdb, 01_Read_Str) {
-  void    *pIter;
+  void    *pIter = NULL;
-  int32_t  num;
+  int32_t  num = 0;
-  SStrObj *pObj;
+  SStrObj *pObj = NULL;
-  SMnode   mnode;
+  SMnode   mnode = {0};
-  SSdb    *pSdb;
+  SSdb    *pSdb = NULL;
   SSdbOpt  opt = {0};
+  SStrObj  strObj = {0};
+  SSdbRaw *pRaw = NULL;
   int32_t  p1 = 0;
   int32_t  p2 = 111;
   int32_t  p3 = 222;
@@ -301,22 +731,174 @@ TEST_F(MndTestSdb, 01_Read) {
   mnode.v200 = 200;
   opt.pMnode = &mnode;
   opt.path = "/tmp/mnode_test_sdb";
-  taosRemoveDir(opt.path);
 
-  SSdbTable strTable = {
+  SSdbTable strTable1;
-      SDB_USER,
+  memset(&strTable1, 0, sizeof(SSdbTable));
-      SDB_KEY_BINARY,
+  strTable1.sdbType = SDB_USER;
-      (SdbDeployFp)strDefault,
+  strTable1.keyType = SDB_KEY_BINARY;
-      (SdbEncodeFp)strEncode,
+  strTable1.deployFp = (SdbDeployFp)strDefault;
-      (SdbDecodeFp)strDecode,
+  strTable1.encodeFp = (SdbEncodeFp)strEncode;
-      (SdbInsertFp)strInsert,
+  strTable1.decodeFp = (SdbDecodeFp)strDecode;
-      (SdbUpdateFp)strUpdate,
+  strTable1.insertFp = (SdbInsertFp)strInsert;
-      (SdbDeleteFp)strDelete,
+  strTable1.updateFp = (SdbUpdateFp)strUpdate;
-  };
+  strTable1.deleteFp = (SdbDeleteFp)strDelete;
+
+  SSdbTable strTable2;
+  memset(&strTable2, 0, sizeof(SSdbTable));
+  strTable2.sdbType = SDB_VGROUP;
+  strTable2.keyType = SDB_KEY_INT32;
+  strTable2.encodeFp = (SdbEncodeFp)i32Encode;
+  strTable2.decodeFp = (SdbDecodeFp)i32Decode;
+  strTable2.insertFp = (SdbInsertFp)i32Insert;
+  strTable2.updateFp = (SdbUpdateFp)i32Update;
+  strTable2.deleteFp = (SdbDeleteFp)i32Delete;
+
+  SSdbTable strTable3;
+  memset(&strTable3, 0, sizeof(SSdbTable));
+  strTable3.sdbType = SDB_CONSUMER;
+  strTable3.keyType = SDB_KEY_INT64;
+  strTable3.encodeFp = (SdbEncodeFp)i64Encode;
+  strTable3.decodeFp = (SdbDecodeFp)i64Decode;
+  strTable3.insertFp = (SdbInsertFp)i64Insert;
+  strTable3.updateFp = (SdbUpdateFp)i64Update;
+  strTable3.deleteFp = (SdbDeleteFp)i64Delete;
 
   pSdb = sdbInit(&opt);
   mnode.pSdb = pSdb;
-
+  ASSERT_NE(pSdb, nullptr);
+  ASSERT_NE(pSdb, nullptr);
+  ASSERT_EQ(sdbSetTable(pSdb, strTable1), 0);
+  ASSERT_EQ(sdbSetTable(pSdb, strTable2), 0);
+  ASSERT_EQ(sdbSetTable(pSdb, strTable3), 0);
   ASSERT_EQ(sdbReadFile(pSdb), 0);
+
+  ASSERT_EQ(sdbGetSize(pSdb, SDB_USER), 2);
+  ASSERT_EQ(sdbGetMaxId(pSdb, SDB_USER), -1);
+  ASSERT_EQ(sdbGetTableVer(pSdb, SDB_USER), 5);
+  ASSERT_EQ(sdbUpdateVer(pSdb, 0), 1);
+  ASSERT_EQ(mnode.insertTimes, 4);
+  ASSERT_EQ(mnode.deleteTimes, 0);
+
+  pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k1000");
+  ASSERT_NE(pObj, nullptr);
+  EXPECT_STREQ(pObj->key, "k1000");
+  EXPECT_STREQ(pObj->vstr, "v1000");
+  ASSERT_EQ(pObj->v8, 1);
+  ASSERT_EQ(pObj->v16, 1);
+  ASSERT_EQ(pObj->v32, 1000);
+  ASSERT_EQ(pObj->v64, 1000);
+  sdbRelease(pSdb, pObj);
+
+  pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k2000");
+  ASSERT_NE(pObj, nullptr);
+  EXPECT_STREQ(pObj->key, "k2000");
+  EXPECT_STREQ(pObj->vstr, "v2000");
+  ASSERT_EQ(pObj->v8, 2);
+  ASSERT_EQ(pObj->v16, 2);
+  ASSERT_EQ(pObj->v32, 2000);
+  ASSERT_EQ(pObj->v64, 2000);
+  sdbRelease(pSdb, pObj);
+
+  pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k200");
+  ASSERT_EQ(pObj, nullptr);
+
+  pIter = NULL;
+  num = 0;
+  do {
+    pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pObj);
+    if (pIter == NULL) break;
+    ASSERT_NE(pObj, nullptr);
+    num++;
+    sdbRelease(pSdb, pObj);
+  } while (1);
+  ASSERT_EQ(num, 2);
+
+  do {
+    pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pObj);
+    if (pIter == NULL) break;
+    if (strcmp(pObj->key, "k1000") == 0) {
+      sdbCancelFetch(pSdb, pIter);
+      break;
+    }
+  } while (1);
+  EXPECT_STREQ(pObj->key, "k1000");
+
+  p1 = 0;
+  p2 = 111;
+  p3 = 222;
+  sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseSucc1, &p1, &p2, &p3);
+  ASSERT_EQ(p1, 334);
+
+  p1 = 0;
+  p2 = 111;
+  p3 = 222;
+  sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseSucc2, &p1, &p2, &p3);
+  ASSERT_EQ(p1, 669);
+
+  p1 = 0;
+  p2 = 111;
+  p3 = 222;
+  sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseFail, &p1, &p2, &p3);
+  ASSERT_EQ(p1, 333);
+
+  int32_t  i32key = 6;
+  SI32Obj *pI32Obj = (SI32Obj *)sdbAcquire(pSdb, SDB_VGROUP, &i32key);
+  ASSERT_NE(pI32Obj, nullptr);
+  ASSERT_EQ(pI32Obj->key, 6);
+  ASSERT_EQ(pI32Obj->v8, 6);
+  ASSERT_EQ(pI32Obj->v16, 6);
+  ASSERT_EQ(pI32Obj->v32, 6000);
+  ASSERT_EQ(pI32Obj->v64, 6000);
+  sdbRelease(pSdb, pI32Obj);
+
+  ASSERT_EQ(sdbGetSize(pSdb, SDB_VGROUP), 1);
+  ASSERT_EQ(sdbGetTableVer(pSdb, SDB_VGROUP), 4);
+  ASSERT_EQ(sdbGetMaxId(pSdb, SDB_VGROUP), 7);
+
+  int64_t  i64key = 7;
+  SI64Obj *pI64Obj = (SI64Obj *)sdbAcquire(pSdb, SDB_CONSUMER, &i64key);
+  ASSERT_NE(pI64Obj, nullptr);
+  ASSERT_EQ(pI64Obj->key, 7);
+  ASSERT_EQ(pI64Obj->v8, 7);
+  ASSERT_EQ(pI64Obj->v16, 7);
+  ASSERT_EQ(pI64Obj->v32, 7000);
+  ASSERT_EQ(pI64Obj->v64, 7000);
+  sdbRelease(pSdb, pI64Obj);
+
+  ASSERT_EQ(sdbGetSize(pSdb, SDB_CONSUMER), 1);
+  ASSERT_EQ(sdbGetTableVer(pSdb, SDB_CONSUMER), 4);
+
+  ASSERT_EQ(mnode.insertTimes, 4);
+  ASSERT_EQ(mnode.deleteTimes, 0);
+
+  {
+    SI32Obj i32Obj = {0};
+    int32_t key = 6;
+    i32SetDefault(&i32Obj, key);
+    pRaw = i32Encode(&i32Obj);
+    sdbSetRawStatus(pRaw, SDB_STATUS_DROPPING);
+    ASSERT_EQ(sdbWrite(pSdb, pRaw), 0);
+    pI32Obj = (SI32Obj *)sdbAcquire(pSdb, SDB_VGROUP, &key);
+    ASSERT_EQ(pI32Obj, nullptr);
+    int32_t code = terrno;
+    ASSERT_EQ(code, TSDB_CODE_SDB_OBJ_DROPPING);
+  }
+
+  {
+    SI32Obj i32Obj = {0};
+    int32_t key = 8;
+    i32SetDefault(&i32Obj, key);
+    pRaw = i32Encode(&i32Obj);
+    EXPECT_NE(sdbSetRawStatus(pRaw, SDB_STATUS_INIT), 0);
+    sdbSetRawStatus(pRaw, SDB_STATUS_CREATING);
+    ASSERT_EQ(sdbWrite(pSdb, pRaw), 0);
+    pI32Obj = (SI32Obj *)sdbAcquire(pSdb, SDB_VGROUP, &key);
+    ASSERT_EQ(pI32Obj, nullptr);
+    int32_t code = terrno;
+    ASSERT_EQ(code, TSDB_CODE_SDB_OBJ_CREATING);
+  }
+
   sdbCleanup(pSdb);
+  ASSERT_EQ(mnode.insertTimes, 5);
+  ASSERT_EQ(mnode.deleteTimes, 5);
 }

source/dnode/mnode/sdb/inc/sdbInt.h

@@ -31,8 +31,6 @@ extern "C" {
 #define mDebug(...) { if (mDebugFlag & DEBUG_DEBUG) { taosPrintLog("MND ", DEBUG_DEBUG, mDebugFlag, __VA_ARGS__); }}
 #define mTrace(...) { if (mDebugFlag & DEBUG_TRACE) { taosPrintLog("MND ", DEBUG_TRACE, mDebugFlag, __VA_ARGS__); }}
 
-#define SDB_MAX_SIZE (32 * 1024)
-
 typedef struct SSdbRaw {
   int8_t  type;
   int8_t  status;

source/dnode/mnode/sdb/src/sdb.c

@@ -28,12 +28,12 @@ SSdb *sdbInit(SSdbOpt *pOption) {
     return NULL;
   }
 
-  char path[PATH_MAX + 100];
+  char path[PATH_MAX + 100] = {0};
-  snprintf(path, PATH_MAX + 100, "%s%sdata", pOption->path, TD_DIRSEP);
+  snprintf(path, sizeof(path), "%s%sdata", pOption->path, TD_DIRSEP);
   pSdb->currDir = strdup(path);
-  snprintf(path, PATH_MAX + 100, "%s%ssync", pOption->path, TD_DIRSEP);
+  snprintf(path, sizeof(path), "%s%ssync", pOption->path, TD_DIRSEP);
   pSdb->syncDir = strdup(path);
-  snprintf(path, PATH_MAX + 100, "%s%stmp", pOption->path, TD_DIRSEP);
+  snprintf(path, sizeof(path), "%s%stmp", pOption->path, TD_DIRSEP);
   pSdb->tmpDir = strdup(path);
   if (pSdb->currDir == NULL || pSdb->currDir == NULL || pSdb->currDir == NULL) {
     sdbCleanup(pSdb);
@@ -50,7 +50,7 @@ SSdb *sdbInit(SSdbOpt *pOption) {
   for (ESdbType i = 0; i < SDB_MAX; ++i) {
     taosInitRWLatch(&pSdb->locks[i]);
     pSdb->maxId[i] = 0;
-    pSdb->tableVer[i] = -1;
+    pSdb->tableVer[i] = 0;
     pSdb->keyTypes[i] = SDB_KEY_INT32;
   }
 
@@ -99,7 +99,7 @@ void sdbCleanup(SSdb *pSdb) {
     taosHashClear(hash);
     taosHashCleanup(hash);
     pSdb->hashObjs[i] = NULL;
-    mDebug("sdb table:%d is cleaned up", i);
+    mDebug("sdb table:%s is cleaned up", sdbTableName(i));
   }
 
   taosMemoryFree(pSdb);

source/dnode/mnode/sdb/src/sdbFile.c

@@ -18,7 +18,7 @@
 #include "tchecksum.h"
 #include "wal.h"
 
-#define SDB_TABLE_SIZE 24
+#define SDB_TABLE_SIZE   24
 #define SDB_RESERVE_SIZE 512
 
 static int32_t sdbRunDeployFp(SSdb *pSdb) {
@@ -50,7 +50,7 @@ static int32_t sdbReadFileHead(SSdb *pSdb, TdFilePtr pFile) {
   }
 
   for (int32_t i = 0; i < SDB_TABLE_SIZE; ++i) {
-    int64_t maxId = -1;
+    int64_t maxId = 0;
     ret = taosReadFile(pFile, &maxId, sizeof(int64_t));
     if (ret < 0) {
       terrno = TAOS_SYSTEM_ERROR(errno);
@@ -66,7 +66,7 @@ static int32_t sdbReadFileHead(SSdb *pSdb, TdFilePtr pFile) {
   }
 
   for (int32_t i = 0; i < SDB_TABLE_SIZE; ++i) {
-    int64_t ver = -1;
+    int64_t ver = 0;
     ret = taosReadFile(pFile, &ver, sizeof(int64_t));
     if (ret < 0) {
       terrno = TAOS_SYSTEM_ERROR(errno);
@@ -102,7 +102,7 @@ static int32_t sdbWriteFileHead(SSdb *pSdb, TdFilePtr pFile) {
   }
 
   for (int32_t i = 0; i < SDB_TABLE_SIZE; ++i) {
-    int64_t maxId = -1;
+    int64_t maxId = 0;
     if (i < SDB_MAX) {
       maxId = pSdb->maxId[i];
     }
@@ -113,7 +113,7 @@ static int32_t sdbWriteFileHead(SSdb *pSdb, TdFilePtr pFile) {
   }
 
   for (int32_t i = 0; i < SDB_TABLE_SIZE; ++i) {
-    int64_t ver = -1;
+    int64_t ver = 0;
     if (i < SDB_MAX) {
       ver = pSdb->tableVer[i];
     }
@@ -165,6 +165,9 @@ int32_t sdbReadFile(SSdb *pSdb) {
     return -1;
   }
 
+  int64_t tableVer[SDB_MAX] = {0};
+  memcpy(tableVer, pSdb->tableVer, sizeof(tableVer));
+
   while (1) {
     readLen = sizeof(SSdbRaw);
     ret = taosReadFile(pFile, pRaw, readLen);
@@ -206,15 +209,16 @@ int32_t sdbReadFile(SSdb *pSdb) {
     code = sdbWriteWithoutFree(pSdb, pRaw);
     if (code != 0) {
       mError("failed to read file:%s since %s", file, terrstr());
-      goto PARSE_SDB_DATA_ERROR;
+      goto _OVER;
     }
   }
 
   code = 0;
   pSdb->lastCommitVer = pSdb->curVer;
+  memcpy(pSdb->tableVer, tableVer, sizeof(tableVer));
   mDebug("read file:%s successfully, ver:%" PRId64, file, pSdb->lastCommitVer);
 
-PARSE_SDB_DATA_ERROR:
+_OVER:
   taosCloseFile(&pFile);
   sdbFreeRaw(pRaw);
 
@@ -259,7 +263,13 @@ static int32_t sdbWriteFileImp(SSdb *pSdb) {
     SSdbRow **ppRow = taosHashIterate(hash, NULL);
     while (ppRow != NULL) {
       SSdbRow *pRow = *ppRow;
-      if (pRow == NULL || pRow->status != SDB_STATUS_READY) {
+      if (pRow == NULL) {
+        ppRow = taosHashIterate(hash, ppRow);
+        continue;
+      }
+
+      if (pRow->status != SDB_STATUS_READY && pRow->status != SDB_STATUS_DROPPING) {
+        sdbPrintOper(pSdb, pRow, "not-write");
         ppRow = taosHashIterate(hash, ppRow);
         continue;
       }

source/dnode/mnode/sdb/src/sdbHash.c

@@ -16,7 +16,7 @@
 #define _DEFAULT_SOURCE
 #include "sdbInt.h"
 
-static void sdbCheck(SSdb *pSdb, SSdbRow *pRow);
+static void sdbCheckRow(SSdb *pSdb, SSdbRow *pRow);
 
 const char *sdbTableName(ESdbType type) {
   switch (type) {
@@ -65,12 +65,10 @@ const char *sdbTableName(ESdbType type) {
   }
 }
 
-static const char *sdbStatusStr(ESdbStatus status) {
+static const char *sdbStatusName(ESdbStatus status) {
   switch (status) {
     case SDB_STATUS_CREATING:
       return "creating";
-    case SDB_STATUS_UPDATING:
-      return "updating";
     case SDB_STATUS_DROPPING:
       return "dropping";
     case SDB_STATUS_READY:
@@ -89,13 +87,13 @@ void sdbPrintOper(SSdb *pSdb, SSdbRow *pRow, const char *oper) {
 
   if (keyType == SDB_KEY_BINARY) {
     mTrace("%s:%s, ref:%d oper:%s row:%p status:%s", sdbTableName(pRow->type), (char *)pRow->pObj, pRow->refCount, oper,
-           pRow->pObj, sdbStatusStr(pRow->status));
+           pRow->pObj, sdbStatusName(pRow->status));
   } else if (keyType == SDB_KEY_INT32) {
     mTrace("%s:%d, ref:%d oper:%s row:%p status:%s", sdbTableName(pRow->type), *(int32_t *)pRow->pObj, pRow->refCount,
-           oper, pRow->pObj, sdbStatusStr(pRow->status));
+           oper, pRow->pObj, sdbStatusName(pRow->status));
   } else if (keyType == SDB_KEY_INT64) {
     mTrace("%s:%" PRId64 ", ref:%d oper:%s row:%p status:%s", sdbTableName(pRow->type), *(int64_t *)pRow->pObj,
-           pRow->refCount, oper, pRow->pObj, sdbStatusStr(pRow->status));
+           pRow->refCount, oper, pRow->pObj, sdbStatusName(pRow->status));
   } else {
   }
 }
@@ -116,7 +114,7 @@ static SHashObj *sdbGetHash(SSdb *pSdb, int32_t type) {
 }
 
 static int32_t sdbGetkeySize(SSdb *pSdb, ESdbType type, const void *pKey) {
-  int32_t  keySize;
+  int32_t  keySize = 0;
   EKeyType keyType = pSdb->keyTypes[type];
 
   if (keyType == SDB_KEY_INT32) {
@@ -149,7 +147,7 @@ static int32_t sdbInsertRow(SSdb *pSdb, SHashObj *hash, SSdbRaw *pRaw, SSdbRow *
   if (taosHashPut(hash, pRow->pObj, keySize, &pRow, sizeof(void *)) != 0) {
     taosWUnLockLatch(pLock);
     sdbFreeRow(pSdb, pRow, false);
-    terrno = TSDB_CODE_SDB_OBJ_ALREADY_THERE;
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
     return terrno;
   }
 
@@ -183,18 +181,18 @@ static int32_t sdbInsertRow(SSdb *pSdb, SHashObj *hash, SSdbRaw *pRaw, SSdbRow *
 
 static int32_t sdbUpdateRow(SSdb *pSdb, SHashObj *hash, SSdbRaw *pRaw, SSdbRow *pNewRow, int32_t keySize) {
   SRWLatch *pLock = &pSdb->locks[pNewRow->type];
-  taosRLockLatch(pLock);
+  taosWLockLatch(pLock);
 
   SSdbRow **ppOldRow = taosHashGet(hash, pNewRow->pObj, keySize);
   if (ppOldRow == NULL || *ppOldRow == NULL) {
-    taosRUnLockLatch(pLock);
+    taosWUnLockLatch(pLock);
     return sdbInsertRow(pSdb, hash, pRaw, pNewRow, keySize);
   }
 
   SSdbRow *pOldRow = *ppOldRow;
   pOldRow->status = pRaw->status;
   sdbPrintOper(pSdb, pOldRow, "update");
-  taosRUnLockLatch(pLock);
+  taosWUnLockLatch(pLock);
 
   int32_t     code = 0;
   SdbUpdateFp updateFp = pSdb->updateFps[pNewRow->type];
@@ -230,8 +228,7 @@ static int32_t sdbDeleteRow(SSdb *pSdb, SHashObj *hash, SSdbRaw *pRaw, SSdbRow *
   pSdb->tableVer[pOldRow->type]++;
   sdbFreeRow(pSdb, pRow, false);
 
-  sdbCheck(pSdb, pOldRow);
+  sdbCheckRow(pSdb, pOldRow);
-  // sdbRelease(pSdb, pOldRow->pObj);
   return 0;
 }
 
@@ -254,7 +251,6 @@ int32_t sdbWriteWithoutFree(SSdb *pSdb, SSdbRaw *pRaw) {
     case SDB_STATUS_CREATING:
       code = sdbInsertRow(pSdb, hash, pRaw, pRow, keySize);
       break;
-    case SDB_STATUS_UPDATING:
     case SDB_STATUS_READY:
     case SDB_STATUS_DROPPING:
       code = sdbUpdateRow(pSdb, hash, pRaw, pRow, keySize);
@@ -295,7 +291,6 @@ void *sdbAcquire(SSdb *pSdb, ESdbType type, const void *pKey) {
   SSdbRow *pRow = *ppRow;
   switch (pRow->status) {
     case SDB_STATUS_READY:
-    case SDB_STATUS_UPDATING:
       atomic_add_fetch_32(&pRow->refCount, 1);
       pRet = pRow->pObj;
       sdbPrintOper(pSdb, pRow, "acquire");
@@ -315,9 +310,9 @@ void *sdbAcquire(SSdb *pSdb, ESdbType type, const void *pKey) {
   return pRet;
 }
 
-static void sdbCheck(SSdb *pSdb, SSdbRow *pRow) {
+static void sdbCheckRow(SSdb *pSdb, SSdbRow *pRow) {
   SRWLatch *pLock = &pSdb->locks[pRow->type];
-  taosRLockLatch(pLock);
+  taosWLockLatch(pLock);
 
   int32_t ref = atomic_load_32(&pRow->refCount);
   sdbPrintOper(pSdb, pRow, "check");
@@ -325,7 +320,7 @@ static void sdbCheck(SSdb *pSdb, SSdbRow *pRow) {
     sdbFreeRow(pSdb, pRow, true);
   }
 
-  taosRUnLockLatch(pLock);
+  taosWUnLockLatch(pLock);
 }
 
 void sdbRelease(SSdb *pSdb, void *pObj) {
@@ -335,7 +330,7 @@ void sdbRelease(SSdb *pSdb, void *pObj) {
   if (pRow->type >= SDB_MAX) return;
 
   SRWLatch *pLock = &pSdb->locks[pRow->type];
-  taosRLockLatch(pLock);
+  taosWLockLatch(pLock);
 
   int32_t ref = atomic_sub_fetch_32(&pRow->refCount, 1);
   sdbPrintOper(pSdb, pRow, "release");
@@ -343,7 +338,7 @@ void sdbRelease(SSdb *pSdb, void *pObj) {
     sdbFreeRow(pSdb, pRow, true);
   }
 
-  taosRUnLockLatch(pLock);
+  taosWUnLockLatch(pLock);
 }
 
 void *sdbFetch(SSdb *pSdb, ESdbType type, void *pIter, void **ppObj) {
@@ -355,16 +350,6 @@ void *sdbFetch(SSdb *pSdb, ESdbType type, void *pIter, void **ppObj) {
   SRWLatch *pLock = &pSdb->locks[type];
   taosRLockLatch(pLock);
 
-#if 0
-  if (pIter != NULL) {
-    SSdbRow *pLastRow = *(SSdbRow **)pIter;
-    int32_t  ref = atomic_load_32(&pLastRow->refCount);
-    if (ref <= 0 && pLastRow->status == SDB_STATUS_DROPPED) {
-      sdbFreeRow(pSdb, pLastRow);
-    }
-  }
-#endif
-
   SSdbRow **ppRow = taosHashIterate(hash, pIter);
   while (ppRow != NULL) {
     SSdbRow *pRow = *ppRow;

source/dnode/mnode/sdb/src/sdbRaw.c

@@ -134,6 +134,11 @@ int32_t sdbSetRawStatus(SSdbRaw *pRaw, ESdbStatus status) {
     return -1;
   }
 
+  if (status == SDB_STATUS_INIT) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return -1;
+  }
+
   pRaw->status = status;
   return 0;
 }

source/dnode/qnode/inc/qndInt.h

@@ -29,7 +29,7 @@
 extern "C" {
 #endif
 
-typedef struct SQWorkerMgmt SQHandle;
+typedef struct SQWorker SQHandle;
 
 typedef struct SQnode {
   int32_t   qndId;

source/dnode/vnode/CMakeLists.txt

@@ -8,7 +8,6 @@ target_sources(
     "src/vnd/vnodeBufPool.c"
     "src/vnd/vnodeCfg.c"
     "src/vnd/vnodeCommit.c"
-    "src/vnd/vnodeInt.c"
     "src/vnd/vnodeQuery.c"
     "src/vnd/vnodeStateMgr.c"
     "src/vnd/vnodeModule.c"
@@ -33,7 +32,6 @@ target_sources(
     "src/tsdb/tsdbMemTable.c"
     "src/tsdb/tsdbRead.c"
     "src/tsdb/tsdbReadImpl.c"
-    "src/tsdb/tsdbScan.c"
     "src/tsdb/tsdbSma.c"
     "src/tsdb/tsdbWrite.c"
 

source/dnode/vnode/inc/vnode.h

@@ -32,12 +32,12 @@
 #include "tmsg.h"
 #include "trow.h"
 
-#include "tdbInt.h"
+#include "tdb.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
-
+#define TSDB_VNODE_SMA_DEBUG  // TODO: evaluate to remove the macro and the relative codes
 // vnode
 typedef struct SVnode    SVnode;
 typedef struct STsdbCfg  STsdbCfg;  // todo: remove
@@ -57,9 +57,6 @@ int     vnodeProcessCMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp);
 int     vnodeProcessSyncReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp);
 int     vnodeProcessQueryMsg(SVnode *pVnode, SRpcMsg *pMsg);
 int     vnodeProcessFetchMsg(SVnode *pVnode, SRpcMsg *pMsg, SQueueInfo *pInfo);
-int32_t vnodeAlter(SVnode *pVnode, const SVnodeCfg *pCfg);
-int32_t vnodeCompact(SVnode *pVnode);
-int32_t vnodeSync(SVnode *pVnode);
 int32_t vnodeGetLoad(SVnode *pVnode, SVnodeLoad *pLoad);
 int     vnodeValidateTableHash(SVnode *pVnode, char *tableFName);
 
@@ -146,9 +143,19 @@ struct STsdbCfg {
   int32_t keep0;
   int32_t keep1;
   int32_t keep2;
-  SArray *retentions;
+  // TODO: save to tsdb cfg file
+  int8_t     type;  // ETsdbType
+  SRetention retentions[TSDB_RSMA_RETENTION_MAX];
 };
 
+typedef enum {
+  TSDB_TYPE_TSDB = 0,     // TSDB
+  TSDB_TYPE_TSMA = 1,     // TSMA
+  TSDB_TYPE_RSMA_L0 = 2,  // RSMA Level 0
+  TSDB_TYPE_RSMA_L1 = 3,  // RSMA Level 1
+  TSDB_TYPE_RSMA_L2 = 4,  // RSMA Level 2
+} ETsdbType;
+
 struct SVnodeCfg {
   int32_t  vgId;
   char     dbname[TSDB_DB_NAME_LEN];

source/dnode/vnode/src/inc/meta.h

@@ -43,7 +43,6 @@ int metaEncodeEntry(SCoder* pCoder, const SMetaEntry* pME);
 int metaDecodeEntry(SCoder* pCoder, SMetaEntry* pME);
 
 // metaTable ==================
-int metaDropSTable(SMeta* pMeta, int64_t verison, SVDropStbReq* pReq);
 
 // metaQuery ==================
 int metaGetTableEntryByVersion(SMetaReader* pReader, int64_t version, tb_uid_t uid);

source/dnode/vnode/src/inc/tsdb.h

@@ -73,7 +73,6 @@ struct STsdb {
   SVnode        *pVnode;
   bool           repoLocked;
   TdThreadMutex  mutex;
-  STsdbCfg       config;
   STsdbMemTable *mem;
   STsdbMemTable *imem;
   SRtn           rtn;
@@ -185,7 +184,7 @@ struct STsdbFS {
 };
 
 #define REPO_ID(r)        TD_VID((r)->pVnode)
-#define REPO_CFG(r)       (&(r)->config)
+#define REPO_CFG(r)       (&(r)->pVnode->config.tsdbCfg)
 #define REPO_FS(r)        ((r)->fs)
 #define REPO_META(r)      ((r)->pVnode->pMeta)
 #define REPO_TFS(r)       ((r)->pVnode->pTfs)
@@ -534,23 +533,6 @@ static FORCE_INLINE int tsdbGetFidLevel(int fid, SRtn *pRtn) {
   }
 }
 
-// tsdbDBDef
-// typedef struct SDBFile SDBFile;
-// typedef DB_ENV*        TDBEnv;
-
-// struct SDBFile {
-//   int32_t fid;
-//   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);
-// void*   tsdbGetSmaDataByKey(SDBFile* pDBF, void* key, uint32_t keySize, uint32_t* valueSize);
-
 // tsdbFile
 #define TSDB_FILE_HEAD_SIZE  512
 #define TSDB_FILE_DELIMITER  0xF00AFA0F

source/dnode/vnode/src/inc/vnodeInt.h

@@ -25,7 +25,7 @@
 #include "tcompare.h"
 #include "tcompression.h"
 #include "tdatablock.h"
-#include "tdbInt.h"
+#include "tdb.h"
 #include "tencode.h"
 #include "tfs.h"
 #include "tglobal.h"
@@ -52,12 +52,15 @@ typedef struct STsdb        STsdb;
 typedef struct STQ          STQ;
 typedef struct SVState      SVState;
 typedef struct SVBufPool    SVBufPool;
-typedef struct SQWorkerMgmt SQHandle;
+typedef struct SQWorker SQHandle;
 
-#define VNODE_META_DIR "meta"
+#define VNODE_META_DIR  "meta"
-#define VNODE_TSDB_DIR "tsdb"
+#define VNODE_TSDB_DIR  "tsdb"
-#define VNODE_TQ_DIR   "tq"
+#define VNODE_TQ_DIR    "tq"
-#define VNODE_WAL_DIR  "wal"
+#define VNODE_WAL_DIR   "wal"
+#define VNODE_TSMA_DIR  "tsma"
+#define VNODE_RSMA1_DIR "rsma1"
+#define VNODE_RSMA2_DIR "rsma2"
 
 // vnd.h
 void* vnodeBufPoolMalloc(SVBufPool* pPool, int size);
@@ -72,6 +75,7 @@ int             metaClose(SMeta* pMeta);
 int             metaBegin(SMeta* pMeta);
 int             metaCommit(SMeta* pMeta);
 int             metaCreateSTable(SMeta* pMeta, int64_t version, SVCreateStbReq* pReq);
+int             metaDropSTable(SMeta* pMeta, int64_t verison, SVDropStbReq* pReq);
 int             metaCreateTable(SMeta* pMeta, int64_t version, SVCreateTbReq* pReq);
 SSchemaWrapper* metaGetTableSchema(SMeta* pMeta, tb_uid_t uid, int32_t sver, bool isinline);
 STSchema*       metaGetTbTSchema(SMeta* pMeta, tb_uid_t uid, int32_t sver);
@@ -87,7 +91,7 @@ int32_t         metaCreateTSma(SMeta* pMeta, SSmaCfg* pCfg);
 int32_t         metaDropTSma(SMeta* pMeta, int64_t indexUid);
 
 // tsdb
-int          tsdbOpen(SVnode* pVnode, STsdb** ppTsdb);
+int          tsdbOpen(SVnode* pVnode, int8_t type);
 int          tsdbClose(STsdb* pTsdb);
 int          tsdbBegin(STsdb* pTsdb);
 int          tsdbCommit(STsdb* pTsdb);
@@ -95,7 +99,7 @@ int32_t      tsdbUpdateSmaWindow(STsdb* pTsdb, SSubmitReq* pMsg, int64_t version
 int32_t      tsdbCreateTSma(STsdb* pTsdb, char* pMsg);
 int32_t      tsdbInsertTSmaData(STsdb* pTsdb, int64_t indexUid, const char* msg);
 int          tsdbInsertData(STsdb* pTsdb, int64_t version, SSubmitReq* pMsg, SSubmitRsp* pRsp);
-tsdbReaderT* tsdbQueryTablesT(STsdb* tsdb, SQueryTableDataCond* pCond, STableGroupInfo* groupList, uint64_t qId,
+tsdbReaderT* tsdbQueryTables(SVnode* pVnode, SQueryTableDataCond* pCond, STableGroupInfo* groupList, uint64_t qId,
                               uint64_t taskId);
 tsdbReaderT  tsdbQueryCacheLastT(STsdb* tsdb, SQueryTableDataCond* pCond, STableGroupInfo* groupList, uint64_t qId,
                                  void* pMemRef);
@@ -160,6 +164,8 @@ struct SVnode {
   SVBufPool* onRecycle;
   SMeta*     pMeta;
   STsdb*     pTsdb;
+  STsdb*     pRSma1;
+  STsdb*     pRSma2;
   SWal*      pWal;
   STQ*       pTq;
   SSink*     pSink;
@@ -168,6 +174,11 @@ struct SVnode {
   SQHandle*  pQuery;
 };
 
+#define VND_TSDB(vnd)  ((vnd)->pTsdb)
+#define VND_RSMA0(vnd) ((vnd)->pTsdb)
+#define VND_RSMA1(vnd) ((vnd)->pRSma1)
+#define VND_RSMA2(vnd) ((vnd)->pRSma2)
+
 struct STbUidStore {
   tb_uid_t  suid;
   SArray*   tbUids;
@@ -176,7 +187,11 @@ struct STbUidStore {
 
 #define TD_VID(PVNODE) (PVNODE)->config.vgId
 
-// typedef struct STbDdlH STbDdlH;
+
+static FORCE_INLINE bool tsdbIsRollup(SVnode* pVnode) {
+  SRetention* pRetention = &(pVnode->config.tsdbCfg.retentions[0]);
+  return (pRetention->freq > 0 && pRetention->keep > 0);
+}
 
 // sma
 void smaHandleRes(void* pVnode, int64_t smaId, const SArray* data);

source/dnode/vnode/src/meta/metaOpen.c

@@ -47,66 +47,66 @@ int metaOpen(SVnode *pVnode, SMeta **ppMeta) {
   // open env
   ret = tdbEnvOpen(pMeta->path, pVnode->config.szPage, pVnode->config.szCache, &pMeta->pEnv);
   if (ret < 0) {
-    metaError("vgId: %d failed to open meta env since %s", TD_VID(pVnode), tstrerror(terrno));
+    metaError("vgId:%d failed to open meta env since %s", TD_VID(pVnode), tstrerror(terrno));
     goto _err;
   }
 
   // open pTbDb
   ret = tdbDbOpen("table.db", sizeof(STbDbKey), -1, tbDbKeyCmpr, pMeta->pEnv, &pMeta->pTbDb);
   if (ret < 0) {
-    metaError("vgId: %d failed to open meta table db since %s", TD_VID(pVnode), tstrerror(terrno));
+    metaError("vgId:%d failed to open meta table db since %s", TD_VID(pVnode), tstrerror(terrno));
     goto _err;
   }
 
   // open pSkmDb
   ret = tdbDbOpen("schema.db", sizeof(SSkmDbKey), -1, skmDbKeyCmpr, pMeta->pEnv, &pMeta->pSkmDb);
   if (ret < 0) {
-    metaError("vgId: %d failed to open meta schema db since %s", TD_VID(pVnode), tstrerror(terrno));
+    metaError("vgId:%d failed to open meta schema db since %s", TD_VID(pVnode), tstrerror(terrno));
     goto _err;
   }
 
   // open pUidIdx
   ret = tdbDbOpen("uid.idx", sizeof(tb_uid_t), sizeof(int64_t), uidIdxKeyCmpr, pMeta->pEnv, &pMeta->pUidIdx);
   if (ret < 0) {
-    metaError("vgId: %d failed to open meta uid idx since %s", TD_VID(pVnode), tstrerror(terrno));
+    metaError("vgId:%d failed to open meta uid idx since %s", TD_VID(pVnode), tstrerror(terrno));
     goto _err;
   }
 
   // open pNameIdx
   ret = tdbDbOpen("name.idx", -1, sizeof(tb_uid_t), NULL, pMeta->pEnv, &pMeta->pNameIdx);
   if (ret < 0) {
-    metaError("vgId: %d failed to open meta name index since %s", TD_VID(pVnode), tstrerror(terrno));
+    metaError("vgId:%d failed to open meta name index since %s", TD_VID(pVnode), tstrerror(terrno));
     goto _err;
   }
 
   // open pCtbIdx
   ret = tdbDbOpen("ctb.idx", sizeof(SCtbIdxKey), 0, ctbIdxKeyCmpr, pMeta->pEnv, &pMeta->pCtbIdx);
   if (ret < 0) {
-    metaError("vgId: %d failed to open meta child table index since %s", TD_VID(pVnode), tstrerror(terrno));
+    metaError("vgId:%d failed to open meta child table index since %s", TD_VID(pVnode), tstrerror(terrno));
     goto _err;
   }
 
   // open pTagIdx
   ret = tdbDbOpen("tag.idx", -1, 0, tagIdxKeyCmpr, pMeta->pEnv, &pMeta->pTagIdx);
   if (ret < 0) {
-    metaError("vgId: %d failed to open meta tag index since %s", TD_VID(pVnode), tstrerror(terrno));
+    metaError("vgId:%d failed to open meta tag index since %s", TD_VID(pVnode), tstrerror(terrno));
     goto _err;
   }
 
   // open pTtlIdx
   ret = tdbDbOpen("ttl.idx", sizeof(STtlIdxKey), 0, ttlIdxKeyCmpr, pMeta->pEnv, &pMeta->pTtlIdx);
   if (ret < 0) {
-    metaError("vgId: %d failed to open meta ttl index since %s", TD_VID(pVnode), tstrerror(terrno));
+    metaError("vgId:%d failed to open meta ttl index since %s", TD_VID(pVnode), tstrerror(terrno));
     goto _err;
   }
 
   // open index
   if (metaOpenIdx(pMeta) < 0) {
-    metaError("vgId: %d failed to open meta index since %s", TD_VID(pVnode), tstrerror(terrno));
+    metaError("vgId:%d failed to open meta index since %s", TD_VID(pVnode), tstrerror(terrno));
     goto _err;
   }
 
-  metaDebug("vgId: %d meta is opened", TD_VID(pVnode));
+  metaDebug("vgId:%d meta is opened", TD_VID(pVnode));
 
   *ppMeta = pMeta;
   return 0;

source/dnode/vnode/src/meta/metaQuery.c

@@ -23,7 +23,7 @@ void metaReaderInit(SMetaReader *pReader, SMeta *pMeta, int32_t flags) {
 
 void metaReaderClear(SMetaReader *pReader) {
   tCoderClear(&pReader->coder);
-  TDB_FREE(pReader->pBuf);
+  tdbFree(pReader->pBuf);
 }
 
 int metaGetTableEntryByVersion(SMetaReader *pReader, int64_t version, tb_uid_t uid) {
@@ -96,15 +96,17 @@ SMTbCursor *metaOpenTbCursor(SMeta *pMeta) {
 
   metaReaderInit(&pTbCur->mr, pMeta, 0);
 
-  tdbDbcOpen(pMeta->pUidIdx, &pTbCur->pDbc);
+  tdbDbcOpen(pMeta->pUidIdx, &pTbCur->pDbc, NULL);
+
+  tdbDbcMoveToFirst(pTbCur->pDbc);
 
   return pTbCur;
 }
 
 void metaCloseTbCursor(SMTbCursor *pTbCur) {
   if (pTbCur) {
-    TDB_FREE(pTbCur->pKey);
+    tdbFree(pTbCur->pKey);
-    TDB_FREE(pTbCur->pVal);
+    tdbFree(pTbCur->pVal);
     metaReaderClear(&pTbCur->mr);
     if (pTbCur->pDbc) {
       tdbDbcClose(pTbCur->pDbc);
@@ -119,7 +121,7 @@ int metaTbCursorNext(SMTbCursor *pTbCur) {
   STbCfg tbCfg;
 
   for (;;) {
-    ret = tdbDbNext(pTbCur->pDbc, &pTbCur->pKey, &pTbCur->kLen, &pTbCur->pVal, &pTbCur->vLen);
+    ret = tdbDbcNext(pTbCur->pDbc, &pTbCur->pKey, &pTbCur->kLen, &pTbCur->pVal, &pTbCur->vLen);
     if (ret < 0) {
       return -1;
     }
@@ -169,7 +171,7 @@ SSchemaWrapper *metaGetTableSchema(SMeta *pMeta, tb_uid_t uid, int32_t sver, boo
 
   pSW->pSchema = pSchema;
 
-  TDB_FREE(pVal);
+  tdbFree(pVal);
 
   return pSW;
 }
@@ -185,7 +187,9 @@ struct SMCtbCursor {
 
 SMCtbCursor *metaOpenCtbCursor(SMeta *pMeta, tb_uid_t uid) {
   SMCtbCursor *pCtbCur = NULL;
+  SCtbIdxKey   ctbIdxKey;
   int          ret;
+  int          c;
 
   pCtbCur = (SMCtbCursor *)taosMemoryCalloc(1, sizeof(*pCtbCur));
   if (pCtbCur == NULL) {
@@ -193,12 +197,20 @@ SMCtbCursor *metaOpenCtbCursor(SMeta *pMeta, tb_uid_t uid) {
   }
 
   pCtbCur->suid = uid;
-  ret = tdbDbcOpen(pMeta->pCtbIdx, &pCtbCur->pCur);
+  ret = tdbDbcOpen(pMeta->pCtbIdx, &pCtbCur->pCur, NULL);
   if (ret < 0) {
     taosMemoryFree(pCtbCur);
     return NULL;
   }
 
+  // move to the suid
+  ctbIdxKey.suid = uid;
+  ctbIdxKey.uid = INT64_MIN;
+  tdbDbcMoveTo(pCtbCur->pCur, &ctbIdxKey, sizeof(ctbIdxKey), &c);
+  if (c > 0) {
+    tdbDbcMoveToNext(pCtbCur->pCur);
+  }
+
   return pCtbCur;
 }
 
@@ -207,8 +219,8 @@ void metaCloseCtbCurosr(SMCtbCursor *pCtbCur) {
     if (pCtbCur->pCur) {
       tdbDbcClose(pCtbCur->pCur);
 
-      TDB_FREE(pCtbCur->pKey);
+      tdbFree(pCtbCur->pKey);
-      TDB_FREE(pCtbCur->pVal);
+      tdbFree(pCtbCur->pVal);
     }
 
     taosMemoryFree(pCtbCur);
@@ -219,12 +231,15 @@ tb_uid_t metaCtbCursorNext(SMCtbCursor *pCtbCur) {
   int         ret;
   SCtbIdxKey *pCtbIdxKey;
 
-  ret = tdbDbNext(pCtbCur->pCur, &pCtbCur->pKey, &pCtbCur->kLen, &pCtbCur->pVal, &pCtbCur->vLen);
+  ret = tdbDbcNext(pCtbCur->pCur, &pCtbCur->pKey, &pCtbCur->kLen, &pCtbCur->pVal, &pCtbCur->vLen);
   if (ret < 0) {
     return 0;
   }
 
   pCtbIdxKey = pCtbCur->pKey;
+  if (pCtbIdxKey->suid > pCtbCur->suid) {
+    return 0;
+  }
 
   return pCtbIdxKey->uid;
 }
@@ -283,7 +298,7 @@ STSmaWrapper *metaGetSmaInfoByTable(SMeta *pMeta, tb_uid_t uid) {
 
   while (true) {
     // TODO: lock during iterate?
-    if (tdbDbNext(pCur->pCur, &pCur->pKey, &pCur->kLen, NULL, &pCur->vLen) == 0) {
+    if (tdbDbcNext(pCur->pCur, &pCur->pKey, &pCur->kLen, NULL, &pCur->vLen) == 0) {
       pSmaIdxKey = pCur->pKey;
       ASSERT(pSmaIdxKey != NULL);
 
@@ -297,7 +312,7 @@ STSmaWrapper *metaGetSmaInfoByTable(SMeta *pMeta, tb_uid_t uid) {
       ++pSW->number;
       STSma *tptr = (STSma *)taosMemoryRealloc(pSW->tSma, pSW->number * sizeof(STSma));
       if (tptr == NULL) {
-        TDB_FREE(pSmaVal);
+        tdbFree(pSmaVal);
         metaCloseSmaCursor(pCur);
         tdDestroyTSmaWrapper(pSW);
         taosMemoryFreeClear(pSW);
@@ -306,13 +321,13 @@ STSmaWrapper *metaGetSmaInfoByTable(SMeta *pMeta, tb_uid_t uid) {
       pSW->tSma = tptr;
       pBuf = pSmaVal;
       if (tDecodeTSma(pBuf, pSW->tSma + pSW->number - 1) == NULL) {
-        TDB_FREE(pSmaVal);
+        tdbFree(pSmaVal);
         metaCloseSmaCursor(pCur);
         tdDestroyTSmaWrapper(pSW);
         taosMemoryFreeClear(pSW);
         return NULL;
       }
-      TDB_FREE(pSmaVal);
+      tdbFree(pSmaVal);
       continue;
     }
     break;
@@ -354,7 +369,7 @@ SArray *metaGetSmaTbUids(SMeta *pMeta, bool isDup) {
   tb_uid_t    uid = 0;
   while (true) {
     // TODO: lock during iterate?
-    if (tdbDbNext(pCur->pCur, &pCur->pKey, &pCur->kLen, NULL, &pCur->vLen) == 0) {
+    if (tdbDbcNext(pCur->pCur, &pCur->pKey, &pCur->kLen, NULL, &pCur->vLen) == 0) {
       ASSERT(pSmaIdxKey != NULL);
       pSmaIdxKey = pCur->pKey;
 
@@ -425,11 +440,11 @@ void *metaGetSmaInfoByIndex(SMeta *pMeta, int64_t indexUid, bool isDecode) {
   if (tDecodeTSma(pBuf, pCfg) == NULL) {
     tdDestroyTSma(pCfg);
     taosMemoryFree(pCfg);
-    TDB_FREE(pVal);
+    tdbFree(pVal);
     return NULL;
   }
 
-  TDB_FREE(pVal);
+  tdbFree(pVal);
   return pCfg;
 #endif
 #endif

source/dnode/vnode/src/meta/metaTDBImpl.c

@@ -289,7 +289,7 @@ int metaSaveTableToDB(SMeta *pMeta, STbCfg *pTbCfg, STbDdlH *pHandle) {
   pVal = pBuf = buf;
   metaEncodeTbInfo(&pBuf, pTbCfg);
   vLen = POINTER_DISTANCE(pBuf, buf);
-  ret = tdbDbInsert(pMetaDb->pTbDB, pKey, kLen, pVal, vLen, &pMetaDb->txn);
+  ret = tdbDbPut(pMetaDb->pTbDB, pKey, kLen, pVal, vLen, &pMetaDb->txn);
   if (ret < 0) {
     return -1;
   }
@@ -311,7 +311,7 @@ int metaSaveTableToDB(SMeta *pMeta, STbCfg *pTbCfg, STbDdlH *pHandle) {
     pVal = pBuf = buf;
     metaEncodeSchemaEx(&pBuf, &schemaWrapper);
     vLen = POINTER_DISTANCE(pBuf, buf);
-    ret = tdbDbInsert(pMetaDb->pSchemaDB, pKey, kLen, pVal, vLen, &pMeta->pDB->txn);
+    ret = tdbDbPut(pMetaDb->pSchemaDB, pKey, kLen, pVal, vLen, &pMeta->pDB->txn);
     if (ret < 0) {
       return -1;
     }
@@ -325,7 +325,7 @@ int metaSaveTableToDB(SMeta *pMeta, STbCfg *pTbCfg, STbDdlH *pHandle) {
   kLen = nameLen + 1 + sizeof(uid);
   pVal = NULL;
   vLen = 0;
-  ret = tdbDbInsert(pMetaDb->pNameIdx, pKey, kLen, pVal, vLen, &pMetaDb->txn);
+  ret = tdbDbPut(pMetaDb->pNameIdx, pKey, kLen, pVal, vLen, &pMetaDb->txn);
   if (ret < 0) {
     return -1;
   }
@@ -336,7 +336,7 @@ int metaSaveTableToDB(SMeta *pMeta, STbCfg *pTbCfg, STbDdlH *pHandle) {
     kLen = sizeof(uid);
     pVal = NULL;
     vLen = 0;
-    ret = tdbDbInsert(pMetaDb->pStbIdx, pKey, kLen, pVal, vLen, &pMetaDb->txn);
+    ret = tdbDbPut(pMetaDb->pStbIdx, pKey, kLen, pVal, vLen, &pMetaDb->txn);
     if (ret < 0) {
       return -1;
     }
@@ -347,7 +347,7 @@ int metaSaveTableToDB(SMeta *pMeta, STbCfg *pTbCfg, STbDdlH *pHandle) {
     kLen = sizeof(ctbIdxKey);
     pVal = NULL;
     vLen = 0;
-    ret = tdbDbInsert(pMetaDb->pCtbIdx, pKey, kLen, pVal, vLen, &pMetaDb->txn);
+    ret = tdbDbPut(pMetaDb->pCtbIdx, pKey, kLen, pVal, vLen, &pMetaDb->txn);
     if (ret < 0) {
       return -1;
     }
@@ -362,7 +362,7 @@ int metaSaveTableToDB(SMeta *pMeta, STbCfg *pTbCfg, STbDdlH *pHandle) {
     kLen = sizeof(uid);
     pVal = NULL;
     vLen = 0;
-    ret = tdbDbInsert(pMetaDb->pNtbIdx, pKey, kLen, pVal, vLen, &pMetaDb->txn);
+    ret = tdbDbPut(pMetaDb->pNtbIdx, pKey, kLen, pVal, vLen, &pMetaDb->txn);
     if (ret < 0) {
       return -1;
     }
@@ -407,7 +407,7 @@ static SSchemaWrapper *metaGetTableSchemaImpl(SMeta *pMeta, tb_uid_t uid, int32_
   pSchemaWrapper = taosMemoryMalloc(sizeof(*pSchemaWrapper));
   metaDecodeSchemaEx(pBuf, pSchemaWrapper, isGetEx);
 
-  TDB_FREE(pVal);
+  tdbFree(pVal);
 
   return pSchemaWrapper;
 }
@@ -438,7 +438,7 @@ STSmaWrapper *metaGetSmaInfoByTable(SMeta *pMeta, tb_uid_t uid) {
 
   while (true) {
     // TODO: lock during iterate?
-    if (tdbDbNext(pCur->pCur, &pCur->pKey, &pCur->kLen, NULL, &pCur->vLen) == 0) {
+    if (tdbDbcNext(pCur->pCur, &pCur->pKey, &pCur->kLen, NULL, &pCur->vLen) == 0) {
       pSmaIdxKey = pCur->pKey;
       ASSERT(pSmaIdxKey != NULL);
 
@@ -450,7 +450,7 @@ STSmaWrapper *metaGetSmaInfoByTable(SMeta *pMeta, tb_uid_t uid) {
       }
 
       if ((pSW == NULL) && ((pSW = taosMemoryCalloc(1, sizeof(*pSW))) == NULL)) {
-        TDB_FREE(pSmaVal);
+        tdbFree(pSmaVal);
         metaCloseSmaCursor(pCur);
         return NULL;
       }
@@ -458,7 +458,7 @@ STSmaWrapper *metaGetSmaInfoByTable(SMeta *pMeta, tb_uid_t uid) {
       ++pSW->number;
       STSma *tptr = (STSma *)taosMemoryRealloc(pSW->tSma, pSW->number * sizeof(STSma));
       if (tptr == NULL) {
-        TDB_FREE(pSmaVal);
+        tdbFree(pSmaVal);
         metaCloseSmaCursor(pCur);
         tdDestroyTSmaWrapper(pSW);
         taosMemoryFreeClear(pSW);
@@ -467,13 +467,13 @@ STSmaWrapper *metaGetSmaInfoByTable(SMeta *pMeta, tb_uid_t uid) {
       pSW->tSma = tptr;
       pBuf = pSmaVal;
       if (tDecodeTSma(pBuf, pSW->tSma + pSW->number - 1) == NULL) {
-        TDB_FREE(pSmaVal);
+        tdbFree(pSmaVal);
         metaCloseSmaCursor(pCur);
         tdDestroyTSmaWrapper(pSW);
         taosMemoryFreeClear(pSW);
         return NULL;
       }
-      TDB_FREE(pSmaVal);
+      tdbFree(pSmaVal);
       continue;
     }
     break;
@@ -530,7 +530,7 @@ int metaSaveSmaToDB(SMeta *pMeta, STSma *pSmaCfg) {
   int32_t kLen = sizeof(pSmaCfg->indexUid);
   int32_t vLen = POINTER_DISTANCE(qBuf, pBuf);
 
-  ret = tdbDbInsert(pMeta->pDB->pSmaDB, key, kLen, val, vLen, &pMetaDb->txn);
+  ret = tdbDbPut(pMeta->pDB->pSmaDB, key, kLen, val, vLen, &pMetaDb->txn);
   if (ret < 0) {
     taosMemoryFreeClear(pBuf);
     return -1;
@@ -545,7 +545,7 @@ int metaSaveSmaToDB(SMeta *pMeta, STSma *pSmaCfg) {
   val = NULL;
   vLen = 0;
 
-  ret = tdbDbInsert(pMeta->pDB->pSmaIdx, key, kLen, val, vLen, &pMetaDb->txn);
+  ret = tdbDbPut(pMeta->pDB->pSmaIdx, key, kLen, val, vLen, &pMetaDb->txn);
   if (ret < 0) {
     taosMemoryFreeClear(pBuf);
     return -1;
@@ -613,7 +613,7 @@ int64_t metaSmaCursorNext(SMSmaCursor *pCur) {
   void       *pBuf;
   SSmaIdxKey *smaIdxKey;
 
-  ret = tdbDbNext(pCur->pCur, &pCur->pKey, &pCur->kLen, &pCur->pVal, &pCur->vLen);
+  ret = tdbDbcNext(pCur->pCur, &pCur->pKey, &pCur->kLen, &pCur->pVal, &pCur->vLen);
   if (ret < 0) {
     return 0;
   }

source/dnode/vnode/src/meta/metaTable.c

@@ -61,19 +61,58 @@ int metaCreateSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
 
   if (metaHandleEntry(pMeta, &me) < 0) goto _err;
 
-  metaDebug("vgId: %d super table is created, name:%s uid: %" PRId64, TD_VID(pMeta->pVnode), pReq->name, pReq->suid);
+  metaDebug("vgId:%d super table is created, name:%s uid: %" PRId64, TD_VID(pMeta->pVnode), pReq->name, pReq->suid);
 
   return 0;
 
 _err:
-  metaError("vgId: %d failed to create super table: %s uid: %" PRId64 " since %s", TD_VID(pMeta->pVnode), pReq->name,
+  metaError("vgId:%d failed to create super table: %s uid: %" PRId64 " since %s", TD_VID(pMeta->pVnode), pReq->name,
             pReq->suid, tstrerror(terrno));
   return -1;
 }
 
 int metaDropSTable(SMeta *pMeta, int64_t verison, SVDropStbReq *pReq) {
-  // TODO
+  SMetaReader mr = {0};
+
+  // validate req
+  metaReaderInit(&mr, pMeta, 0);
+  if (metaGetTableEntryByUid(&mr, pReq->suid) < 0) {
+    terrno = TSDB_CODE_VND_TABLE_NOT_EXIST;
+    goto _err;
+  }
+
+  // do drop
+  // drop from pTbDb
+  // drop from pSkmDb
+  // drop from pUidIdx
+  // drop from pNameIdx
+  // {
+  //   TDBC *pDbc1 = NULL;
+  //   void *pKey = NULL;
+  //   void *pVal = NULL;
+  //   int   kLen = 0;
+  //   int   vLen = 0;
+  //   int   ret = 0;
+
+  //   // drop from pCtbIdx
+  //   ret = tdbDbcOpen(pMeta->pCtbIdx, &pDbc1);
+  //   tdbDbcMoveTo(pDbc1, &pReq->suid, sizeof(pReq->suid), NULL /*cmpr*/, 0 /*TDB_FORWARD_SEARCH*/);
+  //   tdbDbcGet(pDbc1, &pKey, &kLen, &pVal, vLen);
+  //   tdbDbcDrop(pDbc1);
+  //   // drop from pTagIdx
+  //   // drop from pTtlIdx
+  // }
+
+  // clear and return
+  metaReaderClear(&mr);
+  metaError("vgId:%d  super table %s uid:%" PRId64 " is dropped", TD_VID(pMeta->pVnode), pReq->name, pReq->suid);
   return 0;
+
+_err:
+  metaReaderClear(&mr);
+  metaError("vgId:%d failed to drop super table %s uid:%" PRId64 " since %s", TD_VID(pMeta->pVnode), pReq->name,
+            pReq->suid, tstrerror(terrno));
+  return -1;
 }
 
 int metaCreateTable(SMeta *pMeta, int64_t version, SVCreateTbReq *pReq) {
@@ -179,7 +218,7 @@ static int metaSaveToTbDb(SMeta *pMeta, const SMetaEntry *pME) {
   tCoderClear(&coder);
 
   // write to table.db
-  if (tdbDbInsert(pMeta->pTbDb, pKey, kLen, pVal, vLen, &pMeta->txn) < 0) {
+  if (tdbDbPut(pMeta->pTbDb, pKey, kLen, pVal, vLen, &pMeta->txn) < 0) {
     goto _err;
   }
 
@@ -192,11 +231,11 @@ _err:
 }
 
 static int metaUpdateUidIdx(SMeta *pMeta, const SMetaEntry *pME) {
-  return tdbDbInsert(pMeta->pUidIdx, &pME->uid, sizeof(tb_uid_t), &pME->version, sizeof(int64_t), &pMeta->txn);
+  return tdbDbPut(pMeta->pUidIdx, &pME->uid, sizeof(tb_uid_t), &pME->version, sizeof(int64_t), &pMeta->txn);
 }
 
 static int metaUpdateNameIdx(SMeta *pMeta, const SMetaEntry *pME) {
-  return tdbDbInsert(pMeta->pNameIdx, pME->name, strlen(pME->name) + 1, &pME->uid, sizeof(tb_uid_t), &pMeta->txn);
+  return tdbDbPut(pMeta->pNameIdx, pME->name, strlen(pME->name) + 1, &pME->uid, sizeof(tb_uid_t), &pMeta->txn);
 }
 
 static int metaUpdateTtlIdx(SMeta *pMeta, const SMetaEntry *pME) {
@@ -219,12 +258,12 @@ static int metaUpdateTtlIdx(SMeta *pMeta, const SMetaEntry *pME) {
   ttlKey.dtime = ctime + ttlDays * 24 * 60 * 60;
   ttlKey.uid = pME->uid;
 
-  return tdbDbInsert(pMeta->pTtlIdx, &ttlKey, sizeof(ttlKey), NULL, 0, &pMeta->txn);
+  return tdbDbPut(pMeta->pTtlIdx, &ttlKey, sizeof(ttlKey), NULL, 0, &pMeta->txn);
 }
 
 static int metaUpdateCtbIdx(SMeta *pMeta, const SMetaEntry *pME) {
   SCtbIdxKey ctbIdxKey = {.suid = pME->ctbEntry.suid, .uid = pME->uid};
-  return tdbDbInsert(pMeta->pCtbIdx, &ctbIdxKey, sizeof(ctbIdxKey), NULL, 0, &pMeta->txn);
+  return tdbDbPut(pMeta->pCtbIdx, &ctbIdxKey, sizeof(ctbIdxKey), NULL, 0, &pMeta->txn);
 }
 
 static int metaUpdateTagIdx(SMeta *pMeta, const SMetaEntry *pME) {
@@ -265,7 +304,7 @@ static int metaSaveToSkmDb(SMeta *pMeta, const SMetaEntry *pME) {
   tCoderInit(&coder, TD_LITTLE_ENDIAN, pVal, vLen, TD_ENCODER);
   tEncodeSSchemaWrapper(&coder, pSW);
 
-  if (tdbDbInsert(pMeta->pSkmDb, &skmDbKey, sizeof(skmDbKey), pVal, vLen, &pMeta->txn) < 0) {
+  if (tdbDbPut(pMeta->pSkmDb, &skmDbKey, sizeof(skmDbKey), pVal, vLen, &pMeta->txn) < 0) {
     rcode = -1;
     goto _exit;
   }

source/dnode/vnode/src/tsdb/tsdbCommit.c

@@ -55,7 +55,7 @@ typedef struct {
 #define TSDB_COMMIT_BUF(ch)          TSDB_READ_BUF(&((ch)->readh))
 #define TSDB_COMMIT_COMP_BUF(ch)     TSDB_READ_COMP_BUF(&((ch)->readh))
 #define TSDB_COMMIT_EXBUF(ch)        TSDB_READ_EXBUF(&((ch)->readh))
-#define TSDB_COMMIT_DEFAULT_ROWS(ch) TSDB_DEFAULT_BLOCK_ROWS(TSDB_COMMIT_REPO(ch)->config.maxRows)
+#define TSDB_COMMIT_DEFAULT_ROWS(ch) TSDB_DEFAULT_BLOCK_ROWS(TSDB_COMMIT_REPO(ch)->pVnode->config.tsdbCfg.maxRows)
 #define TSDB_COMMIT_TXN_VERSION(ch)  FS_TXN_VERSION(REPO_FS(TSDB_COMMIT_REPO(ch)))
 
 static void tsdbStartCommit(STsdb *pRepo);

source/dnode/vnode/src/tsdb/tsdbOpen.c

@@ -15,12 +15,34 @@
 
 #include "tsdb.h"
 
-int tsdbOpen(SVnode *pVnode, STsdb **ppTsdb) {
+static int tsdbOpenImpl(SVnode *pVnode, int8_t type, STsdb **ppTsdb, const char *dir);
+
+int tsdbOpen(SVnode *pVnode, int8_t type) {
+  switch (type) {
+    case TSDB_TYPE_TSDB:
+      return tsdbOpenImpl(pVnode, type, &VND_TSDB(pVnode), VNODE_TSDB_DIR);
+    case TSDB_TYPE_TSMA:
+      ASSERT(0);
+      break;
+    case TSDB_TYPE_RSMA_L0:
+      return tsdbOpenImpl(pVnode, type, &VND_RSMA0(pVnode), VNODE_TSDB_DIR);
+    case TSDB_TYPE_RSMA_L1:
+      return tsdbOpenImpl(pVnode, type, &VND_RSMA1(pVnode), VNODE_RSMA1_DIR);
+    case TSDB_TYPE_RSMA_L2:
+      return tsdbOpenImpl(pVnode, type, &VND_RSMA2(pVnode), VNODE_RSMA2_DIR);
+    default:
+      ASSERT(0);
+      break;
+  }
+  return 0;
+}
+
+int tsdbOpenImpl(SVnode *pVnode, int8_t type, STsdb **ppTsdb, const char *dir) {
   STsdb *pTsdb = NULL;
   int    slen = 0;
 
   *ppTsdb = NULL;
-  slen = strlen(tfsGetPrimaryPath(pVnode->pTfs)) + strlen(pVnode->path) + strlen(VNODE_TSDB_DIR) + 3;
+  slen = strlen(tfsGetPrimaryPath(pVnode->pTfs)) + strlen(pVnode->path) + strlen(dir) + 3;
 
   // create handle
   pTsdb = (STsdb *)taosMemoryCalloc(1, sizeof(*pTsdb) + slen);
@@ -31,12 +53,11 @@ int tsdbOpen(SVnode *pVnode, STsdb **ppTsdb) {
 
   pTsdb->path = (char *)&pTsdb[1];
   sprintf(pTsdb->path, "%s%s%s%s%s", tfsGetPrimaryPath(pVnode->pTfs), TD_DIRSEP, pVnode->path, TD_DIRSEP,
-          VNODE_TSDB_DIR);
+          dir);
   pTsdb->pVnode = pVnode;
   pTsdb->repoLocked = false;
-  tdbMutexInit(&pTsdb->mutex, NULL);
+  taosThreadMutexInit(&pTsdb->mutex, NULL);
-  pTsdb->config = pVnode->config.tsdbCfg;
+  pTsdb->fs = tsdbNewFS(REPO_CFG(pTsdb));
-  pTsdb->fs = tsdbNewFS(&pTsdb->config);
 
   // create dir (TODO: use tfsMkdir)
   taosMkDir(pTsdb->path);
@@ -46,7 +67,7 @@ int tsdbOpen(SVnode *pVnode, STsdb **ppTsdb) {
     goto _err;
   }
 
-  tsdbDebug("vgId: %d tsdb is opened", TD_VID(pVnode));
+  tsdbDebug("vgId: %d tsdb is opened for %s", TD_VID(pVnode), pTsdb->path);
 
   *ppTsdb = pTsdb;
   return 0;

source/dnode/vnode/src/tsdb/tsdbRead.c

@@ -130,6 +130,7 @@ typedef struct STsdbReadHandle {
   SArray*        prev;  // previous row which is before than time window
   SArray*        next;  // next row which is after the query time window
   SIOCostSummary cost;
+  STSchema*      pSchema;
 } STsdbReadHandle;
 
 typedef struct STableGroupSupporter {
@@ -311,7 +312,7 @@ static bool emptyQueryTimewindow(STsdbReadHandle* pTsdbReadHandle) {
 // Update the query time window according to the data time to live(TTL) information, in order to avoid to return
 // the expired data to client, even it is queried already.
 static int64_t getEarliestValidTimestamp(STsdb* pTsdb) {
-  STsdbCfg* pCfg = &pTsdb->config;
+  STsdbCfg* pCfg = REPO_CFG(pTsdb);
 
   int64_t now = taosGetTimestamp(pCfg->precision);
   return now - (tsTickPerDay[pCfg->precision] * pCfg->keep2) + 1;  // needs to add one tick
@@ -343,14 +344,14 @@ static void setQueryTimewindow(STsdbReadHandle* pTsdbReadHandle, SQueryTableData
   }
 }
 
-static STsdbReadHandle* tsdbQueryTablesImpl(STsdb* tsdb, SQueryTableDataCond* pCond, uint64_t qId, uint64_t taskId) {
+static STsdbReadHandle* tsdbQueryTablesImpl(SVnode* pVnode, SQueryTableDataCond* pCond, uint64_t qId, uint64_t taskId) {
   STsdbReadHandle* pReadHandle = taosMemoryCalloc(1, sizeof(STsdbReadHandle));
   if (pReadHandle == NULL) {
     goto _end;
   }
 
   pReadHandle->order = pCond->order;
-  pReadHandle->pTsdb = tsdb;
+  pReadHandle->pTsdb = pVnode->pTsdb;
   pReadHandle->type = TSDB_QUERY_TYPE_ALL;
   pReadHandle->cur.fid = INT32_MIN;
   pReadHandle->cur.win = TSWINDOW_INITIALIZER;
@@ -368,7 +369,7 @@ static STsdbReadHandle* tsdbQueryTablesImpl(STsdb* tsdb, SQueryTableDataCond* pC
   snprintf(buf, tListLen(buf), "TID:0x%" PRIx64 " QID:0x%" PRIx64, taskId, qId);
   pReadHandle->idStr = strdup(buf);
 
-  if (tsdbInitReadH(&pReadHandle->rhelper, (STsdb*)tsdb) != 0) {
+  if (tsdbInitReadH(&pReadHandle->rhelper, (STsdb*)pVnode->pTsdb) != 0) {
     goto _end;
   }
 
@@ -404,7 +405,7 @@ static STsdbReadHandle* tsdbQueryTablesImpl(STsdb* tsdb, SQueryTableDataCond* pC
     pReadHandle->defaultLoadColumn = getDefaultLoadColumns(pReadHandle, true);
   }
 
-  pReadHandle->pDataCols = tdNewDataCols(1000, pReadHandle->pTsdb->config.maxRows);
+  pReadHandle->pDataCols = tdNewDataCols(1000, pReadHandle->pTsdb->pVnode->config.tsdbCfg.maxRows);
   if (pReadHandle->pDataCols == NULL) {
     tsdbError("%p failed to malloc buf for pDataCols, %s", pReadHandle, pReadHandle->idStr);
     terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
@@ -422,9 +423,10 @@ _end:
   return NULL;
 }
 
-tsdbReaderT* tsdbQueryTablesT(STsdb* tsdb, SQueryTableDataCond* pCond, STableGroupInfo* groupList, uint64_t qId,
+tsdbReaderT* tsdbQueryTables(SVnode* pVnode, SQueryTableDataCond* pCond, STableGroupInfo* groupList, uint64_t qId,
                              uint64_t taskId) {
-  STsdbReadHandle* pTsdbReadHandle = tsdbQueryTablesImpl(tsdb, pCond, qId, taskId);
+
+  STsdbReadHandle* pTsdbReadHandle = tsdbQueryTablesImpl(pVnode, pCond, qId, taskId);
   if (pTsdbReadHandle == NULL) {
     return NULL;
   }
@@ -441,6 +443,9 @@ tsdbReaderT* tsdbQueryTablesT(STsdb* tsdb, SQueryTableDataCond* pCond, STableGro
     return NULL;
   }
 
+  STableCheckInfo *pCheckInfo = taosArrayGet(pTsdbReadHandle->pTableCheckInfo, 0);
+  pTsdbReadHandle->pSchema = metaGetTbTSchema(pVnode->pMeta, pCheckInfo->tableId, 0);
+
   tsdbDebug("%p total numOfTable:%" PRIzu " in this query, group %" PRIzu " %s", pTsdbReadHandle,
             taosArrayGetSize(pTsdbReadHandle->pTableCheckInfo), taosArrayGetSize(groupList->pGroupList),
             pTsdbReadHandle->idStr);
@@ -526,7 +531,7 @@ void tsdbResetQueryHandleForNewTable(tsdbReaderT queryHandle, SQueryTableDataCon
   //  pTsdbReadHandle->next = doFreeColumnInfoData(pTsdbReadHandle->next);
 }
 
-tsdbReaderT tsdbQueryLastRow(STsdb* tsdb, SQueryTableDataCond* pCond, STableGroupInfo* groupList, uint64_t qId,
+tsdbReaderT tsdbQueryLastRow(SVnode* pVnode, SQueryTableDataCond* pCond, STableGroupInfo* groupList, uint64_t qId,
                              uint64_t taskId) {
   pCond->twindow = updateLastrowForEachGroup(groupList);
 
@@ -535,7 +540,7 @@ tsdbReaderT tsdbQueryLastRow(STsdb* tsdb, SQueryTableDataCond* pCond, STableGrou
     return NULL;
   }
 
-  STsdbReadHandle* pTsdbReadHandle = (STsdbReadHandle*)tsdbQueryTablesT(tsdb, pCond, groupList, qId, taskId);
+  STsdbReadHandle* pTsdbReadHandle = (STsdbReadHandle*)tsdbQueryTables(pVnode, pCond, groupList, qId, taskId);
   if (pTsdbReadHandle == NULL) {
     return NULL;
   }
@@ -618,7 +623,7 @@ static STableGroupInfo* trimTableGroup(STimeWindow* window, STableGroupInfo* pGr
   return pNew;
 }
 
-tsdbReaderT tsdbQueryRowsInExternalWindow(STsdb* tsdb, SQueryTableDataCond* pCond, STableGroupInfo* groupList,
+tsdbReaderT tsdbQueryRowsInExternalWindow(SVnode* pVnode, SQueryTableDataCond* pCond, STableGroupInfo* groupList,
                                           uint64_t qId, uint64_t taskId) {
   STableGroupInfo* pNew = trimTableGroup(&pCond->twindow, groupList);
 
@@ -634,7 +639,7 @@ tsdbReaderT tsdbQueryRowsInExternalWindow(STsdb* tsdb, SQueryTableDataCond* pCon
     }
   }
 
-  STsdbReadHandle* pTsdbReadHandle = (STsdbReadHandle*)tsdbQueryTablesT(tsdb, pCond, pNew, qId, taskId);
+  STsdbReadHandle* pTsdbReadHandle = (STsdbReadHandle*)tsdbQueryTables(pVnode, pCond, pNew, qId, taskId);
   pTsdbReadHandle->loadExternalRow = true;
   pTsdbReadHandle->currentLoadExternalRows = true;
 
@@ -889,7 +894,7 @@ static bool moveToNextRowInMem(STableCheckInfo* pCheckInfo) {
 }
 
 static bool hasMoreDataInCache(STsdbReadHandle* pHandle) {
-  STsdbCfg* pCfg = &pHandle->pTsdb->config;
+  STsdbCfg* pCfg = REPO_CFG(pHandle->pTsdb);
   size_t    size = taosArrayGetSize(pHandle->pTableCheckInfo);
   assert(pHandle->activeIndex < size && pHandle->activeIndex >= 0 && size >= 1);
   pHandle->cur.fid = INT32_MIN;
@@ -986,7 +991,7 @@ static int32_t loadBlockInfo(STsdbReadHandle* pTsdbReadHandle, int32_t index, in
   pCheckInfo->numOfBlocks = 0;
 
   STable table = {.uid = pCheckInfo->tableId, .tid = pCheckInfo->tableId};
-  table.pSchema = metaGetTbTSchema(REPO_META(pTsdbReadHandle->pTsdb), pCheckInfo->tableId, 0);
+  table.pSchema = pTsdbReadHandle->pSchema;
 
   if (tsdbSetReadTable(&pTsdbReadHandle->rhelper, &table) != TSDB_CODE_SUCCESS) {
     code = terrno;
@@ -1091,22 +1096,21 @@ static int32_t doLoadFileDataBlock(STsdbReadHandle* pTsdbReadHandle, SBlock* pBl
                                    int32_t slotIndex) {
   int64_t st = taosGetTimestampUs();
 
-  STSchema* pSchema = metaGetTbTSchema(REPO_META(pTsdbReadHandle->pTsdb), pCheckInfo->tableId, 0);
+  int32_t   code = tdInitDataCols(pTsdbReadHandle->pDataCols, pTsdbReadHandle->pSchema);
-  int32_t   code = tdInitDataCols(pTsdbReadHandle->pDataCols, pSchema);
   if (code != TSDB_CODE_SUCCESS) {
     tsdbError("%p failed to malloc buf for pDataCols, %s", pTsdbReadHandle, pTsdbReadHandle->idStr);
     terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
     goto _error;
   }
 
-  code = tdInitDataCols(pTsdbReadHandle->rhelper.pDCols[0], pSchema);
+  code = tdInitDataCols(pTsdbReadHandle->rhelper.pDCols[0], pTsdbReadHandle->pSchema);
   if (code != TSDB_CODE_SUCCESS) {
     tsdbError("%p failed to malloc buf for rhelper.pDataCols[0], %s", pTsdbReadHandle, pTsdbReadHandle->idStr);
     terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
     goto _error;
   }
 
-  code = tdInitDataCols(pTsdbReadHandle->rhelper.pDCols[1], pSchema);
+  code = tdInitDataCols(pTsdbReadHandle->rhelper.pDCols[1], pTsdbReadHandle->pSchema);
   if (code != TSDB_CODE_SUCCESS) {
     tsdbError("%p failed to malloc buf for rhelper.pDataCols[1], %s", pTsdbReadHandle, pTsdbReadHandle->idStr);
     terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
@@ -1169,7 +1173,7 @@ static void    copyAllRemainRowsFromFileBlock(STsdbReadHandle* pTsdbReadHandle,
 
 static int32_t handleDataMergeIfNeeded(STsdbReadHandle* pTsdbReadHandle, SBlock* pBlock, STableCheckInfo* pCheckInfo) {
   SQueryFilePos* cur = &pTsdbReadHandle->cur;
-  STsdbCfg*      pCfg = &pTsdbReadHandle->pTsdb->config;
+  STsdbCfg*      pCfg = REPO_CFG(pTsdbReadHandle->pTsdb);
   SDataBlockInfo binfo = GET_FILE_DATA_BLOCK_INFO(pCheckInfo, pBlock);
   TSKEY          key;
   int32_t        code = TSDB_CODE_SUCCESS;
@@ -1756,7 +1760,7 @@ int32_t getEndPosInDataBlock(STsdbReadHandle* pTsdbReadHandle, SDataBlockInfo* p
 static void doMergeTwoLevelData(STsdbReadHandle* pTsdbReadHandle, STableCheckInfo* pCheckInfo, SBlock* pBlock) {
   SQueryFilePos* cur = &pTsdbReadHandle->cur;
   SDataBlockInfo blockInfo = GET_FILE_DATA_BLOCK_INFO(pCheckInfo, pBlock);
-  STsdbCfg*      pCfg = &pTsdbReadHandle->pTsdb->config;
+  STsdbCfg*      pCfg = REPO_CFG(pTsdbReadHandle->pTsdb);
 
   initTableMemIterator(pTsdbReadHandle, pCheckInfo);
 
@@ -2200,7 +2204,7 @@ static int32_t getFirstFileDataBlock(STsdbReadHandle* pTsdbReadHandle, bool* exi
   int32_t numOfBlocks = 0;
   int32_t numOfTables = (int32_t)taosArrayGetSize(pTsdbReadHandle->pTableCheckInfo);
 
-  STsdbCfg*   pCfg = &pTsdbReadHandle->pTsdb->config;
+  STsdbCfg*   pCfg = REPO_CFG(pTsdbReadHandle->pTsdb);
   STimeWindow win = TSWINDOW_INITIALIZER;
 
   while (true) {
@@ -2306,7 +2310,7 @@ int32_t tsdbGetFileBlocksDistInfo(tsdbReaderT* queryHandle, STableBlockDistInfo*
 
   // find the start data block in file
   pTsdbReadHandle->locateStart = true;
-  STsdbCfg* pCfg = &pTsdbReadHandle->pTsdb->config;
+  STsdbCfg* pCfg = REPO_CFG(pTsdbReadHandle->pTsdb);
   int32_t   fid = getFileIdFromKey(pTsdbReadHandle->window.skey, pCfg->days, pCfg->precision);
 
   tsdbRLockFS(pFileHandle);
@@ -2407,7 +2411,7 @@ static int32_t getDataBlocksInFiles(STsdbReadHandle* pTsdbReadHandle, bool* exis
   // find the start data block in file
   if (!pTsdbReadHandle->locateStart) {
     pTsdbReadHandle->locateStart = true;
-    STsdbCfg* pCfg = &pTsdbReadHandle->pTsdb->config;
+    STsdbCfg* pCfg = REPO_CFG(pTsdbReadHandle->pTsdb);
     int32_t   fid = getFileIdFromKey(pTsdbReadHandle->window.skey, pCfg->days, pCfg->precision);
 
     tsdbRLockFS(pFileHandle);
@@ -2498,7 +2502,7 @@ static int tsdbReadRowsFromCache(STableCheckInfo* pCheckInfo, TSKEY maxKey, int
                                  STsdbReadHandle* pTsdbReadHandle) {
   int       numOfRows = 0;
   int32_t   numOfCols = (int32_t)taosArrayGetSize(pTsdbReadHandle->pColumns);
-  STsdbCfg* pCfg = &pTsdbReadHandle->pTsdb->config;
+  STsdbCfg* pCfg = REPO_CFG(pTsdbReadHandle->pTsdb);
   win->skey = TSKEY_INITIAL_VAL;
 
   int64_t   st = taosGetTimestampUs();
@@ -3292,6 +3296,7 @@ int32_t tsdbRetrieveDataBlockStatisInfo(tsdbReaderT* pTsdbReadHandle, SColumnDat
     if (pHandle->statis[i].numOfNull == -1) {  // set the column data are all NULL
       pHandle->statis[i].numOfNull = pBlockInfo->compBlock->numOfRows;
     }
+
   }
 
   int64_t elapsed = taosGetTimestampUs() - stime;

source/dnode/vnode/src/tsdb/tsdbReadImpl.c

@@ -248,7 +248,8 @@ int tsdbLoadBlockInfo(SReadH *pReadh, void *pTarget) {
 
 int tsdbLoadBlockData(SReadH *pReadh, SBlock *pBlock, SBlockInfo *pBlkInfo) {
   ASSERT(pBlock->numOfSubBlocks > 0);
-  int8_t update = pReadh->pRepo->config.update;
+  STsdbCfg *pCfg = REPO_CFG(pReadh->pRepo);
+  int8_t    update = pCfg->update;
 
   SBlock *iBlock = pBlock;
   if (pBlock->numOfSubBlocks > 1) {
@@ -279,7 +280,7 @@ int tsdbLoadBlockData(SReadH *pReadh, SBlock *pBlock, SBlockInfo *pBlkInfo) {
 int tsdbLoadBlockDataCols(SReadH *pReadh, SBlock *pBlock, SBlockInfo *pBlkInfo, const int16_t *colIds, int numOfColsIds,
                           bool mergeBitmap) {
   ASSERT(pBlock->numOfSubBlocks > 0);
-  int8_t update = pReadh->pRepo->config.update;
+  int8_t update = pReadh->pRepo->pVnode->config.tsdbCfg.update;
 
   SBlock *iBlock = pBlock;
   if (pBlock->numOfSubBlocks > 1) {

source/dnode/vnode/src/tsdb/tsdbScan.c

@@ -1,37 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#if 0
-#include "tsdb.h"
-#ifndef _TSDB_PLUGINS
-
-int tsdbScanFGroup(STsdbScanHandle* pScanHandle, char* rootDir, int fid) { return 0; }
-
-STsdbScanHandle* tsdbNewScanHandle() { return NULL; }
-
-void tsdbSetScanLogStream(STsdbScanHandle* pScanHandle, FILE* fLogStream) {}
-
-int tsdbSetAndOpenScanFile(STsdbScanHandle* pScanHandle, char* rootDir, int fid) { return 0; }
-
-int tsdbScanSBlockIdx(STsdbScanHandle* pScanHandle) { return 0; }
-
-int tsdbScanSBlock(STsdbScanHandle* pScanHandle, int idx) { return 0; }
-
-int tsdbCloseScanFile(STsdbScanHandle* pScanHandle) { return 0; }
-
-void tsdbFreeScanHandle(STsdbScanHandle* pScanHandle) {}
-
-#endif
-#endif

source/dnode/vnode/src/tsdb/tsdbSma.c

@@ -103,10 +103,9 @@ typedef struct {
   STSma    *pSma;            // cache schema
 } SSmaStatItem;
 
-#define RSMA_MAX_LEVEL           2
 #define RSMA_TASK_INFO_HASH_SLOT 8
 struct SRSmaInfo {
-  void *taskInfo[RSMA_MAX_LEVEL];  // qTaskInfo_t
+  void *taskInfo[TSDB_RSMA_RETENTION_2];  // qTaskInfo_t
 };
 
 struct SSmaStat {
@@ -128,7 +127,7 @@ static FORCE_INLINE void tsdbFreeTaskHandle(qTaskInfo_t *taskHandle) {
 }
 
 static FORCE_INLINE void *tsdbFreeRSmaInfo(SRSmaInfo *pInfo) {
-  for (int32_t i = 0; i < RSMA_MAX_LEVEL; ++i) {
+  for (int32_t i = 0; i < TSDB_RSMA_RETENTION_MAX; ++i) {
     if (pInfo->taskInfo[i]) {
       tsdbFreeTaskHandle(pInfo->taskInfo[i]);
     }
@@ -224,7 +223,7 @@ static FORCE_INLINE int32_t tsdbUnLockSma(SSmaEnv *pEnv) {
 }
 
 static SPoolMem *openPool() {
-  SPoolMem *pPool = (SPoolMem *)tdbOsMalloc(sizeof(*pPool));
+  SPoolMem *pPool = (SPoolMem *)taosMemoryMalloc(sizeof(*pPool));
 
   pPool->prev = pPool->next = pPool;
   pPool->size = 0;
@@ -246,7 +245,7 @@ static void clearPool(SPoolMem *pPool) {
     pMem->prev->next = pMem->next;
     pPool->size -= pMem->size;
 
-    tdbOsFree(pMem);
+    taosMemoryFree(pMem);
   } while (1);
 
   assert(pPool->size == 0);
@@ -255,7 +254,7 @@ static void clearPool(SPoolMem *pPool) {
 static void closePool(SPoolMem *pPool) {
   if (pPool) {
     clearPool(pPool);
-    tdbOsFree(pPool);
+    taosMemoryFree(pPool);
   }
 }
 
@@ -264,7 +263,7 @@ static void *poolMalloc(void *arg, size_t size) {
   SPoolMem *pPool = (SPoolMem *)arg;
   SPoolMem *pMem;
 
-  pMem = (SPoolMem *)tdbOsMalloc(sizeof(*pMem) + size);
+  pMem = (SPoolMem *)taosMemoryMalloc(sizeof(*pMem) + size);
   if (!pMem) {
     assert(0);
   }
@@ -291,7 +290,7 @@ static void poolFree(void *arg, void *ptr) {
   pMem->prev->next = pMem->next;
   pPool->size -= pMem->size;
 
-  tdbOsFree(pMem);
+  taosMemoryFree(pMem);
 }
 
 int32_t tsdbInitSma(STsdb *pTsdb) {

source/dnode/vnode/src/tsdb/tsdbTDBImpl.c

@@ -55,12 +55,12 @@ static inline int tsdbSmaKeyCmpr(const void *arg1, int len1, const void *arg2, i
 }
 
 static int32_t tsdbOpenDBDb(TDB **ppDB, TENV *pEnv, const char *pFName) {
-  int            ret;
+  int           ret;
-  FKeyComparator compFunc;
+  tdb_cmpr_fn_t compFunc;
 
   // Create a database
   compFunc = tsdbSmaKeyCmpr;
-  ret = tdbDbOpen(pFName, TDB_VARIANT_LEN, TDB_VARIANT_LEN, compFunc, pEnv, ppDB);
+  ret = tdbDbOpen(pFName, -1, -1, compFunc, pEnv, ppDB);
 
   return 0;
 }
@@ -97,7 +97,7 @@ int32_t tsdbCloseDBF(SDBFile *pDBF) {
 int32_t tsdbSaveSmaToDB(SDBFile *pDBF, void *pKey, int32_t keyLen, void *pVal, int32_t valLen, TXN *txn) {
   int32_t ret;
 
-  ret = tdbDbInsert(pDBF->pDB, pKey, keyLen, pVal, valLen, txn);
+  ret = tdbDbPut(pDBF->pDB, pKey, keyLen, pVal, valLen, txn);
   if (ret < 0) {
     tsdbError("Failed to create insert sma data into db, ret = %d", ret);
     return -1;

source/dnode/vnode/src/tsdb/tsdbWrite.c

@@ -60,9 +60,10 @@ static int tsdbScanAndConvertSubmitMsg(STsdb *pTsdb, SSubmitReq *pMsg) {
   SSubmitBlk    *pBlock = NULL;
   SSubmitBlkIter blkIter = {0};
   STSRow        *row = NULL;
-  TSKEY          now = taosGetTimestamp(pTsdb->config.precision);
+  STsdbCfg      *pCfg = REPO_CFG(pTsdb);
-  TSKEY          minKey = now - tsTickPerDay[pTsdb->config.precision] * pTsdb->config.keep2;
+  TSKEY          now = taosGetTimestamp(pCfg->precision);
-  TSKEY          maxKey = now + tsTickPerDay[pTsdb->config.precision] * pTsdb->config.days;
+  TSKEY          minKey = now - tsTickPerDay[pCfg->precision] * pCfg->keep2;
+  TSKEY          maxKey = now + tsTickPerDay[pCfg->precision] * pCfg->days;
 
   terrno = TSDB_CODE_SUCCESS;
   pMsg->length = htonl(pMsg->length);

source/dnode/vnode/src/vnd/vnodeCfg.c

@@ -66,6 +66,28 @@ int vnodeEncodeConfig(const void *pObj, SJson *pJson) {
   if (tjsonAddIntegerToObject(pJson, "keep0", pCfg->tsdbCfg.keep0) < 0) return -1;
   if (tjsonAddIntegerToObject(pJson, "keep1", pCfg->tsdbCfg.keep1) < 0) return -1;
   if (tjsonAddIntegerToObject(pJson, "keep2", pCfg->tsdbCfg.keep2) < 0) return -1;
+#ifdef TSDB_VNODE_SMA_DEBUG
+  if (pCfg->tsdbCfg.retentions[0].freq > 0) {
+    int32_t nRetention = 1;
+    if (pCfg->tsdbCfg.retentions[1].freq > 0) {
+      ++nRetention;
+      if (pCfg->tsdbCfg.retentions[2].freq > 0) {
+        ++nRetention;
+      }
+    }
+    SJson *pNodeRetentions = tjsonCreateArray();
+    tjsonAddItemToObject(pJson, "retentions", pNodeRetentions);
+    for (int32_t i = 0; i < nRetention; ++i) {
+      SJson      *pNodeRetention = tjsonCreateObject();
+      const SRetention *pRetention = pCfg->tsdbCfg.retentions + i;
+      tjsonAddIntegerToObject(pNodeRetention, "freq", pRetention->freq);
+      tjsonAddIntegerToObject(pNodeRetention, "freqUnit", pRetention->freqUnit);
+      tjsonAddIntegerToObject(pNodeRetention, "keep", pRetention->keep);
+      tjsonAddIntegerToObject(pNodeRetention, "keepUnit", pRetention->keepUnit);
+      tjsonAddItemToArray(pNodeRetentions, pNodeRetention);
+    }
+  }
+#endif
   if (tjsonAddIntegerToObject(pJson, "wal.vgId", pCfg->walCfg.vgId) < 0) return -1;
   if (tjsonAddIntegerToObject(pJson, "wal.fsyncPeriod", pCfg->walCfg.fsyncPeriod) < 0) return -1;
   if (tjsonAddIntegerToObject(pJson, "wal.retentionPeriod", pCfg->walCfg.retentionPeriod) < 0) return -1;
@@ -113,6 +135,20 @@ int vnodeDecodeConfig(const SJson *pJson, void *pObj) {
   if (tjsonGetNumberValue(pJson, "keep0", pCfg->tsdbCfg.keep0) < 0) return -1;
   if (tjsonGetNumberValue(pJson, "keep1", pCfg->tsdbCfg.keep1) < 0) return -1;
   if (tjsonGetNumberValue(pJson, "keep2", pCfg->tsdbCfg.keep2) < 0) return -1;
+#ifdef TSDB_VNODE_SMA_DEBUG
+  SJson *pNodeRetentions = tjsonGetObjectItem(pJson, "retentions");
+  int    nRetention = tjsonGetArraySize(pNodeRetentions);
+  ASSERT(nRetention <= TSDB_RSMA_RETENTION_MAX);
+
+  for (int32_t i = 0; i < nRetention; ++i) {
+    SJson *pNodeRetention = tjsonGetArrayItem(pNodeRetentions, i);
+    ASSERT(pNodeRetention != NULL);
+    tjsonGetNumberValue(pNodeRetention, "freq", (pCfg->tsdbCfg.retentions)[i].freq);
+    tjsonGetNumberValue(pNodeRetention, "freqUnit", (pCfg->tsdbCfg.retentions)[i].freqUnit);
+    tjsonGetNumberValue(pNodeRetention, "keep", (pCfg->tsdbCfg.retentions)[i].keep);
+    tjsonGetNumberValue(pNodeRetention, "keepUnit", (pCfg->tsdbCfg.retentions)[i].keepUnit);
+  }
+#endif
   if (tjsonGetNumberValue(pJson, "wal.vgId", pCfg->walCfg.vgId) < 0) return -1;
   if (tjsonGetNumberValue(pJson, "wal.fsyncPeriod", pCfg->walCfg.fsyncPeriod) < 0) return -1;
   if (tjsonGetNumberValue(pJson, "wal.retentionPeriod", pCfg->walCfg.retentionPeriod) < 0) return -1;

source/dnode/vnode/src/vnd/vnodeCommit.c

@@ -42,13 +42,13 @@ int vnodeBegin(SVnode *pVnode) {
 
   // begin meta
   if (metaBegin(pVnode->pMeta) < 0) {
-    vError("vgId: %d failed to begin meta since %s", TD_VID(pVnode), tstrerror(terrno));
+    vError("vgId:%d failed to begin meta since %s", TD_VID(pVnode), tstrerror(terrno));
     return -1;
   }
 
   // begin tsdb
   if (tsdbBegin(pVnode->pTsdb) < 0) {
-    vError("vgId: %d failed to begin tsdb since %s", TD_VID(pVnode), tstrerror(terrno));
+    vError("vgId:%d failed to begin tsdb since %s", TD_VID(pVnode), tstrerror(terrno));
     return -1;
   }
 
@@ -93,7 +93,7 @@ int vnodeSaveInfo(const char *dir, const SVnodeInfo *pInfo) {
   // free info binary
   taosMemoryFree(data);
 
-  vInfo("vgId: %d vnode info is saved, fname: %s", pInfo->config.vgId, fname);
+  vInfo("vgId:%d vnode info is saved, fname: %s", pInfo->config.vgId, fname);
 
   return 0;
 
@@ -115,7 +115,7 @@ int vnodeCommitInfo(const char *dir, const SVnodeInfo *pInfo) {
     return -1;
   }
 
-  vInfo("vgId: %d vnode info is committed", pInfo->config.vgId);
+  vInfo("vgId:%d vnode info is committed", pInfo->config.vgId);
 
   return 0;
 }
@@ -190,7 +190,7 @@ int vnodeSyncCommit(SVnode *pVnode) {
 }
 
 int vnodeCommit(SVnode *pVnode) {
-  SVnodeInfo info;
+  SVnodeInfo info = {0};
   char       dir[TSDB_FILENAME_LEN];
 
   vInfo("vgId:%d start to commit, version: %" PRId64, TD_VID(pVnode), pVnode->state.applied);

source/dnode/vnode/src/vnd/vnodeInt.c

@@ -1,24 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "vnd.h"
-// #include "vnodeInt.h"
-
-int32_t vnodeAlter(SVnode *pVnode, const SVnodeCfg *pCfg) { return 0; }
-
-int32_t vnodeCompact(SVnode *pVnode) { return 0; }
-
-int32_t vnodeSync(SVnode *pVnode) { return 0; }

source/dnode/vnode/src/vnd/vnodeOpen.c

@@ -23,13 +23,13 @@ int vnodeCreate(const char *path, SVnodeCfg *pCfg, STfs *pTfs) {
 
   // check config
   if (vnodeCheckCfg(pCfg) < 0) {
-    vError("vgId: %d failed to create vnode since: %s", pCfg->vgId, tstrerror(terrno));
+    vError("vgId:%d failed to create vnode since: %s", pCfg->vgId, tstrerror(terrno));
     return -1;
   }
 
   // create vnode env
   if (tfsMkdir(pTfs, path) < 0) {
-    vError("vgId: %d failed to create vnode since: %s", pCfg->vgId, tstrerror(terrno));
+    vError("vgId:%d failed to create vnode since: %s", pCfg->vgId, tstrerror(terrno));
     return -1;
   }
 
@@ -39,11 +39,11 @@ int vnodeCreate(const char *path, SVnodeCfg *pCfg, STfs *pTfs) {
   info.state.applied = -1;
 
   if (vnodeSaveInfo(dir, &info) < 0 || vnodeCommitInfo(dir, &info) < 0) {
-    vError("vgId: %d failed to save vnode config since %s", pCfg->vgId, tstrerror(terrno));
+    vError("vgId:%d failed to save vnode config since %s", pCfg->vgId, tstrerror(terrno));
     return -1;
   }
 
-  vInfo("vgId: %d vnode is created", pCfg->vgId);
+  vInfo("vgId:%d vnode is created", pCfg->vgId);
 
   return 0;
 }
@@ -70,7 +70,7 @@ SVnode *vnodeOpen(const char *path, STfs *pTfs, SMsgCb msgCb) {
   pVnode = (SVnode *)taosMemoryCalloc(1, sizeof(*pVnode) + strlen(path) + 1);
   if (pVnode == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
-    vError("vgId: %d failed to open vnode since %s", info.config.vgId, tstrerror(terrno));
+    vError("vgId:%d failed to open vnode since %s", info.config.vgId, tstrerror(terrno));
     return NULL;
   }
 
@@ -85,27 +85,44 @@ SVnode *vnodeOpen(const char *path, STfs *pTfs, SMsgCb msgCb) {
 
   // open buffer pool
   if (vnodeOpenBufPool(pVnode, pVnode->config.isHeap ? 0 : pVnode->config.szBuf / 3) < 0) {
-    vError("vgId: %d failed to open vnode buffer pool since %s", TD_VID(pVnode), tstrerror(terrno));
+    vError("vgId:%d failed to open vnode buffer pool since %s", TD_VID(pVnode), tstrerror(terrno));
     goto _err;
   }
 
   // open meta
   if (metaOpen(pVnode, &pVnode->pMeta) < 0) {
-    vError("vgId: %d failed to open vnode meta since %s", TD_VID(pVnode), tstrerror(terrno));
+    vError("vgId:%d failed to open vnode meta since %s", TD_VID(pVnode), tstrerror(terrno));
     goto _err;
   }
 
   // open tsdb
-  if (tsdbOpen(pVnode, &pVnode->pTsdb) < 0) {
+  if (tsdbIsRollup(pVnode)) {
-    vError("vgId: %d failed to open vnode tsdb since %s", TD_VID(pVnode), tstrerror(terrno));
+    if (tsdbOpen(pVnode, TSDB_TYPE_RSMA_L0) < 0) {
-    goto _err;
+      vError("vgId: %d failed to open vnode rsma0 since %s", TD_VID(pVnode), tstrerror(terrno));
+      goto _err;
+    }
+
+    if (tsdbOpen(pVnode, TSDB_TYPE_RSMA_L1) < 0) {
+      vError("vgId: %d failed to open vnode rsma1 since %s", TD_VID(pVnode), tstrerror(terrno));
+      goto _err;
+    }
+
+    if (tsdbOpen(pVnode, TSDB_TYPE_RSMA_L2) < 0) {
+      vError("vgId: %d failed to open vnode rsma2 since %s", TD_VID(pVnode), tstrerror(terrno));
+      goto _err;
+    }
+  } else {
+    if (tsdbOpen(pVnode, TSDB_TYPE_TSDB) < 0) {
+      vError("vgId: %d failed to open vnode tsdb since %s", TD_VID(pVnode), tstrerror(terrno));
+      goto _err;
+    }
   }
 
   // open wal
   sprintf(tdir, "%s%s%s", dir, TD_DIRSEP, VNODE_WAL_DIR);
   pVnode->pWal = walOpen(tdir, &(pVnode->config.walCfg));
   if (pVnode->pWal == NULL) {
-    vError("vgId: %d failed to open vnode wal since %s", TD_VID(pVnode), tstrerror(terrno));
+    vError("vgId:%d failed to open vnode wal since %s", TD_VID(pVnode), tstrerror(terrno));
     goto _err;
   }
 
@@ -113,25 +130,25 @@ SVnode *vnodeOpen(const char *path, STfs *pTfs, SMsgCb msgCb) {
   sprintf(tdir, "%s%s%s", dir, TD_DIRSEP, VNODE_TQ_DIR);
   pVnode->pTq = tqOpen(tdir, pVnode, pVnode->pWal);
   if (pVnode->pTq == NULL) {
-    vError("vgId: %d failed to open vnode tq since %s", TD_VID(pVnode), tstrerror(terrno));
+    vError("vgId:%d failed to open vnode tq since %s", TD_VID(pVnode), tstrerror(terrno));
     goto _err;
   }
 
   // open query
   if (vnodeQueryOpen(pVnode)) {
-    vError("vgId: %d failed to open vnode query since %s", TD_VID(pVnode), tstrerror(terrno));
+    vError("vgId:%d failed to open vnode query since %s", TD_VID(pVnode), tstrerror(terrno));
     goto _err;
   }
 
   // vnode begin
   if (vnodeBegin(pVnode) < 0) {
-    vError("vgId: %d failed to begin since %s", TD_VID(pVnode), tstrerror(terrno));
+    vError("vgId:%d failed to begin since %s", TD_VID(pVnode), tstrerror(terrno));
     goto _err;
   }
 
   // open sync
   if (vnodeSyncOpen(pVnode, dir)) {
-    vError("vgId: %d failed to open sync since %s", TD_VID(pVnode), tstrerror(terrno));
+    vError("vgId:%d failed to open sync since %s", TD_VID(pVnode), tstrerror(terrno));
     goto _err;
   }
 
@@ -143,6 +160,8 @@ _err:
   if (pVnode->pWal) walClose(pVnode->pWal);
   if (pVnode->pTsdb) tsdbClose(pVnode->pTsdb);
   if (pVnode->pMeta) metaClose(pVnode->pMeta);
+    tsdbClose(VND_RSMA1(pVnode));
+    tsdbClose(VND_RSMA2(pVnode));
   tsem_destroy(&(pVnode->canCommit));
   taosMemoryFree(pVnode);
   return NULL;
@@ -155,7 +174,9 @@ void vnodeClose(SVnode *pVnode) {
     vnodeQueryClose(pVnode);
     walClose(pVnode->pWal);
     tqClose(pVnode->pTq);
-    tsdbClose(pVnode->pTsdb);
+    tsdbClose(VND_TSDB(pVnode));
+    tsdbClose(VND_RSMA1(pVnode));
+    tsdbClose(VND_RSMA2(pVnode));
     metaClose(pVnode->pMeta);
     vnodeCloseBufPool(pVnode);
     // destroy handle

source/dnode/vnode/src/vnd/vnodeQuery.c

@@ -150,11 +150,6 @@ void vnodeGetInfo(SVnode *pVnode, const char **dbname, int32_t *vgId) {
 }
 
 // wrapper of tsdb read interface
-// TODO: use FORCE_INLINE if possible later
-tsdbReaderT *tsdbQueryTables(SVnode *pVnode, SQueryTableDataCond *pCond, STableGroupInfo *tableInfoGroup, uint64_t qId,
-                             uint64_t taskId) {
-  return tsdbQueryTablesT(pVnode->pTsdb, pCond, tableInfoGroup, qId, taskId);
-}
 tsdbReaderT tsdbQueryCacheLast(SVnode *pVnode, SQueryTableDataCond *pCond, STableGroupInfo *groupList, uint64_t qId,
                                void *pMemRef) {
 #if 0

source/dnode/vnode/src/vnd/vnodeSvr.c

@@ -17,10 +17,10 @@
 
 static int vnodeProcessCreateStbReq(SVnode *pVnode, int64_t version, void *pReq, int len, SRpcMsg *pRsp);
 static int vnodeProcessAlterStbReq(SVnode *pVnode, void *pReq, int32_t len, SRpcMsg *pRsp);
-static int vnodeProcessDropStbReq(SVnode *pVnode, void *pReq, int32_t len, SRpcMsg *pRsp);
+static int vnodeProcessDropStbReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp);
 static int vnodeProcessCreateTbReq(SVnode *pVnode, int64_t version, void *pReq, int len, SRpcMsg *pRsp);
 static int vnodeProcessAlterTbReq(SVnode *pVnode, void *pReq, int32_t len, SRpcMsg *pRsp);
-static int vnodeProcessDropTbReq(SVnode *pVnode, void *pReq, int32_t len, SRpcMsg *pRsp);
+static int vnodeProcessDropTbReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp);
 static int vnodeProcessSubmitReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp);
 
 int vnodePreprocessWriteReqs(SVnode *pVnode, SArray *pMsgs, int64_t *version) {
@@ -93,7 +93,7 @@ int vnodeProcessWriteReq(SVnode *pVnode, SRpcMsg *pMsg, int64_t version, SRpcMsg
   int   len;
   int   ret;
 
-  vTrace("vgId: %d start to process write request %s, version %" PRId64, TD_VID(pVnode), TMSG_INFO(pMsg->msgType),
+  vTrace("vgId:%d start to process write request %s, version %" PRId64, TD_VID(pVnode), TMSG_INFO(pMsg->msgType),
          version);
 
   pVnode->state.applied = version;
@@ -103,7 +103,7 @@ int vnodeProcessWriteReq(SVnode *pVnode, SRpcMsg *pMsg, int64_t version, SRpcMsg
   len = pMsg->contLen - sizeof(SMsgHead);
 
   if (tqPushMsg(pVnode->pTq, pMsg->pCont, pMsg->contLen, pMsg->msgType, version) < 0) {
-    vError("vgId: %d failed to push msg to TQ since %s", TD_VID(pVnode), tstrerror(terrno));
+    vError("vgId:%d failed to push msg to TQ since %s", TD_VID(pVnode), tstrerror(terrno));
     return -1;
   }
 
@@ -116,7 +116,7 @@ int vnodeProcessWriteReq(SVnode *pVnode, SRpcMsg *pMsg, int64_t version, SRpcMsg
       if (vnodeProcessAlterStbReq(pVnode, pReq, len, pRsp) < 0) goto _err;
       break;
     case TDMT_VND_DROP_STB:
-      if (vnodeProcessDropStbReq(pVnode, pReq, len, pRsp) < 0) goto _err;
+      if (vnodeProcessDropStbReq(pVnode, version, pReq, len, pRsp) < 0) goto _err;
       break;
     case TDMT_VND_CREATE_TABLE:
       if (vnodeProcessCreateTbReq(pVnode, version, pReq, len, pRsp) < 0) goto _err;
@@ -125,7 +125,7 @@ int vnodeProcessWriteReq(SVnode *pVnode, SRpcMsg *pMsg, int64_t version, SRpcMsg
       if (vnodeProcessAlterTbReq(pVnode, pReq, len, pRsp) < 0) goto _err;
       break;
     case TDMT_VND_DROP_TABLE:
-      if (vnodeProcessDropTbReq(pVnode, pReq, len, pRsp) < 0) goto _err;
+      if (vnodeProcessDropTbReq(pVnode, version, pReq, len, pRsp) < 0) goto _err;
       break;
     case TDMT_VND_CREATE_SMA: {  // timeRangeSMA
       if (tsdbCreateTSma(pVnode->pTsdb, POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead))) < 0) {
@@ -160,7 +160,7 @@ int vnodeProcessWriteReq(SVnode *pVnode, SRpcMsg *pMsg, int64_t version, SRpcMsg
       break;
   }
 
-  vDebug("vgId: %d process %s request success, version: %" PRId64, TD_VID(pVnode), TMSG_INFO(pMsg->msgType), version);
+  vDebug("vgId:%d process %s request success, version: %" PRId64, TD_VID(pVnode), TMSG_INFO(pMsg->msgType), version);
 
   // commit if need
   if (vnodeShouldCommit(pVnode)) {
@@ -175,7 +175,7 @@ int vnodeProcessWriteReq(SVnode *pVnode, SRpcMsg *pMsg, int64_t version, SRpcMsg
   return 0;
 
 _err:
-  vDebug("vgId: %d process %s request failed since %s, version: %" PRId64, TD_VID(pVnode), TMSG_INFO(pMsg->msgType),
+  vDebug("vgId:%d process %s request failed since %s, version: %" PRId64, TD_VID(pVnode), TMSG_INFO(pMsg->msgType),
          tstrerror(terrno), version);
   return -1;
 }
@@ -450,9 +450,32 @@ static int vnodeProcessAlterStbReq(SVnode *pVnode, void *pReq, int32_t len, SRpc
   return 0;
 }
 
-static int vnodeProcessDropStbReq(SVnode *pVnode, void *pReq, int32_t len, SRpcMsg *pRsp) {
+static int vnodeProcessDropStbReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp) {
-  // TODO
+  SVDropStbReq req = {0};
-  // ASSERT(0);
+  int          rcode = TSDB_CODE_SUCCESS;
+  SCoder       coder = {0};
+
+  pRsp->msgType = TDMT_VND_CREATE_STB_RSP;
+  pRsp->pCont = NULL;
+  pRsp->contLen = 0;
+
+  // decode request
+  tCoderInit(&coder, TD_LITTLE_ENDIAN, pReq, len, TD_DECODER);
+  if (tDecodeSVDropStbReq(&coder, &req) < 0) {
+    rcode = TSDB_CODE_INVALID_MSG;
+    goto _exit;
+  }
+
+  // process request
+  // if (metaDropSTable(pVnode->pMeta, version, &req) < 0) {
+  //   rcode = terrno;
+  //   goto _exit;
+  // }
+
+  // return rsp
+_exit:
+  pRsp->code = rcode;
+  tCoderClear(&coder);
   return 0;
 }
 
@@ -462,9 +485,15 @@ static int vnodeProcessAlterTbReq(SVnode *pVnode, void *pReq, int32_t len, SRpcM
   return 0;
 }
 
-static int vnodeProcessDropTbReq(SVnode *pVnode, void *pReq, int32_t len, SRpcMsg *pRsp) {
+static int vnodeProcessDropTbReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp) {
-  // TODO
+  SVDropTbReq req = {0};
-  ASSERT(0);
+  SVDropTbReq rsp = {0};
+
+  // decode req
+
+  // process req
+
+  // return rsp
   return 0;
 }
 

source/libs/command/inc/commandInt.h

@@ -56,10 +56,9 @@ extern "C" {
 #define EXPLAIN_ROWS_FORMAT "rows=%" PRIu64
 #define EXPLAIN_COLUMNS_FORMAT "columns=%d"
 #define EXPLAIN_WIDTH_FORMAT "width=%d"
+#define EXPLAIN_TABLE_SCAN_FORMAT "order=[asc|%d desc|%d]"
 #define EXPLAIN_GROUPS_FORMAT "groups=%d"
 #define EXPLAIN_WIDTH_FORMAT "width=%d"
-#define EXPLAIN_LOOPS_FORMAT "loops=%d"
-#define EXPLAIN_REVERSE_FORMAT "reverse=%d"
 #define EXPLAIN_FUNCTIONS_FORMAT "functions=%d"
 #define EXPLAIN_EXECINFO_FORMAT "cost=%" PRIu64 "..%" PRIu64 " rows=%" PRIu64
 

source/libs/command/src/explain.c

@@ -379,6 +379,7 @@ int32_t qExplainResNodeToRowsImpl(SExplainResNode *pResNode, SExplainCtx *ctx, i
       EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
       EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pTblScanNode->scan.node.pOutputDataBlockDesc->totalRowSize);
       EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
+      EXPLAIN_ROW_APPEND(EXPLAIN_TABLE_SCAN_FORMAT, pTblScanNode->scanSeq[0], pTblScanNode->scanSeq[1]);
       EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);      
       EXPLAIN_ROW_END();
       QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level));

source/libs/executor/inc/executorimpl.h

@@ -375,6 +375,7 @@ typedef struct SStreamBlockScanInfo {
   uint64_t     numOfExec;        // execution times
   void*        readerHandle;     // stream block reader handle
   SArray*      pColMatchInfo;    //
+  SNode*       pCondition;
 } SStreamBlockScanInfo;
 
 typedef struct SSysTableScanInfo {
@@ -672,7 +673,7 @@ SOperatorInfo* createGroupOperatorInfo(SOperatorInfo* downstream, SExprInfo* pEx
                                        const STableGroupInfo* pTableGroupInfo);
 SOperatorInfo* createDataBlockInfoScanOperator(void* dataReader, SExecTaskInfo* pTaskInfo);
 SOperatorInfo* createStreamScanOperatorInfo(void* streamReadHandle, SSDataBlock* pResBlock, SArray* pColList,
-                                            SArray* pTableIdList, SExecTaskInfo* pTaskInfo);
+                                            SArray* pTableIdList, SExecTaskInfo* pTaskInfo, SNode* pConditions);
 
 SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExpr, int32_t numOfCols,
                                       SInterval* pInterval, SSDataBlock* pResBlock, int32_t fillType, char* fillVal,

source/libs/executor/src/executorimpl.c

@@ -6538,7 +6538,7 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
       int32_t numOfCols = 0;
       SArray* pCols = extractColMatchInfo(pScanPhyNode->pScanCols, pScanPhyNode->node.pOutputDataBlockDesc, &numOfCols);
       SOperatorInfo* pOperator =
-          createStreamScanOperatorInfo(pHandle->reader, pResBlock, pCols, tableIdList, pTaskInfo);
+          createStreamScanOperatorInfo(pHandle->reader, pResBlock, pCols, tableIdList, pTaskInfo, pScanPhyNode->node.pConditions);
       taosArrayDestroy(tableIdList);
       return pOperator;
     } else if (QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN == type) {
@@ -6924,7 +6924,7 @@ tsdbReaderT doCreateDataReader(STableScanPhysiNode* pTableScanNode, SReadHandle*
   code = initQueryTableDataCond(&cond, pTableScanNode);
   if (code != TSDB_CODE_SUCCESS) {
     goto _error;
-  }
+   }
 #if 0
   return tsdbQueryTables(pHandle->reader, &cond, pTableGroupInfo, queryId, taskId);
 #endif

source/libs/executor/src/scanoperator.c

@@ -514,6 +514,7 @@ static SSDataBlock* doStreamBlockScan(SOperatorInfo* pOperator, bool* newgroup)
   // NOTE: this operator does never check if current status is done or not
   SExecTaskInfo*        pTaskInfo = pOperator->pTaskInfo;
   SStreamBlockScanInfo* pInfo = pOperator->info;
+  int32_t rows = 0;
 
   pTaskInfo->code = pOperator->fpSet._openFn(pOperator);
   if (pTaskInfo->code != TSDB_CODE_SUCCESS || pOperator->status == OP_EXEC_DONE) {
@@ -580,6 +581,8 @@ static SSDataBlock* doStreamBlockScan(SOperatorInfo* pOperator, bool* newgroup)
         pTaskInfo->code = terrno;
         return NULL;
       }
+      rows = pBlockInfo->rows;
+      doFilter(pInfo->pCondition, pInfo->pRes);
 
       break;
     }
@@ -588,16 +591,16 @@ static SSDataBlock* doStreamBlockScan(SOperatorInfo* pOperator, bool* newgroup)
     pInfo->numOfExec++;
     pInfo->numOfRows += pBlockInfo->rows;
 
-    if (pBlockInfo->rows == 0) {
+    if (rows == 0) {
       pOperator->status = OP_EXEC_DONE;
     }
 
-    return (pBlockInfo->rows == 0) ? NULL : pInfo->pRes;
+    return (rows == 0) ? NULL : pInfo->pRes;
   }
 }
 
 SOperatorInfo* createStreamScanOperatorInfo(void* streamReadHandle, SSDataBlock* pResBlock, SArray* pColList,
-                                            SArray* pTableIdList, SExecTaskInfo* pTaskInfo) {
+                                            SArray* pTableIdList, SExecTaskInfo* pTaskInfo, SNode* pCondition) {
   SStreamBlockScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamBlockScanInfo));
   SOperatorInfo*        pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
   if (pInfo == NULL || pOperator == NULL) {
@@ -635,6 +638,7 @@ SOperatorInfo* createStreamScanOperatorInfo(void* streamReadHandle, SSDataBlock*
 
   pInfo->readerHandle = streamReadHandle;
   pInfo->pRes = pResBlock;
+  pInfo->pCondition = pCondition;
 
   pOperator->name = "StreamBlockScanOperator";
   pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN;

source/libs/nodes/src/nodesCodeFuncs.c

@@ -1911,23 +1911,51 @@ static int32_t jsonToDatum(const SJson* pJson, void* pObj) {
       break;
     case TSDB_DATA_TYPE_BOOL:
       code = tjsonGetBoolValue(pJson, jkValueDatum, &pNode->datum.b);
+      *(bool*)&pNode->typeData = pNode->datum.b;
       break;
     case TSDB_DATA_TYPE_TINYINT:
+      code = tjsonGetBigIntValue(pJson, jkValueDatum, &pNode->datum.i);
+      *(int8_t*)&pNode->typeData = pNode->datum.i;
+      break;
     case TSDB_DATA_TYPE_SMALLINT:
+      code = tjsonGetBigIntValue(pJson, jkValueDatum, &pNode->datum.i);
+      *(int16_t*)&pNode->typeData = pNode->datum.i;
+      break;
     case TSDB_DATA_TYPE_INT:
+      code = tjsonGetBigIntValue(pJson, jkValueDatum, &pNode->datum.i);
+      *(int32_t*)&pNode->typeData = pNode->datum.i;
+      break;
     case TSDB_DATA_TYPE_BIGINT:
+      code = tjsonGetBigIntValue(pJson, jkValueDatum, &pNode->datum.i);
+      *(int64_t*)&pNode->typeData = pNode->datum.i;
+      break;
     case TSDB_DATA_TYPE_TIMESTAMP:
       code = tjsonGetBigIntValue(pJson, jkValueDatum, &pNode->datum.i);
+      *(int64_t*)&pNode->typeData = pNode->datum.i;
       break;
     case TSDB_DATA_TYPE_UTINYINT:
+      code = tjsonGetUBigIntValue(pJson, jkValueDatum, &pNode->datum.u);
+      *(uint8_t*)&pNode->typeData = pNode->datum.u;
+      break;
     case TSDB_DATA_TYPE_USMALLINT:
+      code = tjsonGetUBigIntValue(pJson, jkValueDatum, &pNode->datum.u);
+      *(uint16_t*)&pNode->typeData = pNode->datum.u;
+      break;
     case TSDB_DATA_TYPE_UINT:
+      code = tjsonGetUBigIntValue(pJson, jkValueDatum, &pNode->datum.u);
+      *(uint32_t*)&pNode->typeData = pNode->datum.u;
+      break;
     case TSDB_DATA_TYPE_UBIGINT:
       code = tjsonGetUBigIntValue(pJson, jkValueDatum, &pNode->datum.u);
+      *(uint64_t*)&pNode->typeData = pNode->datum.u;
       break;
     case TSDB_DATA_TYPE_FLOAT:
+      code = tjsonGetDoubleValue(pJson, jkValueDatum, &pNode->datum.d);
+      *(float*)&pNode->typeData = pNode->datum.d;
+      break;
     case TSDB_DATA_TYPE_DOUBLE:
       code = tjsonGetDoubleValue(pJson, jkValueDatum, &pNode->datum.d);
+      *(double*)&pNode->typeData = pNode->datum.d;
       break;
     case TSDB_DATA_TYPE_NCHAR:
     case TSDB_DATA_TYPE_VARCHAR:

source/libs/nodes/src/nodesUtilFuncs.c

@@ -871,21 +871,18 @@ void nodesClearList(SNodeList* pList) {
 void* nodesGetValueFromNode(SValueNode* pNode) {
   switch (pNode->node.resType.type) {
     case TSDB_DATA_TYPE_BOOL:
-      return (void*)&pNode->datum.b;
     case TSDB_DATA_TYPE_TINYINT:
     case TSDB_DATA_TYPE_SMALLINT:
     case TSDB_DATA_TYPE_INT:
     case TSDB_DATA_TYPE_BIGINT:
     case TSDB_DATA_TYPE_TIMESTAMP:
-      return (void*)&pNode->datum.i;
     case TSDB_DATA_TYPE_UTINYINT:
     case TSDB_DATA_TYPE_USMALLINT:
     case TSDB_DATA_TYPE_UINT:
     case TSDB_DATA_TYPE_UBIGINT:
-      return (void*)&pNode->datum.u;
     case TSDB_DATA_TYPE_FLOAT:
     case TSDB_DATA_TYPE_DOUBLE:
-      return (void*)&pNode->datum.d;
+      return (void*)&pNode->typeData;
     case TSDB_DATA_TYPE_NCHAR:
     case TSDB_DATA_TYPE_VARCHAR:
     case TSDB_DATA_TYPE_VARBINARY:
@@ -897,6 +894,68 @@ void* nodesGetValueFromNode(SValueNode* pNode) {
   return NULL;
 }
 
+int32_t nodesSetValueNodeValue(SValueNode* pNode, void *value) {
+  switch (pNode->node.resType.type) {
+    case TSDB_DATA_TYPE_BOOL:
+      pNode->datum.b = *(bool*)value;
+      *(bool*)&pNode->typeData = pNode->datum.b;
+      break;
+    case TSDB_DATA_TYPE_TINYINT:
+      pNode->datum.i = *(int8_t*)value;
+      *(int8_t*)&pNode->typeData = pNode->datum.i;
+      break;
+    case TSDB_DATA_TYPE_SMALLINT:
+      pNode->datum.i = *(int16_t*)value;
+      *(int16_t*)&pNode->typeData = pNode->datum.i;
+      break;
+    case TSDB_DATA_TYPE_INT:
+      pNode->datum.i = *(int32_t*)value;
+      *(int32_t*)&pNode->typeData = pNode->datum.i;
+      break;
+    case TSDB_DATA_TYPE_BIGINT:
+      pNode->datum.i = *(int64_t*)value;
+      *(int64_t*)&pNode->typeData = pNode->datum.i;
+      break;
+    case TSDB_DATA_TYPE_TIMESTAMP:
+      pNode->datum.i = *(int64_t*)value;
+      *(int64_t*)&pNode->typeData = pNode->datum.i;
+      break;
+    case TSDB_DATA_TYPE_UTINYINT:
+      pNode->datum.u = *(int8_t*)value;
+      *(int8_t*)&pNode->typeData = pNode->datum.u;
+      break;
+    case TSDB_DATA_TYPE_USMALLINT:
+      pNode->datum.u = *(int16_t*)value;
+      *(int16_t*)&pNode->typeData = pNode->datum.u;
+      break;
+    case TSDB_DATA_TYPE_UINT:
+      pNode->datum.u = *(int32_t*)value;
+      *(int32_t*)&pNode->typeData = pNode->datum.u;
+      break;
+    case TSDB_DATA_TYPE_UBIGINT:
+      pNode->datum.u = *(uint64_t*)value;
+      *(uint64_t*)&pNode->typeData = pNode->datum.u;
+      break;
+    case TSDB_DATA_TYPE_FLOAT:
+      pNode->datum.d = *(float*)value;
+      *(float*)&pNode->typeData = pNode->datum.d;
+      break;
+    case TSDB_DATA_TYPE_DOUBLE:
+      pNode->datum.d = *(double*)value;
+      *(double*)&pNode->typeData = pNode->datum.d;
+      break;
+    case TSDB_DATA_TYPE_NCHAR:
+    case TSDB_DATA_TYPE_VARCHAR:
+    case TSDB_DATA_TYPE_VARBINARY:
+      pNode->datum.p = (char*)value;
+      break;
+    default:
+      return TSDB_CODE_QRY_APP_ERROR;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
 char* nodesGetStrValueFromNode(SValueNode* pNode) {
   switch (pNode->node.resType.type) {
     case TSDB_DATA_TYPE_BOOL: {

source/libs/parser/src/parTranslater.c

@@ -466,27 +466,66 @@ static EDealRes translateValue(STranslateContext* pCxt, SValueNode* pVal) {
         break;
       case TSDB_DATA_TYPE_BOOL:
         pVal->datum.b = (0 == strcasecmp(pVal->literal, "true"));
+        *(bool*)&pVal->typeData = pVal->datum.b;
         break;
-      case TSDB_DATA_TYPE_TINYINT:
+      case TSDB_DATA_TYPE_TINYINT:{
-      case TSDB_DATA_TYPE_SMALLINT:
+        char* endPtr = NULL;
-      case TSDB_DATA_TYPE_INT:
+        pVal->datum.i = strtoll(pVal->literal, &endPtr, 10);
+        *(int8_t*)&pVal->typeData = pVal->datum.i;
+        break;
+      }
+      case TSDB_DATA_TYPE_SMALLINT:{
+        char* endPtr = NULL;
+        pVal->datum.i = strtoll(pVal->literal, &endPtr, 10);
+        *(int16_t*)&pVal->typeData = pVal->datum.i;
+        break;
+      }
+      case TSDB_DATA_TYPE_INT:{
+        char* endPtr = NULL;
+        pVal->datum.i = strtoll(pVal->literal, &endPtr, 10);
+        *(int32_t*)&pVal->typeData = pVal->datum.i;
+        break;
+      }
       case TSDB_DATA_TYPE_BIGINT: {
         char* endPtr = NULL;
         pVal->datum.i = strtoll(pVal->literal, &endPtr, 10);
+        *(int64_t*)&pVal->typeData = pVal->datum.i;        
+        break;
+      }
+      case TSDB_DATA_TYPE_UTINYINT:{
+        char* endPtr = NULL;
+        pVal->datum.u = strtoull(pVal->literal, &endPtr, 10);
+        *(uint8_t*)&pVal->typeData = pVal->datum.u;        
+        break;
+      }
+      case TSDB_DATA_TYPE_USMALLINT:{
+        char* endPtr = NULL;
+        pVal->datum.u = strtoull(pVal->literal, &endPtr, 10);
+        *(uint16_t*)&pVal->typeData = pVal->datum.u;        
+        break;
+      }
+      case TSDB_DATA_TYPE_UINT:{
+        char* endPtr = NULL;
+        pVal->datum.u = strtoull(pVal->literal, &endPtr, 10);
+        *(uint32_t*)&pVal->typeData = pVal->datum.u;        
         break;
       }
-      case TSDB_DATA_TYPE_UTINYINT:
-      case TSDB_DATA_TYPE_USMALLINT:
-      case TSDB_DATA_TYPE_UINT:
       case TSDB_DATA_TYPE_UBIGINT: {
         char* endPtr = NULL;
         pVal->datum.u = strtoull(pVal->literal, &endPtr, 10);
+        *(uint64_t*)&pVal->typeData = pVal->datum.u;                
+        break;
+      }
+      case TSDB_DATA_TYPE_FLOAT:{
+        char* endPtr = NULL;
+        pVal->datum.d = strtold(pVal->literal, &endPtr);
+        *(float*)&pVal->typeData = pVal->datum.d;     
         break;
       }
-      case TSDB_DATA_TYPE_FLOAT:
       case TSDB_DATA_TYPE_DOUBLE: {
         char* endPtr = NULL;
         pVal->datum.d = strtold(pVal->literal, &endPtr);
+        *(double*)&pVal->typeData = pVal->datum.d;     
         break;
       }
       case TSDB_DATA_TYPE_VARCHAR:
@@ -504,6 +543,7 @@ static EDealRes translateValue(STranslateContext* pCxt, SValueNode* pVal) {
             TSDB_CODE_SUCCESS) {
           return generateDealNodeErrMsg(pCxt, TSDB_CODE_PAR_WRONG_VALUE_TYPE, pVal->literal);
         }
+        *(int64_t*)&pVal->typeData = pVal->datum.i;        
         break;
       }
       case TSDB_DATA_TYPE_NCHAR:
@@ -3199,11 +3239,11 @@ static int32_t rewriteShow(STranslateContext* pCxt, SQuery* pQuery) {
   return code;
 }
 
-typedef struct SVgroupTablesBatch {
+typedef struct SVgroupCreateTableBatch {
   SVCreateTbBatchReq req;
   SVgroupInfo        info;
   char               dbName[TSDB_DB_NAME_LEN];
-} SVgroupTablesBatch;
+} SVgroupCreateTableBatch;
 
 static void destroyCreateTbReq(SVCreateTbReq* pReq) {
   taosMemoryFreeClear(pReq->name);
@@ -3211,7 +3251,7 @@ static void destroyCreateTbReq(SVCreateTbReq* pReq) {
 }
 
 static int32_t buildNormalTableBatchReq(int32_t acctId, const SCreateTableStmt* pStmt, const SVgroupInfo* pVgroupInfo,
-                                        SVgroupTablesBatch* pBatch) {
+                                        SVgroupCreateTableBatch* pBatch) {
   char  dbFName[TSDB_DB_FNAME_LEN] = {0};
   SName name = {.type = TSDB_DB_NAME_T, .acctId = acctId};
   strcpy(name.dbname, pStmt->dbName);
@@ -3245,13 +3285,13 @@ static int32_t buildNormalTableBatchReq(int32_t acctId, const SCreateTableStmt*
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t serializeVgroupTablesBatch(SVgroupTablesBatch* pTbBatch, SArray* pBufArray) {
+static int32_t serializeVgroupCreateTableBatch(SVgroupCreateTableBatch* pTbBatch, SArray* pBufArray) {
   int    tlen;
   SCoder coder = {0};
 
   int32_t ret = 0;
   tEncodeSize(tEncodeSVCreateTbBatchReq, &pTbBatch->req, tlen, ret);
-  tlen += sizeof(SMsgHead);  //+ tSerializeSVCreateTbBatchReq(NULL, &(pTbBatch->req));
+  tlen += sizeof(SMsgHead);
   void* buf = taosMemoryMalloc(tlen);
   if (NULL == buf) {
     return TSDB_CODE_OUT_OF_MEMORY;
@@ -3277,7 +3317,7 @@ static int32_t serializeVgroupTablesBatch(SVgroupTablesBatch* pTbBatch, SArray*
   return TSDB_CODE_SUCCESS;
 }
 
-static void destroyCreateTbReqBatch(SVgroupTablesBatch* pTbBatch) {
+static void destroyCreateTbReqBatch(SVgroupCreateTableBatch* pTbBatch) {
   size_t size = taosArrayGetSize(pTbBatch->req.pArray);
   for (int32_t i = 0; i < size; ++i) {
     SVCreateTbReq* pTableReq = taosArrayGet(pTbBatch->req.pArray, i);
@@ -3322,10 +3362,10 @@ static int32_t buildCreateTableDataBlock(int32_t acctId, const SCreateTableStmt*
     return TSDB_CODE_OUT_OF_MEMORY;
   }
 
-  SVgroupTablesBatch tbatch = {0};
+  SVgroupCreateTableBatch tbatch = {0};
-  int32_t            code = buildNormalTableBatchReq(acctId, pStmt, pInfo, &tbatch);
+  int32_t                 code = buildNormalTableBatchReq(acctId, pStmt, pInfo, &tbatch);
   if (TSDB_CODE_SUCCESS == code) {
-    code = serializeVgroupTablesBatch(&tbatch, *pBufArray);
+    code = serializeVgroupCreateTableBatch(&tbatch, *pBufArray);
   }
 
   destroyCreateTbReqBatch(&tbatch);
@@ -3370,9 +3410,9 @@ static void addCreateTbReqIntoVgroup(int32_t acctId, SHashObj* pVgroupHashmap, c
   req.ctb.suid = suid;
   req.ctb.pTag = row;
 
-  SVgroupTablesBatch* pTableBatch = taosHashGet(pVgroupHashmap, &pVgInfo->vgId, sizeof(pVgInfo->vgId));
+  SVgroupCreateTableBatch* pTableBatch = taosHashGet(pVgroupHashmap, &pVgInfo->vgId, sizeof(pVgInfo->vgId));
   if (pTableBatch == NULL) {
-    SVgroupTablesBatch tBatch = {0};
+    SVgroupCreateTableBatch tBatch = {0};
     tBatch.info = *pVgInfo;
     strcpy(tBatch.dbName, pDbName);
 
@@ -3545,21 +3585,21 @@ static int32_t rewriteCreateSubTable(STranslateContext* pCxt, SCreateSubTableCla
   return code;
 }
 
-static SArray* serializeVgroupsTablesBatch(int32_t acctId, SHashObj* pVgroupHashmap) {
+static SArray* serializeVgroupsCreateTableBatch(int32_t acctId, SHashObj* pVgroupHashmap) {
   SArray* pBufArray = taosArrayInit(taosHashGetSize(pVgroupHashmap), sizeof(void*));
   if (NULL == pBufArray) {
     return NULL;
   }
 
-  int32_t             code = TSDB_CODE_SUCCESS;
+  int32_t                  code = TSDB_CODE_SUCCESS;
-  SVgroupTablesBatch* pTbBatch = NULL;
+  SVgroupCreateTableBatch* pTbBatch = NULL;
   do {
     pTbBatch = taosHashIterate(pVgroupHashmap, pTbBatch);
     if (pTbBatch == NULL) {
       break;
     }
 
-    serializeVgroupTablesBatch(pTbBatch, pBufArray);
+    serializeVgroupCreateTableBatch(pTbBatch, pBufArray);
     destroyCreateTbReqBatch(pTbBatch);
   } while (true);
 
@@ -3584,7 +3624,143 @@ static int32_t rewriteCreateMultiTable(STranslateContext* pCxt, SQuery* pQuery)
     }
   }
 
-  SArray* pBufArray = serializeVgroupsTablesBatch(pCxt->pParseCxt->acctId, pVgroupHashmap);
+  SArray* pBufArray = serializeVgroupsCreateTableBatch(pCxt->pParseCxt->acctId, pVgroupHashmap);
+  taosHashCleanup(pVgroupHashmap);
+  if (NULL == pBufArray) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  return rewriteToVnodeModifOpStmt(pQuery, pBufArray);
+}
+
+typedef struct SVgroupDropTableBatch {
+  SVDropTbBatchReq req;
+  SVgroupInfo      info;
+  char             dbName[TSDB_DB_NAME_LEN];
+} SVgroupDropTableBatch;
+
+static void addDropTbReqIntoVgroup(SHashObj* pVgroupHashmap, SDropTableClause* pClause, SVgroupInfo* pVgInfo) {
+  SVDropTbReq            req = {.name = pClause->tableName, .igNotExists = pClause->ignoreNotExists};
+  SVgroupDropTableBatch* pTableBatch = taosHashGet(pVgroupHashmap, &pVgInfo->vgId, sizeof(pVgInfo->vgId));
+  if (NULL == pTableBatch) {
+    SVgroupDropTableBatch tBatch = {0};
+    tBatch.info = *pVgInfo;
+    tBatch.req.pArray = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SVDropTbReq));
+    taosArrayPush(tBatch.req.pArray, &req);
+
+    taosHashPut(pVgroupHashmap, &pVgInfo->vgId, sizeof(pVgInfo->vgId), &tBatch, sizeof(tBatch));
+  } else {  // add to the correct vgroup
+    taosArrayPush(pTableBatch->req.pArray, &req);
+  }
+}
+
+static int32_t buildDropTableVgroupHashmap(STranslateContext* pCxt, SDropTableClause* pClause, bool* pIsSuperTable,
+                                           SHashObj* pVgroupHashmap) {
+  STableMeta* pTableMeta = NULL;
+  int32_t     code = getTableMeta(pCxt, pClause->dbName, pClause->tableName, &pTableMeta);
+
+  if (TSDB_CODE_SUCCESS == code && TSDB_SUPER_TABLE == pTableMeta->tableType) {
+    *pIsSuperTable = true;
+    goto over;
+  }
+
+  *pIsSuperTable = false;
+
+  SVgroupInfo info = {0};
+  if (TSDB_CODE_SUCCESS == code) {
+    code = getTableHashVgroup(pCxt, pClause->dbName, pClause->tableName, &info);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    addDropTbReqIntoVgroup(pVgroupHashmap, pClause, &info);
+  }
+
+over:
+  taosMemoryFreeClear(pTableMeta);
+  return code;
+}
+
+static void destroyDropTbReqBatch(SVgroupDropTableBatch* pTbBatch) { taosArrayDestroy(pTbBatch->req.pArray); }
+
+static int32_t serializeVgroupDropTableBatch(SVgroupDropTableBatch* pTbBatch, SArray* pBufArray) {
+  int    tlen;
+  SCoder coder = {0};
+
+  int32_t ret = 0;
+  tEncodeSize(tEncodeSVDropTbBatchReq, &pTbBatch->req, tlen, ret);
+  tlen += sizeof(SMsgHead);
+  void* buf = taosMemoryMalloc(tlen);
+  if (NULL == buf) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+  ((SMsgHead*)buf)->vgId = htonl(pTbBatch->info.vgId);
+  ((SMsgHead*)buf)->contLen = htonl(tlen);
+  void* pBuf = POINTER_SHIFT(buf, sizeof(SMsgHead));
+
+  tCoderInit(&coder, TD_LITTLE_ENDIAN, pBuf, tlen - sizeof(SMsgHead), TD_ENCODER);
+  tEncodeSVDropTbBatchReq(&coder, &pTbBatch->req);
+  tCoderClear(&coder);
+
+  SVgDataBlocks* pVgData = taosMemoryCalloc(1, sizeof(SVgDataBlocks));
+  if (NULL == pVgData) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+  pVgData->vg = pTbBatch->info;
+  pVgData->pData = buf;
+  pVgData->size = tlen;
+  pVgData->numOfTables = (int32_t)taosArrayGetSize(pTbBatch->req.pArray);
+  taosArrayPush(pBufArray, &pVgData);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static SArray* serializeVgroupsDropTableBatch(int32_t acctId, SHashObj* pVgroupHashmap) {
+  SArray* pBufArray = taosArrayInit(taosHashGetSize(pVgroupHashmap), sizeof(void*));
+  if (NULL == pBufArray) {
+    return NULL;
+  }
+
+  int32_t                code = TSDB_CODE_SUCCESS;
+  SVgroupDropTableBatch* pTbBatch = NULL;
+  do {
+    pTbBatch = taosHashIterate(pVgroupHashmap, pTbBatch);
+    if (pTbBatch == NULL) {
+      break;
+    }
+
+    serializeVgroupDropTableBatch(pTbBatch, pBufArray);
+    destroyDropTbReqBatch(pTbBatch);
+  } while (true);
+
+  return pBufArray;
+}
+
+static int32_t rewriteDropTable(STranslateContext* pCxt, SQuery* pQuery) {
+  SDropTableStmt* pStmt = (SDropTableStmt*)pQuery->pRoot;
+
+  SHashObj* pVgroupHashmap = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_NO_LOCK);
+  if (NULL == pVgroupHashmap) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  bool   isSuperTable = false;
+  SNode* pNode;
+  FOREACH(pNode, pStmt->pTables) {
+    int32_t code = buildDropTableVgroupHashmap(pCxt, (SDropTableClause*)pNode, &isSuperTable, pVgroupHashmap);
+    if (TSDB_CODE_SUCCESS != code) {
+      taosHashCleanup(pVgroupHashmap);
+      return code;
+    }
+    if (isSuperTable && LIST_LENGTH(pStmt->pTables) > 1) {
+      return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_DROP_STABLE);
+    }
+  }
+
+  if (isSuperTable) {
+    taosHashCleanup(pVgroupHashmap);
+    return TSDB_CODE_SUCCESS;
+  }
+
+  SArray* pBufArray = serializeVgroupsDropTableBatch(pCxt->pParseCxt->acctId, pVgroupHashmap);
   taosHashCleanup(pVgroupHashmap);
   if (NULL == pBufArray) {
     return TSDB_CODE_OUT_OF_MEMORY;
@@ -3630,6 +3806,9 @@ static int32_t rewriteQuery(STranslateContext* pCxt, SQuery* pQuery) {
     case QUERY_NODE_CREATE_MULTI_TABLE_STMT:
       code = rewriteCreateMultiTable(pCxt, pQuery);
       break;
+    case QUERY_NODE_DROP_TABLE_STMT:
+      code = rewriteDropTable(pCxt, pQuery);
+      break;
     case QUERY_NODE_ALTER_TABLE_STMT:
       if (TSDB_ALTER_TABLE_UPDATE_TAG_VAL == ((SAlterTableStmt*)pQuery->pRoot)->alterType) {
         code = rewriteAlterTable(pCxt, pQuery);

source/libs/parser/src/parUtil.c

@@ -126,6 +126,8 @@ static char* getSyntaxErrFormat(int32_t errCode) {
       return "slimit/soffset only available for PARTITION BY query";
     case TSDB_CODE_PAR_INVALID_TOPIC_QUERY:
       return "Invalid topic query";
+    case TSDB_CODE_PAR_INVALID_DROP_STABLE:
+      return "Cannot drop super table in batch";
     case TSDB_CODE_OUT_OF_MEMORY:
       return "Out of memory";
     default:

source/libs/planner/src/planLogicCreater.c

@@ -944,9 +944,16 @@ static int32_t createSetOperatorLogicNode(SLogicPlanContext* pCxt, SSetOperator*
 }
 
 static int32_t getMsgType(ENodeType sqlType) {
-  return (QUERY_NODE_CREATE_TABLE_STMT == sqlType || QUERY_NODE_CREATE_MULTI_TABLE_STMT == sqlType)
+  switch (sqlType) {
-             ? TDMT_VND_CREATE_TABLE
+    case QUERY_NODE_CREATE_TABLE_STMT:
-             : TDMT_VND_SUBMIT;
+    case QUERY_NODE_CREATE_MULTI_TABLE_STMT:
+      return TDMT_VND_CREATE_TABLE;
+    case QUERY_NODE_DROP_TABLE_STMT:
+      return TDMT_VND_DROP_TABLE;
+    default:
+      break;
+  }
+  return TDMT_VND_SUBMIT;
 }
 
 static int32_t createVnodeModifLogicNode(SLogicPlanContext* pCxt, SVnodeModifOpStmt* pStmt, SLogicNode** pLogicNode) {

source/libs/planner/src/planOptimizer.c

@@ -206,6 +206,8 @@ static int32_t cpdMergeCond(SNode** pDst, SNode** pSrc) {
   if (NULL == pLogicCond) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }
+  pLogicCond->node.resType.type = TSDB_DATA_TYPE_BOOL;
+  pLogicCond->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes;
   pLogicCond->condType = LOGIC_COND_TYPE_AND;
   int32_t code = nodesListMakeAppend(&pLogicCond->pParameterList, *pSrc);
   if (TSDB_CODE_SUCCESS == code) {

source/libs/planner/src/planner.c

@@ -104,8 +104,9 @@ static int32_t setValueByBindParam(SValueNode* pVal, TAOS_MULTI_BIND* pParam) {
     pVal->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_NULL].bytes;
     return TSDB_CODE_SUCCESS;
   }
+  int32_t inputSize = (NULL != pParam->length ? *(pParam->length) : tDataTypes[pParam->buffer_type].bytes);
   pVal->node.resType.type = pParam->buffer_type;
-  pVal->node.resType.bytes = NULL != pParam->length ? *(pParam->length) : tDataTypes[pParam->buffer_type].bytes;
+  pVal->node.resType.bytes = inputSize;
   switch (pParam->buffer_type) {
     case TSDB_DATA_TYPE_BOOL:
       pVal->datum.b = *((bool*)pParam->buffer);
@@ -130,7 +131,6 @@ static int32_t setValueByBindParam(SValueNode* pVal, TAOS_MULTI_BIND* pParam) {
       break;
     case TSDB_DATA_TYPE_VARCHAR:
     case TSDB_DATA_TYPE_VARBINARY:
-    case TSDB_DATA_TYPE_NCHAR:
       pVal->datum.p = taosMemoryCalloc(1, pVal->node.resType.bytes + VARSTR_HEADER_SIZE + 1);
       if (NULL == pVal->datum.p) {
         return TSDB_CODE_OUT_OF_MEMORY;
@@ -138,6 +138,21 @@ static int32_t setValueByBindParam(SValueNode* pVal, TAOS_MULTI_BIND* pParam) {
       varDataSetLen(pVal->datum.p, pVal->node.resType.bytes);
       strncpy(varDataVal(pVal->datum.p), (const char*)pParam->buffer, pVal->node.resType.bytes);
       break;
+    case TSDB_DATA_TYPE_NCHAR: {
+      pVal->node.resType.bytes *= TSDB_NCHAR_SIZE;
+      pVal->datum.p = taosMemoryCalloc(1, pVal->node.resType.bytes + VARSTR_HEADER_SIZE + 1);
+      if (NULL == pVal->datum.p) {
+        return TSDB_CODE_OUT_OF_MEMORY;
+      }
+      
+      int32_t output = 0;
+      if (!taosMbsToUcs4(pParam->buffer, inputSize, (TdUcs4*)varDataVal(pVal->datum.p), pVal->node.resType.bytes, &output)) {
+        return errno;
+      }
+      varDataSetLen(pVal->datum.p, output);
+      pVal->node.resType.bytes = output;
+      break;
+    }
     case TSDB_DATA_TYPE_TIMESTAMP:
       pVal->datum.i = *((int64_t*)pParam->buffer);
       break;
@@ -181,13 +196,20 @@ static EDealRes updatePlanQueryId(SNode* pNode, void* pContext) {
 
 int32_t qStmtBindParam(SQueryPlan* pPlan, TAOS_MULTI_BIND* pParams, int32_t colIdx, uint64_t queryId) {
   int32_t size = taosArrayGetSize(pPlan->pPlaceholderValues);
-
+  int32_t code = 0;
+  
   if (colIdx < 0) {
     for (int32_t i = 0; i < size; ++i) {
-      setValueByBindParam((SValueNode*)taosArrayGetP(pPlan->pPlaceholderValues, i), pParams + i);
+      code = setValueByBindParam((SValueNode*)taosArrayGetP(pPlan->pPlaceholderValues, i), pParams + i);
+      if (code) {
+        return code;
+      }
     }
   } else {
-    setValueByBindParam((SValueNode*)taosArrayGetP(pPlan->pPlaceholderValues, colIdx), pParams);
+    code = setValueByBindParam((SValueNode*)taosArrayGetP(pPlan->pPlaceholderValues, colIdx), pParams);
+    if (code) {
+      return code;
+    }
   }
 
   if (colIdx < 0 || ((colIdx + 1) == size)) {

source/libs/qworker/inc/qworkerInt.h

@@ -23,6 +23,7 @@ extern "C" {
 #include "qworker.h"
 #include "tlockfree.h"
 #include "ttimer.h"
+#include "tref.h"
 
 #define QW_DEFAULT_SCHEDULER_NUMBER 10000
 #define QW_DEFAULT_TASK_NUMBER      10000
@@ -85,6 +86,12 @@ typedef struct SQWMsg {
   SQWConnInfo connInfo;
 } SQWMsg;
 
+typedef struct SQWHbParam {
+  bool    inUse;
+  int32_t qwrId;
+  int64_t refId;
+} SQWHbParam;
+
 typedef struct SQWHbInfo {
   SSchedulerHbRsp rsp;
   SQWConnInfo     connInfo;
@@ -137,7 +144,8 @@ typedef struct SQWSchStatus {
 } SQWSchStatus;
 
 // Qnode/Vnode level task management
-typedef struct SQWorkerMgmt {
+typedef struct SQWorker {
+  int64_t     refId;
   SQWorkerCfg cfg;
   int8_t      nodeType;
   int32_t     nodeId;
@@ -148,9 +156,17 @@ typedef struct SQWorkerMgmt {
   SHashObj *schHash;  // key: schedulerId,    value: SQWSchStatus
   SHashObj *ctxHash;  // key: queryId+taskId, value: SQWTaskCtx
   SMsgCb    msgCb;
+} SQWorker;
+
+typedef struct SQWorkerMgmt {
+  SRWLatch   lock;
+  int32_t    qwRef;
+  int32_t    qwNum;
+  SQWHbParam param[1024];
+  int32_t    paramIdx;
 } SQWorkerMgmt;
 
-#define QW_FPARAMS_DEF SQWorkerMgmt *mgmt, uint64_t sId, uint64_t qId, uint64_t tId, int64_t rId
+#define QW_FPARAMS_DEF SQWorker *mgmt, uint64_t sId, uint64_t qId, uint64_t tId, int64_t rId
 #define QW_IDS()       sId, qId, tId, rId
 #define QW_FPARAMS()   mgmt, QW_IDS()
 
@@ -209,13 +225,13 @@ typedef struct SQWorkerMgmt {
     }                                \
   } while (0)
 
-#define QW_ELOG(param, ...) qError("QW:%p " param, mgmt, __VA_ARGS__)
+#define QW_ELOG(_param, ...) qError("QW:%p " _param, mgmt, __VA_ARGS__)
-#define QW_DLOG(param, ...) qDebug("QW:%p " param, mgmt, __VA_ARGS__)
+#define QW_DLOG(_param, ...) qDebug("QW:%p " _param, mgmt, __VA_ARGS__)
 
-#define QW_DUMP(param, ...)                      \
+#define QW_DUMP(_param, ...)                      \
   do {                                           \
     if (gQWDebug.dumpEnable) {                   \
-      qDebug("QW:%p " param, mgmt, __VA_ARGS__); \
+      qDebug("QW:%p " _param, mgmt, __VA_ARGS__); \
     }                                            \
   } while (0)
 
@@ -282,6 +298,14 @@ typedef struct SQWorkerMgmt {
     }                                                                                               \
   } while (0)
 
+
+extern SQWorkerMgmt gQwMgmt;
+
+FORCE_INLINE SQWorker *qwAcquire(int64_t refId) { return (SQWorker *)taosAcquireRef(atomic_load_32(&gQwMgmt.qwRef), refId); }
+
+FORCE_INLINE int32_t qwRelease(int64_t refId) { return taosReleaseRef(gQwMgmt.qwRef, refId); }
+
+
 #ifdef __cplusplus
 }
 #endif

source/libs/qworker/inc/qworkerMsg.h

@@ -28,7 +28,7 @@ int32_t qwProcessCQuery(QW_FPARAMS_DEF, SQWMsg *qwMsg);
 int32_t qwProcessReady(QW_FPARAMS_DEF, SQWMsg *qwMsg);
 int32_t qwProcessFetch(QW_FPARAMS_DEF, SQWMsg *qwMsg);
 int32_t qwProcessDrop(QW_FPARAMS_DEF, SQWMsg *qwMsg);
-int32_t qwProcessHb(SQWorkerMgmt *mgmt, SQWMsg *qwMsg, SSchedulerHbReq *req);
+int32_t qwProcessHb(SQWorker *mgmt, SQWMsg *qwMsg, SSchedulerHbReq *req);
 
 int32_t qwBuildAndSendDropRsp(SQWConnInfo *pConn, int32_t code);
 int32_t qwBuildAndSendCancelRsp(SQWConnInfo *pConn, int32_t code);
@@ -41,10 +41,10 @@ int32_t qwBuildAndSendQueryRsp(SQWConnInfo *pConn, int32_t code);
 int32_t qwBuildAndSendExplainRsp(SQWConnInfo *pConn, SExplainExecInfo *execInfo, int32_t num);
 void    qwFreeFetchRsp(void *msg);
 int32_t qwMallocFetchRsp(int32_t length, SRetrieveTableRsp **rsp);
-int32_t qwGetSchTasksStatus(SQWorkerMgmt *mgmt, uint64_t sId, SSchedulerStatusRsp **rsp);
+int32_t qwGetSchTasksStatus(SQWorker *mgmt, uint64_t sId, SSchedulerStatusRsp **rsp);
 int32_t qwBuildAndSendHbRsp(SQWConnInfo *pConn, SSchedulerHbRsp *rsp, int32_t code);
 int32_t qwRegisterQueryBrokenLinkArg(QW_FPARAMS_DEF, SQWConnInfo *pConn);
-int32_t qwRegisterHbBrokenLinkArg(SQWorkerMgmt *mgmt, uint64_t sId, SQWConnInfo *pConn);
+int32_t qwRegisterHbBrokenLinkArg(SQWorker *mgmt, uint64_t sId, SQWConnInfo *pConn);
 
 #ifdef __cplusplus
 }

source/libs/qworker/src/qworker.c

@@ -10,6 +10,11 @@
 #include "tname.h"
 
 SQWDebug gQWDebug = {.statusEnable = true, .dumpEnable = true};
+SQWorkerMgmt gQwMgmt = {
+  .lock  = 0,
+  .qwRef = -1, 
+  .qwNum = 0,
+};
 
 int32_t qwDbgValidateStatus(QW_FPARAMS_DEF, int8_t oriStatus, int8_t newStatus, bool *ignore) {
   if (!gQWDebug.statusEnable) {
@@ -98,7 +103,7 @@ _return:
 
 void qwDbgDumpSchInfo(SQWSchStatus *sch, int32_t i) {}
 
-void qwDbgDumpMgmtInfo(SQWorkerMgmt *mgmt) {
+void qwDbgDumpMgmtInfo(SQWorker *mgmt) {
   if (!gQWDebug.dumpEnable) {
     return;
   }
@@ -186,7 +191,7 @@ int32_t qwSetTaskStatus(QW_FPARAMS_DEF, SQWTaskStatus *task, int8_t status) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t qwAddSchedulerImpl(SQWorkerMgmt *mgmt, uint64_t sId, int32_t rwType) {
+int32_t qwAddSchedulerImpl(SQWorker *mgmt, uint64_t sId, int32_t rwType) {
   SQWSchStatus newSch = {0};
   newSch.tasksHash =
       taosHashInit(mgmt->cfg.maxSchTaskNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
@@ -213,7 +218,7 @@ int32_t qwAddSchedulerImpl(SQWorkerMgmt *mgmt, uint64_t sId, int32_t rwType) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t qwAcquireSchedulerImpl(SQWorkerMgmt *mgmt, uint64_t sId, int32_t rwType, SQWSchStatus **sch, int32_t nOpt) {
+int32_t qwAcquireSchedulerImpl(SQWorker *mgmt, uint64_t sId, int32_t rwType, SQWSchStatus **sch, int32_t nOpt) {
   while (true) {
     QW_LOCK(rwType, &mgmt->schLock);
     *sch = taosHashGet(mgmt->schHash, &sId, sizeof(sId));
@@ -240,15 +245,15 @@ int32_t qwAcquireSchedulerImpl(SQWorkerMgmt *mgmt, uint64_t sId, int32_t rwType,
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t qwAcquireAddScheduler(SQWorkerMgmt *mgmt, uint64_t sId, int32_t rwType, SQWSchStatus **sch) {
+int32_t qwAcquireAddScheduler(SQWorker *mgmt, uint64_t sId, int32_t rwType, SQWSchStatus **sch) {
   return qwAcquireSchedulerImpl(mgmt, sId, rwType, sch, QW_NOT_EXIST_ADD);
 }
 
-int32_t qwAcquireScheduler(SQWorkerMgmt *mgmt, uint64_t sId, int32_t rwType, SQWSchStatus **sch) {
+int32_t qwAcquireScheduler(SQWorker *mgmt, uint64_t sId, int32_t rwType, SQWSchStatus **sch) {
   return qwAcquireSchedulerImpl(mgmt, sId, rwType, sch, QW_NOT_EXIST_RET_ERR);
 }
 
-void qwReleaseScheduler(int32_t rwType, SQWorkerMgmt *mgmt) { QW_UNLOCK(rwType, &mgmt->schLock); }
+void qwReleaseScheduler(int32_t rwType, SQWorker *mgmt) { QW_UNLOCK(rwType, &mgmt->schLock); }
 
 int32_t qwAcquireTaskStatus(QW_FPARAMS_DEF, int32_t rwType, SQWSchStatus *sch, SQWTaskStatus **task) {
   char id[sizeof(qId) + sizeof(tId)] = {0};
@@ -384,7 +389,7 @@ int32_t qwAddTaskCtx(QW_FPARAMS_DEF) { QW_RET(qwAddTaskCtxImpl(QW_FPARAMS(), fal
 
 int32_t qwAddAcquireTaskCtx(QW_FPARAMS_DEF, SQWTaskCtx **ctx) { return qwAddTaskCtxImpl(QW_FPARAMS(), true, ctx); }
 
-void qwReleaseTaskCtx(SQWorkerMgmt *mgmt, void *ctx) { taosHashRelease(mgmt->ctxHash, ctx); }
+void qwReleaseTaskCtx(SQWorker *mgmt, void *ctx) { taosHashRelease(mgmt->ctxHash, ctx); }
 
 void qwFreeTaskHandle(QW_FPARAMS_DEF, qTaskInfo_t *taskHandle) {
   // Note: free/kill may in RC
@@ -606,7 +611,7 @@ int32_t qwExecTask(QW_FPARAMS_DEF, SQWTaskCtx *ctx, bool *queryEnd) {
   QW_RET(code);
 }
 
-int32_t qwGenerateSchHbRsp(SQWorkerMgmt *mgmt, SQWSchStatus *sch, SQWHbInfo *hbInfo) {
+int32_t qwGenerateSchHbRsp(SQWorker *mgmt, SQWSchStatus *sch, SQWHbInfo *hbInfo) {
   int32_t taskNum = 0;
 
   hbInfo->connInfo = sch->hbConnInfo;
@@ -1262,7 +1267,7 @@ _return:
   QW_RET(TSDB_CODE_SUCCESS);
 }
 
-int32_t qwProcessHbLinkBroken(SQWorkerMgmt *mgmt, SQWMsg *qwMsg, SSchedulerHbReq *req) {
+int32_t qwProcessHbLinkBroken(SQWorker *mgmt, SQWMsg *qwMsg, SSchedulerHbReq *req) {
   int32_t         code = 0;
   SSchedulerHbRsp rsp = {0};
   SQWSchStatus *  sch = NULL;
@@ -1288,7 +1293,7 @@ int32_t qwProcessHbLinkBroken(SQWorkerMgmt *mgmt, SQWMsg *qwMsg, SSchedulerHbReq
   QW_RET(TSDB_CODE_SUCCESS);
 }
 
-int32_t qwProcessHb(SQWorkerMgmt *mgmt, SQWMsg *qwMsg, SSchedulerHbReq *req) {
+int32_t qwProcessHb(SQWorker *mgmt, SQWMsg *qwMsg, SSchedulerHbReq *req) {
   int32_t         code = 0;
   SSchedulerHbRsp rsp = {0};
   SQWSchStatus *  sch = NULL;
@@ -1333,7 +1338,19 @@ _return:
 }
 
 void qwProcessHbTimerEvent(void *param, void *tmrId) {
-  SQWorkerMgmt *mgmt = (SQWorkerMgmt *)param;
+  SQWHbParam* hbParam = (SQWHbParam*)param;
+  if (hbParam->qwrId != atomic_load_32(&gQwMgmt.qwRef)) {
+    return;
+  }
+
+  int64_t refId = hbParam->refId;
+  SQWorker *mgmt = qwAcquire(refId);
+  if (NULL == mgmt) {
+    QW_DLOG("qwAcquire %" PRIx64 "failed", refId);
+    taosMemoryFree(param);
+    return;
+  }
+  
   SQWSchStatus *sch = NULL;
   int32_t       taskNum = 0;
   SQWHbInfo *   rspList = NULL;
@@ -1347,6 +1364,7 @@ void qwProcessHbTimerEvent(void *param, void *tmrId) {
   if (schNum <= 0) {
     QW_UNLOCK(QW_READ, &mgmt->schLock);
     taosTmrReset(qwProcessHbTimerEvent, QW_DEFAULT_HEARTBEAT_MSEC, param, mgmt->timer, &mgmt->hbTimer);
+    qwRelease(refId);
     return;
   }
 
@@ -1355,6 +1373,7 @@ void qwProcessHbTimerEvent(void *param, void *tmrId) {
     QW_UNLOCK(QW_READ, &mgmt->schLock);
     QW_ELOG("calloc %d SQWHbInfo failed", schNum);
     taosTmrReset(qwProcessHbTimerEvent, QW_DEFAULT_HEARTBEAT_MSEC, param, mgmt->timer, &mgmt->hbTimer);
+    qwRelease(refId);
     return;
   }
 
@@ -1396,6 +1415,74 @@ _return:
   taosMemoryFreeClear(rspList);
 
   taosTmrReset(qwProcessHbTimerEvent, QW_DEFAULT_HEARTBEAT_MSEC, param, mgmt->timer, &mgmt->hbTimer);
+  qwRelease(refId);  
+}
+
+void qwCloseRef(void) {
+  taosWLockLatch(&gQwMgmt.lock);
+  if (atomic_load_32(&gQwMgmt.qwNum) <= 0 && gQwMgmt.qwRef >= 0) {
+    taosCloseRef(gQwMgmt.qwRef);
+    gQwMgmt.qwRef= -1;
+  }
+  taosWUnLockLatch(&gQwMgmt.lock);
+}
+
+void qwDestroyImpl(void *pMgmt) {
+  SQWorker *mgmt = (SQWorker *)pMgmt;
+
+  taosTmrStopA(&mgmt->hbTimer);
+  taosTmrCleanUp(mgmt->timer);
+
+  // TODO STOP ALL QUERY
+
+  // TODO FREE ALL
+
+  taosHashCleanup(mgmt->ctxHash);
+  taosHashCleanup(mgmt->schHash);
+
+  taosMemoryFree(mgmt);
+
+  atomic_sub_fetch_32(&gQwMgmt.qwNum, 1);  
+
+  qwCloseRef();
+}
+
+int32_t qwOpenRef(void) {
+  taosWLockLatch(&gQwMgmt.lock);
+  if (gQwMgmt.qwRef < 0) {
+    gQwMgmt.qwRef= taosOpenRef(100, qwDestroyImpl);
+    if (gQwMgmt.qwRef < 0) {
+      taosWUnLockLatch(&gQwMgmt.lock);
+      qError("init qworker ref failed");
+      QW_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
+    }
+  }
+  taosWUnLockLatch(&gQwMgmt.lock);
+  
+  return TSDB_CODE_SUCCESS;
+}
+
+void qwSetHbParam(int64_t refId, SQWHbParam **pParam) {
+  int32_t paramIdx = 0;
+  int32_t newParamIdx = 0;
+  
+  while (true) {
+    paramIdx = atomic_load_32(&gQwMgmt.paramIdx);
+    if (paramIdx == tListLen(gQwMgmt.param)) {
+      newParamIdx = 0;
+    } else {
+      newParamIdx = paramIdx + 1;
+    }
+    
+    if (paramIdx == atomic_val_compare_exchange_32(&gQwMgmt.paramIdx, paramIdx, newParamIdx)) {
+      break;
+    }
+  }
+
+  gQwMgmt.param[paramIdx].qwrId = gQwMgmt.qwRef;
+  gQwMgmt.param[paramIdx].refId = refId;
+
+  *pParam = &gQwMgmt.param[paramIdx];
 }
 
 int32_t qWorkerInit(int8_t nodeType, int32_t nodeId, SQWorkerCfg *cfg, void **qWorkerMgmt, const SMsgCb *pMsgCb) {
@@ -1404,10 +1491,21 @@ int32_t qWorkerInit(int8_t nodeType, int32_t nodeId, SQWorkerCfg *cfg, void **qW
     QW_RET(TSDB_CODE_QRY_INVALID_INPUT);
   }
 
-  int32_t       code = 0;
+  int32_t qwNum = atomic_add_fetch_32(&gQwMgmt.qwNum, 1);
-  SQWorkerMgmt *mgmt = taosMemoryCalloc(1, sizeof(SQWorkerMgmt));
+  if (1 == qwNum) {
+    memset(gQwMgmt.param, 0, sizeof(gQwMgmt.param));
+  }
+
+  int32_t code = qwOpenRef();
+  if (code) {
+    atomic_sub_fetch_32(&gQwMgmt.qwNum, 1);
+    QW_RET(code);
+  }
+
+  SQWorker *mgmt = taosMemoryCalloc(1, sizeof(SQWorker));
   if (NULL == mgmt) {
-    qError("calloc %d failed", (int32_t)sizeof(SQWorkerMgmt));
+    qError("calloc %d failed", (int32_t)sizeof(SQWorker));
+    atomic_sub_fetch_32(&gQwMgmt.qwNum, 1);
     QW_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
   }
 
@@ -1449,16 +1547,25 @@ int32_t qWorkerInit(int8_t nodeType, int32_t nodeId, SQWorkerCfg *cfg, void **qW
     QW_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY);
   }
 
-  mgmt->hbTimer = taosTmrStart(qwProcessHbTimerEvent, QW_DEFAULT_HEARTBEAT_MSEC, mgmt, mgmt->timer);
-  if (NULL == mgmt->hbTimer) {
-    qError("start hb timer failed");
-    QW_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY);
-  }
-
   mgmt->nodeType = nodeType;
   mgmt->nodeId = nodeId;
   mgmt->msgCb = *pMsgCb;
 
+  mgmt->refId = taosAddRef(gQwMgmt.qwRef, mgmt);
+  if (mgmt->refId < 0) {
+    qError("taosAddRef qw failed, error:%s", tstrerror(terrno));
+    QW_ERR_JRET(terrno);
+  }
+
+  SQWHbParam *param = NULL;
+  qwSetHbParam(mgmt->refId, &param);
+
+  mgmt->hbTimer = taosTmrStart(qwProcessHbTimerEvent, QW_DEFAULT_HEARTBEAT_MSEC, (void*)param, mgmt->timer);
+  if (NULL == mgmt->hbTimer) {
+    qError("start hb timer failed");
+    QW_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY);
+  }
+  
   *qWorkerMgmt = mgmt;
 
   qDebug("qworker initialized for node, type:%d, id:%d, handle:%p", mgmt->nodeType, mgmt->nodeId, mgmt);
@@ -1467,13 +1574,17 @@ int32_t qWorkerInit(int8_t nodeType, int32_t nodeId, SQWorkerCfg *cfg, void **qW
 
 _return:
 
-  taosHashCleanup(mgmt->schHash);
+  if (mgmt->refId >= 0) {
-  taosHashCleanup(mgmt->ctxHash);
+    qwRelease(mgmt->refId);
-
+  } else {
-  taosTmrCleanUp(mgmt->timer);
+    taosHashCleanup(mgmt->schHash);
-
+    taosHashCleanup(mgmt->ctxHash);
-  taosMemoryFreeClear(mgmt);
+    taosTmrCleanUp(mgmt->timer);
+    taosMemoryFreeClear(mgmt);
 
+    atomic_sub_fetch_32(&gQwMgmt.qwNum, 1);    
+  }
+  
   QW_RET(code);
 }
 
@@ -1482,22 +1593,14 @@ void qWorkerDestroy(void **qWorkerMgmt) {
     return;
   }
 
-  SQWorkerMgmt *mgmt = *qWorkerMgmt;
+  SQWorker *mgmt = *qWorkerMgmt;
 
-  taosTmrStopA(&mgmt->hbTimer);
+  if (taosRemoveRef(gQwMgmt.qwRef, mgmt->refId)) {
-  taosTmrCleanUp(mgmt->timer);
+    qError("remove qw from ref list failed, refId:%" PRIx64, mgmt->refId);
-
+  }
-  // TODO STOP ALL QUERY
-
-  // TODO FREE ALL
-
-  taosHashCleanup(mgmt->ctxHash);
-  taosHashCleanup(mgmt->schHash);
-
-  taosMemoryFreeClear(*qWorkerMgmt);
 }
 
-int32_t qwGetSchTasksStatus(SQWorkerMgmt *mgmt, uint64_t sId, SSchedulerStatusRsp **rsp) {
+int32_t qwGetSchTasksStatus(SQWorker *mgmt, uint64_t sId, SSchedulerStatusRsp **rsp) {
   /*
     SQWSchStatus *sch = NULL;
     int32_t taskNum = 0;
@@ -1544,7 +1647,7 @@ int32_t qwGetSchTasksStatus(SQWorkerMgmt *mgmt, uint64_t sId, SSchedulerStatusRs
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t qwUpdateSchLastAccess(SQWorkerMgmt *mgmt, uint64_t sId, uint64_t qId, uint64_t tId) {
+int32_t qwUpdateSchLastAccess(SQWorker *mgmt, uint64_t sId, uint64_t qId, uint64_t tId) {
   SQWSchStatus *sch = NULL;
 
   /*
@@ -1557,7 +1660,7 @@ int32_t qwUpdateSchLastAccess(SQWorkerMgmt *mgmt, uint64_t sId, uint64_t qId, ui
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t qwGetTaskStatus(SQWorkerMgmt *mgmt, uint64_t sId, uint64_t qId, uint64_t tId, int8_t *taskStatus) {
+int32_t qwGetTaskStatus(SQWorker *mgmt, uint64_t sId, uint64_t qId, uint64_t tId, int8_t *taskStatus) {
   SQWSchStatus * sch = NULL;
   SQWTaskStatus *task = NULL;
   int32_t        code = 0;
@@ -1584,7 +1687,7 @@ int32_t qwGetTaskStatus(SQWorkerMgmt *mgmt, uint64_t sId, uint64_t qId, uint64_t
   QW_RET(code);
 }
 
-int32_t qwCancelTask(SQWorkerMgmt *mgmt, uint64_t sId, uint64_t qId, uint64_t tId) {
+int32_t qwCancelTask(SQWorker *mgmt, uint64_t sId, uint64_t qId, uint64_t tId) {
   SQWSchStatus * sch = NULL;
   SQWTaskStatus *task = NULL;
   int32_t        code = 0;

source/libs/qworker/src/qworkerMsg.c

@@ -320,7 +320,7 @@ int32_t qwRegisterQueryBrokenLinkArg(QW_FPARAMS_DEF, SQWConnInfo *pConn) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t qwRegisterHbBrokenLinkArg(SQWorkerMgmt *mgmt, uint64_t sId, SQWConnInfo *pConn) {
+int32_t qwRegisterHbBrokenLinkArg(SQWorker *mgmt, uint64_t sId, SQWConnInfo *pConn) {
   SSchedulerHbReq req = {0};
   req.header.vgId = mgmt->nodeId;
   req.sId = sId;
@@ -363,7 +363,7 @@ int32_t qWorkerProcessQueryMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg) {
 
   int32_t       code = 0;
   SSubQueryMsg *msg = pMsg->pCont;
-  SQWorkerMgmt *mgmt = (SQWorkerMgmt *)qWorkerMgmt;
+  SQWorker *mgmt = (SQWorker *)qWorkerMgmt;
 
   if (NULL == msg || pMsg->contLen <= sizeof(*msg)) {
     QW_ELOG("invalid query msg, msg:%p, msgLen:%d", msg, pMsg->contLen);
@@ -405,7 +405,7 @@ int32_t qWorkerProcessCQueryMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg) {
   SQueryContinueReq *msg = (SQueryContinueReq *)pMsg->pCont;
   bool               needStop = false;
   SQWTaskCtx        *handles = NULL;
-  SQWorkerMgmt      *mgmt = (SQWorkerMgmt *)qWorkerMgmt;
+  SQWorker      *mgmt = (SQWorker *)qWorkerMgmt;
 
   if (NULL == msg || pMsg->contLen < sizeof(*msg)) {
     QW_ELOG("invalid cquery msg, msg:%p, msgLen:%d", msg, pMsg->contLen);
@@ -436,7 +436,7 @@ int32_t qWorkerProcessReadyMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg) {
     return TSDB_CODE_QRY_INVALID_INPUT;
   }
 
-  SQWorkerMgmt *mgmt = (SQWorkerMgmt *)qWorkerMgmt;
+  SQWorker *mgmt = (SQWorker *)qWorkerMgmt;
   SResReadyReq *msg = pMsg->pCont;
   if (NULL == msg || pMsg->contLen < sizeof(*msg)) {
     QW_ELOG("invalid task ready msg, msg:%p, msgLen:%d", msg, pMsg->contLen);
@@ -478,7 +478,7 @@ int32_t qWorkerProcessStatusMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg) {
     QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
   }
 
-  SQWorkerMgmt *mgmt = (SQWorkerMgmt *)qWorkerMgmt;
+  SQWorker *mgmt = (SQWorker *)qWorkerMgmt;
   msg->sId = htobe64(msg->sId);
   uint64_t sId = msg->sId;
 
@@ -499,7 +499,7 @@ int32_t qWorkerProcessFetchMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg) {
   }
 
   SResFetchReq *msg = pMsg->pCont;
-  SQWorkerMgmt *mgmt = (SQWorkerMgmt *)qWorkerMgmt;
+  SQWorker *mgmt = (SQWorker *)qWorkerMgmt;
 
   if (NULL == msg || pMsg->contLen < sizeof(*msg)) {
     QW_ELOG("invalid fetch msg, msg:%p, msgLen:%d", msg, pMsg->contLen);
@@ -539,7 +539,7 @@ int32_t qWorkerProcessCancelMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg) {
     return TSDB_CODE_QRY_INVALID_INPUT;
   }
 
-  SQWorkerMgmt   *mgmt = (SQWorkerMgmt *)qWorkerMgmt;
+  SQWorker   *mgmt = (SQWorker *)qWorkerMgmt;
   int32_t         code = 0;
   STaskCancelReq *msg = pMsg->pCont;
   if (NULL == msg || pMsg->contLen < sizeof(*msg)) {
@@ -579,7 +579,7 @@ int32_t qWorkerProcessDropMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg) {
 
   int32_t       code = 0;
   STaskDropReq *msg = pMsg->pCont;
-  SQWorkerMgmt *mgmt = (SQWorkerMgmt *)qWorkerMgmt;
+  SQWorker *mgmt = (SQWorker *)qWorkerMgmt;
 
   if (NULL == msg || pMsg->contLen < sizeof(*msg)) {
     QW_ELOG("invalid task drop msg, msg:%p, msgLen:%d", msg, pMsg->contLen);
@@ -621,7 +621,7 @@ int32_t qWorkerProcessHbMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg) {
 
   int32_t         code = 0;
   SSchedulerHbReq req = {0};
-  SQWorkerMgmt   *mgmt = (SQWorkerMgmt *)qWorkerMgmt;
+  SQWorker   *mgmt = (SQWorker *)qWorkerMgmt;
 
   if (NULL == pMsg->pCont) {
     QW_ELOG("invalid hb msg, msg:%p, msgLen:%d", pMsg->pCont, pMsg->contLen);

source/libs/scalar/src/filter.c

@@ -3765,6 +3765,7 @@ int32_t filterInitFromNode(SNode* pNode, SFilterInfo **pInfo, uint32_t options)
   FLT_ERR_JRET(fltReviseNodes(info, &pNode, &stat));
 
   info->scalarMode = stat.scalarMode;
+  fltDebug("scalar mode: %d", info->scalarMode);
 
   if (!info->scalarMode) {
     FLT_ERR_JRET(fltInitFromNode(pNode, info, options));

source/libs/scalar/src/scalar.c

@@ -75,7 +75,15 @@ int32_t scalarGenerateSetFromList(void **data, void *pNode, uint32_t type) {
     
     if (valueNode->node.resType.type != type) {
       out.columnData->info.type = type;
-      out.columnData->info.bytes = tDataTypes[type].bytes;
+      if (IS_VAR_DATA_TYPE(type)) {
+        if (IS_VAR_DATA_TYPE(valueNode->node.resType.type)) {
+          out.columnData->info.bytes = valueNode->node.resType.bytes * TSDB_NCHAR_SIZE;
+        } else {
+          out.columnData->info.bytes = 64 * TSDB_NCHAR_SIZE;
+        }
+      } else {
+        out.columnData->info.bytes = tDataTypes[type].bytes;
+      }
 
       code = doConvertDataType(valueNode, &out);
       if (code != TSDB_CODE_SUCCESS) {
@@ -598,7 +606,7 @@ EDealRes sclRewriteFunction(SNode** pNode, SScalarCtx *ctx) {
       res->datum.p = taosMemoryCalloc(res->node.resType.bytes + VARSTR_HEADER_SIZE + 1, 1);
       memcpy(res->datum.p, output.columnData->pData, varDataTLen(output.columnData->pData));
     } else {
-      memcpy(nodesGetValueFromNode(res), output.columnData->pData, tDataTypes[type].bytes);
+      nodesSetValueNodeValue(res, output.columnData->pData);
     }
   }
 
@@ -638,7 +646,7 @@ EDealRes sclRewriteLogic(SNode** pNode, SScalarCtx *ctx) {
     res->datum.p = output.columnData->pData;
     output.columnData->pData = NULL;
   } else {
-    memcpy(nodesGetValueFromNode(res), output.columnData->pData, tDataTypes[type].bytes);
+    nodesSetValueNodeValue(res, output.columnData->pData);
   }
 
   nodesDestroyNode(*pNode);
@@ -680,7 +688,7 @@ EDealRes sclRewriteOperator(SNode** pNode, SScalarCtx *ctx) {
       res->datum.p = output.columnData->pData;
       output.columnData->pData = NULL;
     } else {
-      memcpy(nodesGetValueFromNode(res), output.columnData->pData, tDataTypes[type].bytes);
+      nodesSetValueNodeValue(res, output.columnData->pData);    
     }
   }
 

source/libs/scheduler/inc/schedulerInt.h

@@ -85,7 +85,10 @@ typedef struct SSchedulerMgmt {
   uint64_t        taskId; // sequential taksId
   uint64_t        sId;    // schedulerId
   SSchedulerCfg   cfg;
+  SRWLatch        lock;
+  bool            exit;
   int32_t         jobRef;
+  int32_t         jobNum;
   SSchedulerStat  stat;
   SHashObj       *hbConnections;
 } SSchedulerMgmt;

source/libs/scheduler/src/scheduler.c

@@ -21,7 +21,9 @@
 #include "tref.h"
 #include "trpc.h"
 
-SSchedulerMgmt schMgmt = {0};
+SSchedulerMgmt schMgmt = {
+  .jobRef = -1,
+};
 
 FORCE_INLINE SSchJob *schAcquireJob(int64_t refId) { return (SSchJob *)taosAcquireRef(schMgmt.jobRef, refId); }
 
@@ -70,6 +72,7 @@ int32_t schInitTask(SSchJob *pJob, SSchTask *pTask, SSubplan *pPlan, SSchLevel *
 int32_t schInitJob(SSchJob **pSchJob, SQueryPlan *pDag, void *transport, SArray *pNodeList, const char *sql,
                    int64_t startTs, bool syncSchedule) {
   int32_t  code = 0;
+  int64_t refId = -1;
   SSchJob *pJob = taosMemoryCalloc(1, sizeof(SSchJob));
   if (NULL == pJob) {
     qError("QID:%" PRIx64 " calloc %d failed", pDag->queryId, (int32_t)sizeof(SSchJob));
@@ -114,15 +117,17 @@ int32_t schInitJob(SSchJob **pSchJob, SQueryPlan *pDag, void *transport, SArray
 
   tsem_init(&pJob->rspSem, 0, 0);
 
-  int64_t refId = taosAddRef(schMgmt.jobRef, pJob);
+  refId = taosAddRef(schMgmt.jobRef, pJob);
   if (refId < 0) {
     SCH_JOB_ELOG("taosAddRef job failed, error:%s", tstrerror(terrno));
     SCH_ERR_JRET(terrno);
   }
 
+  atomic_add_fetch_32(&schMgmt.jobNum, 1);
+  
   if (NULL == schAcquireJob(refId)) {
     SCH_JOB_ELOG("schAcquireJob job failed, refId:%" PRIx64, refId);
-    SCH_RET(TSDB_CODE_SCH_STATUS_ERROR);
+    SCH_ERR_JRET(TSDB_CODE_SCH_STATUS_ERROR);
   }
 
   pJob->refId = refId;
@@ -137,7 +142,11 @@ int32_t schInitJob(SSchJob **pSchJob, SQueryPlan *pDag, void *transport, SArray
 
 _return:
 
-  schFreeJobImpl(pJob);
+  if (refId < 0) {
+    schFreeJobImpl(pJob);
+  } else {
+    taosRemoveRef(schMgmt.jobRef, refId);
+  }
   SCH_RET(code);
 }
 
@@ -245,6 +254,7 @@ int32_t schValidateTaskReceivedMsgType(SSchJob *pJob, SSchTask *pTask, int32_t m
       SCH_SET_TASK_LASTMSG_TYPE(pTask, -1);
       return TSDB_CODE_SUCCESS;
     case TDMT_VND_CREATE_TABLE_RSP:
+    case TDMT_VND_DROP_TABLE_RSP:
     case TDMT_VND_SUBMIT_RSP:
       break;
     default:
@@ -369,7 +379,7 @@ int32_t schBuildTaskRalation(SSchJob *pJob, SHashObj *planToTask) {
       }
 
       for (int32_t n = 0; n < childNum; ++n) {
-        SSubplan * child = (SSubplan *)nodesListGetNode(pPlan->pChildren, n);
+        SSubplan  *child = (SSubplan *)nodesListGetNode(pPlan->pChildren, n);
         SSchTask **childTask = taosHashGet(planToTask, &child, POINTER_BYTES);
         if (NULL == childTask || NULL == *childTask) {
           SCH_TASK_ELOG("subplan children relationship error, level:%d, taskIdx:%d, childIdx:%d", i, m, n);
@@ -401,7 +411,7 @@ int32_t schBuildTaskRalation(SSchJob *pJob, SHashObj *planToTask) {
       }
 
       for (int32_t n = 0; n < parentNum; ++n) {
-        SSubplan * parent = (SSubplan *)nodesListGetNode(pPlan->pParents, n);
+        SSubplan  *parent = (SSubplan *)nodesListGetNode(pPlan->pParents, n);
         SSchTask **parentTask = taosHashGet(planToTask, &parent, POINTER_BYTES);
         if (NULL == parentTask || NULL == *parentTask) {
           SCH_TASK_ELOG("subplan parent relationship error, level:%d, taskIdx:%d, childIdx:%d", i, m, n);
@@ -491,7 +501,7 @@ int32_t schValidateAndBuildJob(SQueryPlan *pDag, SSchJob *pJob) {
   SSchLevel      level = {0};
   SNodeListNode *plans = NULL;
   int32_t        taskNum = 0;
-  SSchLevel *    pLevel = NULL;
+  SSchLevel     *pLevel = NULL;
 
   level.status = JOB_TASK_STATUS_NOT_START;
 
@@ -1094,6 +1104,30 @@ int32_t schHandleResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t msgType, ch
       SCH_ERR_RET(schProcessOnTaskSuccess(pJob, pTask));
       break;
     }
+    case TDMT_VND_DROP_TABLE_RSP: {
+      SVDropTbBatchRsp batchRsp = {0};
+      if (msg) {
+        SCoder coder = {0};
+        tCoderInit(&coder, TD_LITTLE_ENDIAN, msg, msgSize, TD_DECODER);
+        code = tDecodeSVDropTbBatchRsp(&coder, &batchRsp);
+        if (TSDB_CODE_SUCCESS == code && batchRsp.pArray) {
+          int32_t num = taosArrayGetSize(batchRsp.pArray);
+          for (int32_t i = 0; i < num; ++i) {
+            SVDropTbRsp *rsp = taosArrayGet(batchRsp.pArray, i);
+            if (NEED_CLIENT_HANDLE_ERROR(rsp->code)) {
+              tCoderClear(&coder);
+              SCH_ERR_JRET(rsp->code);
+            }
+          }
+        }
+        tCoderClear(&coder);
+        SCH_ERR_JRET(code);
+      }
+
+      SCH_ERR_JRET(rspCode);
+      SCH_ERR_RET(schProcessOnTaskSuccess(pJob, pTask));
+      break;
+    }
     case TDMT_VND_SUBMIT_RSP: {
       if (msg) {
         SSubmitRsp *rsp = (SSubmitRsp *)msg;
@@ -1267,7 +1301,7 @@ int32_t schUpdateTaskExecNodeHandle(SSchTask *pTask, void *handle, int32_t rspCo
 int32_t schHandleCallback(void *param, const SDataBuf *pMsg, int32_t msgType, int32_t rspCode) {
   int32_t                code = 0;
   SSchTaskCallbackParam *pParam = (SSchTaskCallbackParam *)param;
-  SSchTask *             pTask = NULL;
+  SSchTask              *pTask = NULL;
 
   SSchJob *pJob = schAcquireJob(pParam->refId);
   if (NULL == pJob) {
@@ -1316,6 +1350,10 @@ int32_t schHandleCreateTableCallback(void *param, const SDataBuf *pMsg, int32_t
   return schHandleCallback(param, pMsg, TDMT_VND_CREATE_TABLE_RSP, code);
 }
 
+int32_t schHandleDropTableCallback(void *param, const SDataBuf *pMsg, int32_t code) {
+  return schHandleCallback(param, pMsg, TDMT_VND_DROP_TABLE_RSP, code);
+}
+
 int32_t schHandleQueryCallback(void *param, const SDataBuf *pMsg, int32_t code) {
   return schHandleCallback(param, pMsg, TDMT_VND_QUERY_RSP, code);
 }
@@ -1412,6 +1450,9 @@ int32_t schGetCallbackFp(int32_t msgType, __async_send_cb_fn_t *fp) {
     case TDMT_VND_CREATE_TABLE:
       *fp = schHandleCreateTableCallback;
       break;
+    case TDMT_VND_DROP_TABLE:
+      *fp = schHandleDropTableCallback;
+      break;
     case TDMT_VND_SUBMIT:
       *fp = schHandleSubmitCallback;
       break;
@@ -1617,8 +1658,8 @@ _return:
 int32_t schMakeHbRpcCtx(SSchJob *pJob, SSchTask *pTask, SRpcCtx *pCtx) {
   int32_t              code = 0;
   SSchHbCallbackParam *param = NULL;
-  SMsgSendInfo *       pMsgSendInfo = NULL;
+  SMsgSendInfo        *pMsgSendInfo = NULL;
-  SQueryNodeAddr *     addr = taosArrayGet(pTask->candidateAddrs, pTask->candidateIdx);
+  SQueryNodeAddr      *addr = taosArrayGet(pTask->candidateAddrs, pTask->candidateIdx);
   SQueryNodeEpId       epId = {0};
 
   epId.nodeId = addr->nodeId;
@@ -1759,10 +1800,10 @@ int32_t schCloneHbRpcCtx(SRpcCtx *pSrc, SRpcCtx *pDst) {
   }
 
   SRpcCtxVal dst = {0};
-  void *     pIter = taosHashIterate(pSrc->args, NULL);
+  void      *pIter = taosHashIterate(pSrc->args, NULL);
   while (pIter) {
     SRpcCtxVal *pVal = (SRpcCtxVal *)pIter;
-    int32_t *   msgType = taosHashGetKey(pIter, NULL);
+    int32_t    *msgType = taosHashGetKey(pIter, NULL);
 
     dst = *pVal;
     dst.val = NULL;
@@ -1916,7 +1957,7 @@ _return:
 
 int32_t schBuildAndSendMsg(SSchJob *pJob, SSchTask *pTask, SQueryNodeAddr *addr, int32_t msgType) {
   uint32_t msgSize = 0;
-  void *   msg = NULL;
+  void    *msg = NULL;
   int32_t  code = 0;
   bool     isCandidateAddr = false;
   bool     persistHandle = false;
@@ -1931,6 +1972,7 @@ int32_t schBuildAndSendMsg(SSchJob *pJob, SSchTask *pTask, SQueryNodeAddr *addr,
 
   switch (msgType) {
     case TDMT_VND_CREATE_TABLE:
+    case TDMT_VND_DROP_TABLE:
     case TDMT_VND_SUBMIT: {
       msgSize = pTask->msgLen;
       msg = taosMemoryCalloc(1, msgSize);
@@ -2239,6 +2281,19 @@ int32_t schCancelJob(SSchJob *pJob) {
   // TODO MOVE ALL TASKS FROM EXEC LIST TO FAIL LIST
 }
 
+void schCloseJobRef(void) {
+  if (!atomic_load_8((int8_t*)&schMgmt.exit)) {
+    return;
+  }
+  
+  SCH_LOCK(SCH_WRITE, &schMgmt.lock);
+  if (atomic_load_32(&schMgmt.jobNum) <= 0 && schMgmt.jobRef >= 0) {
+    taosCloseRef(schMgmt.jobRef);
+    schMgmt.jobRef = -1;
+  }
+  SCH_UNLOCK(SCH_WRITE, &schMgmt.lock);
+}
+
 void schFreeJobImpl(void *job) {
   if (NULL == job) {
     return;
@@ -2284,6 +2339,10 @@ void schFreeJobImpl(void *job) {
   taosMemoryFreeClear(pJob);
 
   qDebug("QID:0x%" PRIx64 " job freed, refId:%" PRIx64 ", pointer:%p", queryId, refId, pJob);
+
+  atomic_sub_fetch_32(&schMgmt.jobNum, 1);
+
+  schCloseJobRef();
 }
 
 static int32_t schExecJobImpl(void *transport, SArray *pNodeList, SQueryPlan *pDag, int64_t *job, const char *sql,
@@ -2368,7 +2427,7 @@ _return:
 }
 
 int32_t schedulerInit(SSchedulerCfg *cfg) {
-  if (schMgmt.jobRef) {
+  if (schMgmt.jobRef >= 0) {
     qError("scheduler already initialized");
     return TSDB_CODE_QRY_INVALID_INPUT;
   }
@@ -2673,7 +2732,7 @@ int32_t schedulerGetTasksStatus(int64_t job, SArray *pSub) {
     SSchLevel *pLevel = taosArrayGet(pJob->levels, i);
 
     for (int32_t m = 0; m < pLevel->taskNum; ++m) {
-      SSchTask *    pTask = taosArrayGet(pLevel->subTasks, m);
+      SSchTask     *pTask = taosArrayGet(pLevel->subTasks, m);
       SQuerySubDesc subDesc = {.tid = pTask->taskId, .status = pTask->status};
 
       taosArrayPush(pSub, &subDesc);
@@ -2732,7 +2791,9 @@ void schedulerFreeTaskList(SArray *taskList) {
 }
 
 void schedulerDestroy(void) {
-  if (schMgmt.jobRef) {
+  atomic_store_8((int8_t*)&schMgmt.exit, 1);
+  
+  if (schMgmt.jobRef >= 0) {
     SSchJob *pJob = taosIterateRef(schMgmt.jobRef, 0);
     int64_t  refId = 0;
 
@@ -2745,9 +2806,6 @@ void schedulerDestroy(void) {
 
       pJob = taosIterateRef(schMgmt.jobRef, refId);
     }
-
-    taosCloseRef(schMgmt.jobRef);
-    schMgmt.jobRef = 0;
   }
 
   if (schMgmt.hbConnections) {

source/libs/tdb/inc/tdb.h

@@ -22,6 +22,65 @@
 extern "C" {
 #endif
 
+typedef int (*tdb_cmpr_fn_t)(const void *pKey1, int kLen1, const void *pKey2, int kLen2);
+
+// exposed types
+typedef struct STEnv TENV;
+typedef struct STDB  TDB;
+typedef struct STDBC TDBC;
+typedef struct STxn  TXN;
+
+// TENV
+int tdbEnvOpen(const char *rootDir, int szPage, int pages, TENV **ppEnv);
+int tdbEnvClose(TENV *pEnv);
+int tdbBegin(TENV *pEnv, TXN *pTxn);
+int tdbCommit(TENV *pEnv, TXN *pTxn);
+
+// TDB
+int tdbDbOpen(const char *fname, int keyLen, int valLen, tdb_cmpr_fn_t keyCmprFn, TENV *pEnv, TDB **ppDb);
+int tdbDbClose(TDB *pDb);
+int tdbDbDrop(TDB *pDb);
+int tdbDbPut(TDB *pDb, const void *pKey, int keyLen, const void *pVal, int valLen, TXN *pTxn);
+int tdbDbGet(TDB *pDb, const void *pKey, int kLen, void **ppVal, int *vLen);
+int tdbDbPGet(TDB *pDb, const void *pKey, int kLen, void **ppKey, int *pkLen, void **ppVal, int *vLen);
+
+// TDBC
+int tdbDbcOpen(TDB *pDb, TDBC **ppDbc, TXN *pTxn);
+int tdbDbcClose(TDBC *pDbc);
+int tdbDbcMoveTo(TDBC *pDbc, const void *pKey, int kLen, int *c);
+int tdbDbcMoveToFirst(TDBC *pDbc);
+int tdbDbcMoveToLast(TDBC *pDbc);
+int tdbDbcMoveToNext(TDBC *pDbc);
+int tdbDbcMoveToPrev(TDBC *pDbc);
+int tdbDbcGet(TDBC *pDbc, const void **ppKey, int *pkLen, const void **ppVal, int *pvLen);
+
+int tdbDbcPut(TDBC *pDbc, const void *pKey, int keyLen, const void *pVal, int valLen);
+int tdbDbcUpdate(TDBC *pDbc, const void *pKey, int kLen, const void *pVal, int vLen);
+int tdbDbcDrop(TDBC *pDbc);
+int tdbDbcNext(TDBC *pDbc, void **ppKey, int *kLen, void **ppVal, int *vLen);
+
+// TXN
+#define TDB_TXN_WRITE            0x1
+#define TDB_TXN_READ_UNCOMMITTED 0x2
+
+int tdbTxnOpen(TXN *pTxn, int64_t txnid, void *(*xMalloc)(void *, size_t), void (*xFree)(void *, void *), void *xArg,
+               int flags);
+int tdbTxnClose(TXN *pTxn);
+
+// other
+void tdbFree(void *);
+
+struct STxn {
+  int     flags;
+  int64_t txnId;
+  void *(*xMalloc)(void *, size_t);
+  void (*xFree)(void *, void *);
+  void *xArg;
+};
+
+// error code
+enum { TDB_CODE_SUCCESS = 0, TDB_CODE_MAX };
+
 #ifdef __cplusplus
 }
 #endif

source/libs/tdb/src/db/tdbBtree.c

@@ -19,17 +19,17 @@
 #define TDB_BTREE_LEAF 0x2
 
 struct SBTree {
-  SPgno          root;
+  SPgno         root;
-  int            keyLen;
+  int           keyLen;
-  int            valLen;
+  int           valLen;
-  SPager        *pPager;
+  SPager       *pPager;
-  FKeyComparator kcmpr;
+  tdb_cmpr_fn_t kcmpr;
-  int            pageSize;
+  int           pageSize;
-  int            maxLocal;
+  int           maxLocal;
-  int            minLocal;
+  int           minLocal;
-  int            maxLeaf;
+  int           maxLeaf;
-  int            minLeaf;
+  int           minLeaf;
-  void          *pBuf;
+  void         *pBuf;
 };
 
 #define TDB_BTREE_PAGE_COMMON_HDR u8 flags;
@@ -58,16 +58,6 @@ typedef struct {
   SBTree *pBt;
 } SBtreeInitPageArg;
 
-typedef struct {
-  int       kLen;
-  const u8 *pKey;
-  int       vLen;
-  const u8 *pVal;
-  SPgno     pgno;
-  u8       *pBuf;
-} SCellDecoder;
-
-static int tdbBtcMoveTo(SBTC *pBtc, const void *pKey, int kLen, int *pCRst);
 static int tdbDefaultKeyCmprFn(const void *pKey1, int keyLen1, const void *pKey2, int keyLen2);
 static int tdbBtreeOpenImpl(SBTree *pBt);
 static int tdbBtreeInitPage(SPage *pPage, void *arg, int init);
@@ -76,11 +66,10 @@ static int tdbBtreeEncodeCell(SPage *pPage, const void *pKey, int kLen, const vo
 static int tdbBtreeDecodeCell(SPage *pPage, const SCell *pCell, SCellDecoder *pDecoder);
 static int tdbBtreeBalance(SBTC *pBtc);
 static int tdbBtreeCellSize(const SPage *pPage, SCell *pCell);
-static int tdbBtcMoveToNext(SBTC *pBtc);
 static int tdbBtcMoveDownward(SBTC *pBtc);
 static int tdbBtcMoveUpward(SBTC *pBtc);
 
-int tdbBtreeOpen(int keyLen, int valLen, SPager *pPager, FKeyComparator kcmpr, SBTree **ppBt) {
+int tdbBtreeOpen(int keyLen, int valLen, SPager *pPager, tdb_cmpr_fn_t kcmpr, SBTree **ppBt) {
   SBTree *pBt;
   int     ret;
 
@@ -165,7 +154,7 @@ int tdbBtreeInsert(SBTree *pBt, const void *pKey, int kLen, const void *pVal, in
 
   // make sure enough space to hold the cell
   szBuf = kLen + vLen + 14;
-  pBuf = TDB_REALLOC(pBt->pBuf, pBt->pageSize > szBuf ? szBuf : pBt->pageSize);
+  pBuf = tdbRealloc(pBt->pBuf, pBt->pageSize > szBuf ? szBuf : pBt->pageSize);
   if (pBuf == NULL) {
     tdbBtcClose(&btc);
     ASSERT(0);
@@ -243,7 +232,7 @@ int tdbBtreePGet(SBTree *pBt, const void *pKey, int kLen, void **ppKey, int *pkL
   tdbBtreeDecodeCell(btc.pPage, pCell, &cd);
 
   if (ppKey) {
-    pTKey = TDB_REALLOC(*ppKey, cd.kLen);
+    pTKey = tdbRealloc(*ppKey, cd.kLen);
     if (pTKey == NULL) {
       tdbBtcClose(&btc);
       ASSERT(0);
@@ -255,7 +244,7 @@ int tdbBtreePGet(SBTree *pBt, const void *pKey, int kLen, void **ppKey, int *pkL
   }
 
   if (ppVal) {
-    pTVal = TDB_REALLOC(*ppVal, cd.vLen);
+    pTVal = tdbRealloc(*ppVal, cd.vLen);
     if (pTVal == NULL) {
       tdbBtcClose(&btc);
       ASSERT(0);
@@ -1018,6 +1007,7 @@ int tdbBtcOpen(SBTC *pBtc, SBTree *pBt, TXN *pTxn) {
   pBtc->iPage = -1;
   pBtc->pPage = NULL;
   pBtc->idx = -1;
+  memset(&pBtc->coder, 0, sizeof(SCellDecoder));
 
   if (pTxn == NULL) {
     pBtc->pTxn = &pBtc->txn;
@@ -1060,6 +1050,8 @@ int tdbBtcMoveToFirst(SBTC *pBtc) {
       return 0;
     }
   } else {
+    ASSERT(0);
+#if 0
     // move from a position
     int iPage = 0;
 
@@ -1077,6 +1069,7 @@ int tdbBtcMoveToFirst(SBTC *pBtc) {
 
       tdbBtcMoveUpward(pBtc);
     }
+#endif
   }
 
   // move downward
@@ -1125,6 +1118,8 @@ int tdbBtcMoveToLast(SBTC *pBtc) {
       return 0;
     }
   } else {
+    ASSERT(0);
+#if 0
     int iPage = 0;
 
     // downward search
@@ -1147,6 +1142,7 @@ int tdbBtcMoveToLast(SBTC *pBtc) {
 
       tdbBtcMoveUpward(pBtc);
     }
+#endif
   }
 
   // move downward
@@ -1185,7 +1181,7 @@ int tdbBtreeNext(SBTC *pBtc, void **ppKey, int *kLen, void **ppVal, int *vLen) {
 
   tdbBtreeDecodeCell(pBtc->pPage, pCell, &cd);
 
-  pKey = TDB_REALLOC(*ppKey, cd.kLen);
+  pKey = tdbRealloc(*ppKey, cd.kLen);
   if (pKey == NULL) {
     return -1;
   }
@@ -1196,9 +1192,9 @@ int tdbBtreeNext(SBTC *pBtc, void **ppKey, int *kLen, void **ppVal, int *vLen) {
 
   if (ppVal) {
     // TODO: vLen may be zero
-    pVal = TDB_REALLOC(*ppVal, cd.vLen);
+    pVal = tdbRealloc(*ppVal, cd.vLen);
     if (pVal == NULL) {
-      TDB_FREE(pKey);
+      tdbFree(pKey);
       return -1;
     }
 
@@ -1216,7 +1212,7 @@ int tdbBtreeNext(SBTC *pBtc, void **ppKey, int *kLen, void **ppVal, int *vLen) {
   return 0;
 }
 
-static int tdbBtcMoveToNext(SBTC *pBtc) {
+int tdbBtcMoveToNext(SBTC *pBtc) {
   int    nCells;
   int    ret;
   SCell *pCell;
@@ -1262,6 +1258,43 @@ static int tdbBtcMoveToNext(SBTC *pBtc) {
   return 0;
 }
 
+int tdbBtcMoveToPrev(SBTC *pBtc) {
+  if (pBtc->idx < 0) return -1;
+
+  pBtc->idx--;
+  if (pBtc->idx >= 0) {
+    return 0;
+  }
+
+  // move upward
+  for (;;) {
+    if (pBtc->iPage == 0) {
+      pBtc->idx = -1;
+      return 0;
+    }
+
+    tdbBtcMoveUpward(pBtc);
+    pBtc->idx--;
+    if (pBtc->idx >= 0) {
+      break;
+    }
+  }
+
+  // move downward
+  for (;;) {
+    if (TDB_BTREE_PAGE_IS_LEAF(pBtc->pPage)) break;
+
+    tdbBtcMoveDownward(pBtc);
+    if (TDB_BTREE_PAGE_IS_LEAF(pBtc->pPage)) {
+      pBtc->idx = TDB_PAGE_TOTAL_CELLS(pBtc->pPage) - 1;
+    } else {
+      pBtc->idx = TDB_PAGE_TOTAL_CELLS(pBtc->pPage);
+    }
+  }
+
+  return 0;
+}
+
 static int tdbBtcMoveDownward(SBTC *pBtc) {
   int    ret;
   SPgno  pgno;
@@ -1307,17 +1340,38 @@ static int tdbBtcMoveUpward(SBTC *pBtc) {
   return 0;
 }
 
-static int tdbBtcMoveTo(SBTC *pBtc, const void *pKey, int kLen, int *pCRst) {
+int tdbBtcGet(SBTC *pBtc, const void **ppKey, int *kLen, const void **ppVal, int *vLen) {
-  int          ret;
+  SCell *pCell;
-  int          nCells;
-  int          c;
-  SBTree      *pBt;
-  SCell       *pCell;
-  SPager      *pPager;
-  SCellDecoder cd = {0};
 
-  pBt = pBtc->pBt;
+  if (pBtc->idx < 0 || pBtc->idx >= TDB_PAGE_TOTAL_CELLS(pBtc->pPage)) {
-  pPager = pBt->pPager;
+    return -1;
+  }
+
+  pCell = tdbPageGetCell(pBtc->pPage, pBtc->idx);
+  tdbBtreeDecodeCell(pBtc->pPage, pCell, &pBtc->coder);
+
+  if (ppKey) {
+    *ppKey = (void *)pBtc->coder.pKey;
+    *kLen = pBtc->coder.kLen;
+  }
+
+  if (ppVal) {
+    *ppVal = (void *)pBtc->coder.pVal;
+    *kLen = pBtc->coder.vLen;
+  }
+
+  return 0;
+}
+
+int tdbBtcMoveTo(SBTC *pBtc, const void *pKey, int kLen, int *pCRst) {
+  int         ret;
+  int         nCells;
+  int         c;
+  SCell      *pCell;
+  SBTree     *pBt = pBtc->pBt;
+  SPager     *pPager = pBt->pPager;
+  const void *pTKey;
+  int         tkLen;
 
   if (pBtc->iPage < 0) {
     // move from a clear cursor
@@ -1334,6 +1388,8 @@ static int tdbBtcMoveTo(SBTC *pBtc, const void *pKey, int kLen, int *pCRst) {
     // for empty tree, just return with an invalid position
     if (TDB_PAGE_TOTAL_CELLS(pBtc->pPage) == 0) return 0;
   } else {
+    ASSERT(0);
+#if 0
     SPage *pPage;
     int    idx;
     int    iPage = 0;
@@ -1368,11 +1424,12 @@ static int tdbBtcMoveTo(SBTC *pBtc, const void *pKey, int kLen, int *pCRst) {
       if (pBtc->iPage == iPage) break;
       tdbBtcMoveUpward(pBtc);
     }
+#endif
   }
 
   // search downward to the leaf
   for (;;) {
-    int    lidx, ridx, midx;
+    int    lidx, ridx;
     SPage *pPage;
 
     pPage = pBtc->pPage;
@@ -1381,13 +1438,11 @@ static int tdbBtcMoveTo(SBTC *pBtc, const void *pKey, int kLen, int *pCRst) {
     ridx = nCells - 1;
 
     ASSERT(nCells > 0);
-    ASSERT(pBtc->idx == -1);
 
     // compare first cell
-    midx = lidx;
+    pBtc->idx = lidx;
-    pCell = tdbPageGetCell(pPage, midx);
+    tdbBtcGet(pBtc, &pTKey, &tkLen, NULL, NULL);
-    tdbBtreeDecodeCell(pPage, pCell, &cd);
+    c = pBt->kcmpr(pKey, kLen, pTKey, tkLen);
-    c = pBt->kcmpr(pKey, kLen, cd.pKey, cd.kLen);
     if (c <= 0) {
       ridx = lidx - 1;
     } else {
@@ -1396,10 +1451,9 @@ static int tdbBtcMoveTo(SBTC *pBtc, const void *pKey, int kLen, int *pCRst) {
 
     // compare last cell
     if (lidx <= ridx) {
-      midx = ridx;
+      pBtc->idx = ridx;
-      pCell = tdbPageGetCell(pPage, midx);
+      tdbBtcGet(pBtc, &pTKey, &tkLen, NULL, NULL);
-      tdbBtreeDecodeCell(pPage, pCell, &cd);
+      c = pBt->kcmpr(pKey, kLen, pTKey, tkLen);
-      c = pBt->kcmpr(pKey, kLen, cd.pKey, cd.kLen);
       if (c >= 0) {
         lidx = ridx + 1;
       } else {
@@ -1411,24 +1465,15 @@ static int tdbBtcMoveTo(SBTC *pBtc, const void *pKey, int kLen, int *pCRst) {
     for (;;) {
       if (lidx > ridx) break;
 
-      midx = (lidx + ridx) >> 1;
+      pBtc->idx = (lidx + ridx) >> 1;
-
+      tdbBtcGet(pBtc, &pTKey, &tkLen, NULL, NULL);
-      pCell = tdbPageGetCell(pPage, midx);
+      c = pBt->kcmpr(pKey, kLen, pTKey, tkLen);
-      ret = tdbBtreeDecodeCell(pPage, pCell, &cd);
-      if (ret < 0) {
-        // TODO: handle error
-        ASSERT(0);
-        return -1;
-      }
-
-      // Compare the key values
-      c = pBt->kcmpr(pKey, kLen, cd.pKey, cd.kLen);
       if (c < 0) {
         // pKey < cd.pKey
-        ridx = midx - 1;
+        ridx = pBtc->idx - 1;
       } else if (c > 0) {
         // pKey > cd.pKey
-        lidx = midx + 1;
+        lidx = pBtc->idx + 1;
       } else {
         // pKey == cd.pKey
         break;
@@ -1437,14 +1482,11 @@ static int tdbBtcMoveTo(SBTC *pBtc, const void *pKey, int kLen, int *pCRst) {
 
     // keep search downward or break
     if (TDB_BTREE_PAGE_IS_LEAF(pPage)) {
-      pBtc->idx = midx;
       *pCRst = c;
       break;
     } else {
-      if (c <= 0) {
+      if (c > 0) {
-        pBtc->idx = midx;
+        pBtc->idx += 1;
-      } else {
-        pBtc->idx = midx + 1;
       }
       tdbBtcMoveDownward(pBtc);
     }

source/libs/tdb/src/db/tdbDb.c

@@ -24,7 +24,7 @@ struct STDBC {
   SBTC btc;
 };
 
-int tdbDbOpen(const char *fname, int keyLen, int valLen, FKeyComparator keyCmprFn, TENV *pEnv, TDB **ppDb) {
+int tdbDbOpen(const char *fname, int keyLen, int valLen, tdb_cmpr_fn_t keyCmprFn, TENV *pEnv, TDB **ppDb) {
   TDB    *pDb;
   SPager *pPager;
   int     ret;
@@ -75,7 +75,7 @@ int tdbDbDrop(TDB *pDb) {
   return 0;
 }
 
-int tdbDbInsert(TDB *pDb, const void *pKey, int keyLen, const void *pVal, int valLen, TXN *pTxn) {
+int tdbDbPut(TDB *pDb, const void *pKey, int keyLen, const void *pVal, int valLen, TXN *pTxn) {
   return tdbBtreeInsert(pDb->pBt, pKey, keyLen, pVal, valLen, pTxn);
 }
 
@@ -87,7 +87,7 @@ int tdbDbPGet(TDB *pDb, const void *pKey, int kLen, void **ppKey, int *pkLen, vo
   return tdbBtreePGet(pDb->pBt, pKey, kLen, ppKey, pkLen, ppVal, vLen);
 }
 
-int tdbDbcOpen(TDB *pDb, TDBC **ppDbc) {
+int tdbDbcOpen(TDB *pDb, TDBC **ppDbc, TXN *pTxn) {
   int   ret;
   TDBC *pDbc = NULL;
 
@@ -97,34 +97,53 @@ int tdbDbcOpen(TDB *pDb, TDBC **ppDbc) {
     return -1;
   }
 
-  tdbBtcOpen(&pDbc->btc, pDb->pBt, NULL);
+  tdbBtcOpen(&pDbc->btc, pDb->pBt, pTxn);
-
-  // TODO: move to first now, we can move to any key-value
-  // and in any direction, design new APIs.
-  ret = tdbBtcMoveToFirst(&pDbc->btc);
-  if (ret < 0) {
-    ASSERT(0);
-    return -1;
-  }
 
   *ppDbc = pDbc;
   return 0;
 }
 
-int tdbDbNext(TDBC *pDbc, void **ppKey, int *kLen, void **ppVal, int *vLen) {
+int tdbDbcMoveTo(TDBC *pDbc, const void *pKey, int kLen, int *c) { return tdbBtcMoveTo(&pDbc->btc, pKey, kLen, c); }
+
+int tdbDbcMoveToFirst(TDBC *pDbc) { return tdbBtcMoveToFirst(&pDbc->btc); }
+
+int tdbDbcMoveToLast(TDBC *pDbc) { return tdbBtcMoveToLast(&pDbc->btc); }
+
+int tdbDbcMoveToNext(TDBC *pDbc) { return tdbBtcMoveToNext(&pDbc->btc); }
+
+int tdbDbcMoveToPrev(TDBC *pDbc) { return tdbBtcMoveToPrev(&pDbc->btc); }
+
+int tdbDbcGet(TDBC *pDbc, const void **ppKey, int *pkLen, const void **ppVal, int *pvLen) {
+  return tdbBtcGet(&pDbc->btc, ppKey, pkLen, ppVal, pvLen);
+}
+
+int tdbDbcPut(TDBC *pDbc, const void *pKey, int keyLen, const void *pVal, int valLen) {
+  // TODO
+  ASSERT(0);
+  return 0;
+}
+
+int tdbDbcUpdate(TDBC *pDbc, const void *pKey, int kLen, const void *pVal, int vLen) {
+  // TODO
+  ASSERT(0);
+  return 0;
+}
+
+int tdbDbcDrop(TDBC *pDbc) {
+  // TODO
+  ASSERT(0);
+  return 0;
+}
+
+int tdbDbcNext(TDBC *pDbc, void **ppKey, int *kLen, void **ppVal, int *vLen) {
   return tdbBtreeNext(&pDbc->btc, ppKey, kLen, ppVal, vLen);
 }
 
 int tdbDbcClose(TDBC *pDbc) {
   if (pDbc) {
+    tdbBtcClose(&pDbc->btc);
     tdbOsFree(pDbc);
   }
 
   return 0;
 }
-
-int tdbDbcInsert(TDBC *pDbc, const void *pKey, int keyLen, const void *pVal, int valLen) {
-  // TODO
-  ASSERT(0);
-  return 0;
-}

source/libs/tdb/src/db/tdbEnv.c

@@ -15,7 +15,7 @@
 
 #include "tdbInt.h"
 
-int tdbEnvOpen(const char *rootDir, int pageSize, int cacheSize, TENV **ppEnv) {
+int tdbEnvOpen(const char *rootDir, int szPage, int pages, TENV **ppEnv) {
   TENV *pEnv;
   int   dsize;
   int   zsize;
@@ -49,14 +49,14 @@ int tdbEnvOpen(const char *rootDir, int pageSize, int cacheSize, TENV **ppEnv) {
 
   pEnv->jfd = -1;
 
-  ret = tdbPCacheOpen(pageSize, cacheSize, &(pEnv->pCache));
+  ret = tdbPCacheOpen(szPage, pages, &(pEnv->pCache));
   if (ret < 0) {
     return -1;
   }
 
   pEnv->nPgrHash = 8;
   tsize = sizeof(SPager *) * pEnv->nPgrHash;
-  pEnv->pgrHash = TDB_REALLOC(pEnv->pgrHash, tsize);
+  pEnv->pgrHash = tdbRealloc(pEnv->pgrHash, tsize);
   if (pEnv->pgrHash == NULL) {
     return -1;
   }
@@ -103,11 +103,6 @@ int tdbCommit(TENV *pEnv, TXN *pTxn) {
   return 0;
 }
 
-int tdbRollback(TENV *pEnv, TXN *pTxn) {
-  ASSERT(0);
-  return 0;
-}
-
 SPager *tdbEnvGetPager(TENV *pEnv, const char *fname) {
   u32      hash;
   SPager **ppPager;

source/libs/tdb/src/db/tdbOs.c

@@ -13,7 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "tdbInt.h"
+#include "tdbOs.h"
 
 #ifndef TDB_FOR_TDENGINE
 

source/libs/tdb/src/db/tdbPCache.c

@@ -135,7 +135,7 @@ static SPage *tdbPCacheFetchImpl(SPCache *pCache, const SPgid *pPgid, TXN *pTxn)
   // 1. Search the hash table
   pPage = pCache->pgHash[tdbPCachePageHash(pPgid) % pCache->nHash];
   while (pPage) {
-    if (TDB_IS_SAME_PAGE(&(pPage->pgid), pPgid)) break;
+    if (memcmp(pPage->pgid.fileid, pPgid->fileid, TDB_FILE_ID_LEN) == 0 && pPage->pgid.pgno == pPgid->pgno) break;
     pPage = pPage->pHashNext;
   }
 

source/libs/tdb/src/db/tdbUtil.c

@@ -15,6 +15,26 @@
 
 #include "tdbInt.h"
 
+void *tdbRealloc(void *ptr, size_t size) {
+  void *nPtr;
+  if ((ptr) == NULL || ((int *)(ptr))[-1] < (size)) {
+    nPtr = tdbOsRealloc((ptr) ? (char *)(ptr) - sizeof(int) : NULL, (size) + sizeof(int));
+    if (nPtr) {
+      ((int *)nPtr)[0] = (size);
+      nPtr = (char *)nPtr + sizeof(int);
+    }
+  } else {
+    nPtr = (ptr);
+  }
+  return nPtr;
+}
+
+void tdbFree(void *p) {
+  if (p) {
+    tdbOsFree((char *)(p) - sizeof(int));
+  }
+}
+
 int tdbGnrtFileID(const char *fname, uint8_t *fileid, bool unique) {
   int64_t stDev = 0, stIno = 0;
 

source/libs/tdb/src/inc/tdbBtree.h

@@ -1,60 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _TD_BTREE_H_
-#define _TD_BTREE_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct SBTree SBTree;
-typedef struct SBTC   SBTC;
-typedef struct SBtInfo {
-  SPgno root;
-  int   nLevel;
-  int   nData;
-} SBtInfo;
-
-struct SBTC {
-  SBTree *pBt;
-  i8      iPage;
-  SPage  *pPage;
-  int     idx;
-  int     idxStack[BTREE_MAX_DEPTH + 1];
-  SPage  *pgStack[BTREE_MAX_DEPTH + 1];
-  TXN    *pTxn;
-  TXN     txn;
-};
-
-// SBTree
-int tdbBtreeOpen(int keyLen, int valLen, SPager *pFile, FKeyComparator kcmpr, SBTree **ppBt);
-int tdbBtreeClose(SBTree *pBt);
-int tdbBtreeInsert(SBTree *pBt, const void *pKey, int kLen, const void *pVal, int vLen, TXN *pTxn);
-int tdbBtreeGet(SBTree *pBt, const void *pKey, int kLen, void **ppVal, int *vLen);
-int tdbBtreePGet(SBTree *pBt, const void *pKey, int kLen, void **ppKey, int *pkLen, void **ppVal, int *vLen);
-
-// SBTC
-int tdbBtcOpen(SBTC *pBtc, SBTree *pBt, TXN *pTxn);
-int tdbBtcMoveToFirst(SBTC *pBtc);
-int tdbBtcMoveToLast(SBTC *pBtc);
-int tdbBtreeNext(SBTC *pBtc, void **ppKey, int *kLen, void **ppVal, int *vLen);
-int tdbBtcClose(SBTC *pBtc);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_BTREE_H_*/

source/libs/tdb/src/inc/tdbDb.h

@@ -1,44 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _TD_TDB_DB_H_
-#define _TD_TDB_DB_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct STDB  TDB;
-typedef struct STDBC TDBC;
-
-// TDB
-int tdbDbOpen(const char *fname, int keyLen, int valLen, FKeyComparator keyCmprFn, TENV *pEnv, TDB **ppDb);
-int tdbDbClose(TDB *pDb);
-int tdbDbDrop(TDB *pDb);
-int tdbDbInsert(TDB *pDb, const void *pKey, int keyLen, const void *pVal, int valLen, TXN *pTxn);
-int tdbDbGet(TDB *pDb, const void *pKey, int kLen, void **ppVal, int *vLen);
-int tdbDbPGet(TDB *pDb, const void *pKey, int kLen, void **ppKey, int *pkLen, void **ppVal, int *vLen);
-
-// TDBC
-int tdbDbcOpen(TDB *pDb, TDBC **ppDbc);
-int tdbDbNext(TDBC *pDbc, void **ppKey, int *kLen, void **ppVal, int *vLen);
-int tdbDbcClose(TDBC *pDbc);
-int tdbDbcInsert(TDBC *pDbc, const void *pKey, int keyLen, const void *pVal, int valLen);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_TDB_DB_H_*/

source/libs/tdb/src/inc/tdbEnv.h

@@ -1,48 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _TDB_ENV_H_
-#define _TDB_ENV_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct STEnv {
-  char    *rootDir;
-  char    *jfname;
-  int      jfd;
-  SPCache *pCache;
-  SPager  *pgrList;
-  int      nPager;
-  int      nPgrHash;
-  SPager **pgrHash;
-} TENV;
-
-int tdbEnvOpen(const char *rootDir, int pageSize, int cacheSize, TENV **ppEnv);
-int tdbEnvClose(TENV *pEnv);
-int tdbBegin(TENV *pEnv, TXN *pTxn);
-int tdbCommit(TENV *pEnv, TXN *pTxn);
-int tdbRollback(TENV *pEnv, TXN *pTxn);
-
-void    tdbEnvAddPager(TENV *pEnv, SPager *pPager);
-void    tdbEnvRemovePager(TENV *pEnv, SPager *pPager);
-SPager *tdbEnvGetPager(TENV *pEnv, const char *fname);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TDB_ENV_H_*/

source/libs/tdb/src/inc/tdbInt.h

@@ -31,6 +31,12 @@ typedef uint16_t u16;
 typedef uint32_t u32;
 typedef uint64_t u64;
 
+// SPgno
+typedef u32 SPgno;
+
+#include "tdbOs.h"
+#include "tdbUtil.h"
+
 // p must be u8 *
 #define TDB_GET_U24(p) ((p)[0] * 65536 + *(u16 *)((p) + 1))
 #define TDB_PUT_U24(p, v)       \
@@ -41,10 +47,6 @@ typedef uint64_t u64;
     (p)[0] = (tv >> 16) & 0xff; \
   } while (0)
 
-// SPgno
-typedef u32 SPgno;
-#define TDB_IVLD_PGNO ((pgno_t)0)
-
 // fileid
 #define TDB_FILE_ID_LEN 24
 
@@ -54,51 +56,21 @@ typedef struct {
   SPgno   pgno;
 } SPgid;
 
-#define TDB_IVLD_PGID (SPgid){0, TDB_IVLD_PGNO};
-
-static FORCE_INLINE int tdbCmprPgId(const void *p1, const void *p2) {
-  SPgid *pgid1 = (SPgid *)p1;
-  SPgid *pgid2 = (SPgid *)p2;
-  int    rcode;
-
-  rcode = memcmp(pgid1->fileid, pgid2->fileid, TDB_FILE_ID_LEN);
-  if (rcode) {
-    return rcode;
-  } else {
-    if (pgid1->pgno > pgid2->pgno) {
-      return 1;
-    } else if (pgid1->pgno < pgid2->pgno) {
-      return -1;
-    } else {
-      return 0;
-    }
-  }
-}
-
-#define TDB_IS_SAME_PAGE(pPgid1, pPgid2) (tdbCmprPgId(pPgid1, pPgid2) == 0)
-
 // pgsz_t
 #define TDB_MIN_PGSIZE       512       // 512B
 #define TDB_MAX_PGSIZE       16777216  // 16M
 #define TDB_DEFAULT_PGSIZE   4096
 #define TDB_IS_PGSIZE_VLD(s) (((s) >= TDB_MIN_PGSIZE) && ((s) <= TDB_MAX_PGSIZE))
 
-// cache
-#define TDB_DEFAULT_CACHE_SIZE (256 * 4096)  // 1M
-
 // dbname
 #define TDB_MAX_DBNAME_LEN 24
 
 #define TDB_VARIANT_LEN ((int)-1)
 
-typedef int (*FKeyComparator)(const void *pKey1, int kLen1, const void *pKey2, int kLen2);
-
 #define TDB_JOURNAL_NAME "tdb.journal"
 
 #define TDB_FILENAME_LEN 128
 
-#define TDB_DEFAULT_FANOUT 6
-
 #define BTREE_MAX_DEPTH 20
 
 #define TDB_FLAG_IS(flags, flag)     ((flags) == (flag))
@@ -112,37 +84,253 @@ typedef struct SPCache SPCache;
 typedef struct SPage   SPage;
 
 // transaction
-#define TDB_TXN_WRITE            0x1
-#define TDB_TXN_READ_UNCOMMITTED 0x2
-typedef struct STxn {
-  int flags;
-  i64 txnId;
-  void *(*xMalloc)(void *, size_t);
-  void (*xFree)(void *, void *);
-  void *xArg;
-} TXN;
 
 #define TDB_TXN_IS_WRITE(PTXN)            ((PTXN)->flags & TDB_TXN_WRITE)
 #define TDB_TXN_IS_READ(PTXN)             (!TDB_TXN_IS_WRITE(PTXN))
 #define TDB_TXN_IS_READ_UNCOMMITTED(PTXN) ((PTXN)->flags & TDB_TXN_READ_UNCOMMITTED)
 
-#include "tdbOs.h"
+// tdbEnv.c ====================================
+void    tdbEnvAddPager(TENV *pEnv, SPager *pPager);
+void    tdbEnvRemovePager(TENV *pEnv, SPager *pPager);
+SPager *tdbEnvGetPager(TENV *pEnv, const char *fname);
 
-#include "tdbUtil.h"
+// tdbBtree.c ====================================
+typedef struct SBTree SBTree;
+typedef struct SBTC   SBTC;
+typedef struct SBtInfo {
+  SPgno root;
+  int   nLevel;
+  int   nData;
+} SBtInfo;
 
-#include "tdbPCache.h"
+typedef struct {
+  int       kLen;
+  const u8 *pKey;
+  int       vLen;
+  const u8 *pVal;
+  SPgno     pgno;
+  u8       *pBuf;
+} SCellDecoder;
 
-#include "tdbPager.h"
+struct SBTC {
+  SBTree      *pBt;
+  i8           iPage;
+  SPage       *pPage;
+  int          idx;
+  int          idxStack[BTREE_MAX_DEPTH + 1];
+  SPage       *pgStack[BTREE_MAX_DEPTH + 1];
+  SCellDecoder coder;
+  TXN         *pTxn;
+  TXN          txn;
+};
 
-#include "tdbBtree.h"
+// SBTree
+int tdbBtreeOpen(int keyLen, int valLen, SPager *pFile, tdb_cmpr_fn_t kcmpr, SBTree **ppBt);
+int tdbBtreeClose(SBTree *pBt);
+int tdbBtreeInsert(SBTree *pBt, const void *pKey, int kLen, const void *pVal, int vLen, TXN *pTxn);
+int tdbBtreeGet(SBTree *pBt, const void *pKey, int kLen, void **ppVal, int *vLen);
+int tdbBtreePGet(SBTree *pBt, const void *pKey, int kLen, void **ppKey, int *pkLen, void **ppVal, int *vLen);
 
-#include "tdbEnv.h"
+// SBTC
+int tdbBtcOpen(SBTC *pBtc, SBTree *pBt, TXN *pTxn);
+int tdbBtcClose(SBTC *pBtc);
+int tdbBtcMoveTo(SBTC *pBtc, const void *pKey, int kLen, int *pCRst);
+int tdbBtcMoveToFirst(SBTC *pBtc);
+int tdbBtcMoveToLast(SBTC *pBtc);
+int tdbBtcMoveToNext(SBTC *pBtc);
+int tdbBtcMoveToPrev(SBTC *pBtc);
+int tdbBtreeNext(SBTC *pBtc, void **ppKey, int *kLen, void **ppVal, int *vLen);
+int tdbBtcGet(SBTC *pBtc, const void **ppKey, int *kLen, const void **ppVal, int *vLen);
 
-#include "tdbDb.h"
+// tdbPager.c ====================================
 
-#include "tdbPage.h"
+int  tdbPagerOpen(SPCache *pCache, const char *fileName, SPager **ppPager);
+int  tdbPagerClose(SPager *pPager);
+int  tdbPagerOpenDB(SPager *pPager, SPgno *ppgno, bool toCreate);
+int  tdbPagerWrite(SPager *pPager, SPage *pPage);
+int  tdbPagerBegin(SPager *pPager, TXN *pTxn);
+int  tdbPagerCommit(SPager *pPager, TXN *pTxn);
+int  tdbPagerFetchPage(SPager *pPager, SPgno *ppgno, SPage **ppPage, int (*initPage)(SPage *, void *, int), void *arg,
+                       TXN *pTxn);
+void tdbPagerReturnPage(SPager *pPager, SPage *pPage, TXN *pTxn);
+int  tdbPagerAllocPage(SPager *pPager, SPgno *ppgno);
 
-#include "tdbTxn.h"
+// tdbPCache.c ====================================
+#define TDB_PCACHE_PAGE \
+  u8      isAnchor;     \
+  u8      isLocal;      \
+  u8      isDirty;      \
+  i32     nRef;         \
+  SPage  *pCacheNext;   \
+  SPage  *pFreeNext;    \
+  SPage  *pHashNext;    \
+  SPage  *pLruNext;     \
+  SPage  *pLruPrev;     \
+  SPage  *pDirtyNext;   \
+  SPager *pPager;       \
+  SPgid   pgid;
+
+// For page ref
+#define TDB_INIT_PAGE_REF(pPage) ((pPage)->nRef = 0)
+#define TDB_REF_PAGE(pPage)      atomic_add_fetch_32(&((pPage)->nRef), 1)
+#define TDB_UNREF_PAGE(pPage)    atomic_sub_fetch_32(&((pPage)->nRef), 1)
+#define TDB_GET_PAGE_REF(pPage)  atomic_load_32(&((pPage)->nRef))
+
+int    tdbPCacheOpen(int pageSize, int cacheSize, SPCache **ppCache);
+int    tdbPCacheClose(SPCache *pCache);
+SPage *tdbPCacheFetch(SPCache *pCache, const SPgid *pPgid, TXN *pTxn);
+void   tdbPCacheRelease(SPCache *pCache, SPage *pPage, TXN *pTxn);
+int    tdbPCacheGetPageSize(SPCache *pCache);
+
+// tdbPage.c ====================================
+typedef u8 SCell;
+
+// PAGE APIS implemented
+typedef struct {
+  int szOffset;
+  int szPageHdr;
+  int szFreeCell;
+  // cell number
+  int (*getCellNum)(SPage *);
+  void (*setCellNum)(SPage *, int);
+  // cell content offset
+  int (*getCellBody)(SPage *);
+  void (*setCellBody)(SPage *, int);
+  // first free cell offset (0 means no free cells)
+  int (*getCellFree)(SPage *);
+  void (*setCellFree)(SPage *, int);
+  // total free bytes
+  int (*getFreeBytes)(SPage *);
+  void (*setFreeBytes)(SPage *, int);
+  // cell offset at idx
+  int (*getCellOffset)(SPage *, int);
+  void (*setCellOffset)(SPage *, int, int);
+  // free cell info
+  void (*getFreeCellInfo)(SCell *pCell, int *szCell, int *nxOffset);
+  void (*setFreeCellInfo)(SCell *pCell, int szCell, int nxOffset);
+} SPageMethods;
+
+#pragma pack(push, 1)
+
+// Page footer
+typedef struct {
+  u8 cksm[4];
+} SPageFtr;
+#pragma pack(pop)
+
+struct SPage {
+  tdb_spinlock_t lock;
+  int            pageSize;
+  u8            *pData;
+  SPageMethods  *pPageMethods;
+  // Fields below used by pager and am
+  u8       *pPageHdr;
+  u8       *pCellIdx;
+  u8       *pFreeStart;
+  u8       *pFreeEnd;
+  SPageFtr *pPageFtr;
+  int       nOverflow;
+  SCell    *apOvfl[4];
+  int       aiOvfl[4];
+  int       kLen;  // key length of the page, -1 for unknown
+  int       vLen;  // value length of the page, -1 for unknown
+  int       maxLocal;
+  int       minLocal;
+  int (*xCellSize)(const SPage *, SCell *);
+  // Fields used by SPCache
+  TDB_PCACHE_PAGE
+};
+
+// For page lock
+#define P_LOCK_SUCC 0
+#define P_LOCK_BUSY 1
+#define P_LOCK_FAIL -1
+
+static inline int tdbTryLockPage(tdb_spinlock_t *pLock) {
+  int ret;
+  if (tdbSpinlockTrylock(pLock) == 0) {
+    ret = P_LOCK_SUCC;
+  } else if (errno == EBUSY) {
+    ret = P_LOCK_BUSY;
+  } else {
+    ret = P_LOCK_FAIL;
+  }
+  return ret;
+}
+
+#define TDB_INIT_PAGE_LOCK(pPage)    tdbSpinlockInit(&((pPage)->lock), 0)
+#define TDB_DESTROY_PAGE_LOCK(pPage) tdbSpinlockDestroy(&((pPage)->lock))
+#define TDB_LOCK_PAGE(pPage)         tdbSpinlockLock(&((pPage)->lock))
+#define TDB_UNLOCK_PAGE(pPage)       tdbSpinlockUnlock(&((pPage)->lock))
+#define TDB_TRY_LOCK_PAGE(pPage)     tdbTryLockPage(&((pPage)->lock))
+
+// APIs
+#define TDB_PAGE_TOTAL_CELLS(pPage)        ((pPage)->nOverflow + (pPage)->pPageMethods->getCellNum(pPage))
+#define TDB_PAGE_USABLE_SIZE(pPage)        ((u8 *)(pPage)->pPageFtr - (pPage)->pCellIdx)
+#define TDB_PAGE_FREE_SIZE(pPage)          (*(pPage)->pPageMethods->getFreeBytes)(pPage)
+#define TDB_PAGE_PGNO(pPage)               ((pPage)->pgid.pgno)
+#define TDB_BYTES_CELL_TAKEN(pPage, pCell) ((*(pPage)->xCellSize)(pPage, pCell) + (pPage)->pPageMethods->szOffset)
+#define TDB_PAGE_OFFSET_SIZE(pPage)        ((pPage)->pPageMethods->szOffset)
+
+int  tdbPageCreate(int pageSize, SPage **ppPage, void *(*xMalloc)(void *, size_t), void *arg);
+int  tdbPageDestroy(SPage *pPage, void (*xFree)(void *arg, void *ptr), void *arg);
+void tdbPageZero(SPage *pPage, u8 szAmHdr, int (*xCellSize)(const SPage *, SCell *));
+void tdbPageInit(SPage *pPage, u8 szAmHdr, int (*xCellSize)(const SPage *, SCell *));
+int  tdbPageInsertCell(SPage *pPage, int idx, SCell *pCell, int szCell, u8 asOvfl);
+int  tdbPageDropCell(SPage *pPage, int idx);
+void tdbPageCopy(SPage *pFromPage, SPage *pToPage);
+int  tdbPageCapacity(int pageSize, int amHdrSize);
+
+static inline SCell *tdbPageGetCell(SPage *pPage, int idx) {
+  SCell *pCell;
+  int    iOvfl;
+  int    lidx;
+
+  ASSERT(idx >= 0 && idx < TDB_PAGE_TOTAL_CELLS(pPage));
+
+  iOvfl = 0;
+  for (; iOvfl < pPage->nOverflow; iOvfl++) {
+    if (pPage->aiOvfl[iOvfl] == idx) {
+      pCell = pPage->apOvfl[iOvfl];
+      return pCell;
+    } else if (pPage->aiOvfl[iOvfl] > idx) {
+      break;
+    }
+  }
+
+  lidx = idx - iOvfl;
+  ASSERT(lidx >= 0 && lidx < pPage->pPageMethods->getCellNum(pPage));
+  pCell = pPage->pData + pPage->pPageMethods->getCellOffset(pPage, lidx);
+
+  return pCell;
+}
+
+struct STEnv {
+  char    *rootDir;
+  char    *jfname;
+  int      jfd;
+  SPCache *pCache;
+  SPager  *pgrList;
+  int      nPager;
+  int      nPgrHash;
+  SPager **pgrHash;
+};
+
+struct SPager {
+  char    *dbFileName;
+  char    *jFileName;
+  int      pageSize;
+  uint8_t  fid[TDB_FILE_ID_LEN];
+  tdb_fd_t fd;
+  tdb_fd_t jfd;
+  SPCache *pCache;
+  SPgno    dbFileSize;
+  SPgno    dbOrigSize;
+  SPage   *pDirty;
+  u8       inTran;
+  SPager  *pNext;      // used by TENV
+  SPager  *pHashNext;  // used by TENV
+};
 
 #ifdef __cplusplus
 }

source/libs/tdb/src/inc/tdbPCache.h

@@ -1,59 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _TD_PAGE_CACHE_H_
-#define _TD_PAGE_CACHE_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define TDB_PCACHE_PAGE \
-  u8      isAnchor;     \
-  u8      isLocal;      \
-  u8      isDirty;      \
-  i32     nRef;         \
-  SPage  *pCacheNext;   \
-  SPage  *pFreeNext;    \
-  SPage  *pHashNext;    \
-  SPage  *pLruNext;     \
-  SPage  *pLruPrev;     \
-  SPage  *pDirtyNext;   \
-  SPager *pPager;       \
-  SPgid   pgid;
-
-// For page ref
-#define TDB_INIT_PAGE_REF(pPage) ((pPage)->nRef = 0)
-#if 0
-#define TDB_REF_PAGE(pPage)     (++(pPage)->nRef)
-#define TDB_UNREF_PAGE(pPage)   (--(pPage)->nRef)
-#define TDB_GET_PAGE_REF(pPage) ((pPage)->nRef)
-#else
-#define TDB_REF_PAGE(pPage)     atomic_add_fetch_32(&((pPage)->nRef), 1)
-#define TDB_UNREF_PAGE(pPage)   atomic_sub_fetch_32(&((pPage)->nRef), 1)
-#define TDB_GET_PAGE_REF(pPage) atomic_load_32(&((pPage)->nRef))
-#endif
-
-int    tdbPCacheOpen(int pageSize, int cacheSize, SPCache **ppCache);
-int    tdbPCacheClose(SPCache *pCache);
-SPage *tdbPCacheFetch(SPCache *pCache, const SPgid *pPgid, TXN *pTxn);
-void   tdbPCacheRelease(SPCache *pCache, SPage *pPage, TXN *pTxn);
-int    tdbPCacheGetPageSize(SPCache *pCache);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_PAGE_CACHE_H_*/

source/libs/tdb/src/inc/tdbPage.h

@@ -1,149 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _TDB_PAGE_H_
-#define _TDB_PAGE_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef u8 SCell;
-
-// PAGE APIS implemented
-typedef struct {
-  int szOffset;
-  int szPageHdr;
-  int szFreeCell;
-  // cell number
-  int (*getCellNum)(SPage *);
-  void (*setCellNum)(SPage *, int);
-  // cell content offset
-  int (*getCellBody)(SPage *);
-  void (*setCellBody)(SPage *, int);
-  // first free cell offset (0 means no free cells)
-  int (*getCellFree)(SPage *);
-  void (*setCellFree)(SPage *, int);
-  // total free bytes
-  int (*getFreeBytes)(SPage *);
-  void (*setFreeBytes)(SPage *, int);
-  // cell offset at idx
-  int (*getCellOffset)(SPage *, int);
-  void (*setCellOffset)(SPage *, int, int);
-  // free cell info
-  void (*getFreeCellInfo)(SCell *pCell, int *szCell, int *nxOffset);
-  void (*setFreeCellInfo)(SCell *pCell, int szCell, int nxOffset);
-} SPageMethods;
-
-#pragma pack(push,1)
-
-// Page footer
-typedef struct {
-  u8 cksm[4];
-} SPageFtr;
-#pragma pack(pop)
-
-struct SPage {
-  tdb_spinlock_t lock;
-  int            pageSize;
-  u8            *pData;
-  SPageMethods  *pPageMethods;
-  // Fields below used by pager and am
-  u8       *pPageHdr;
-  u8       *pCellIdx;
-  u8       *pFreeStart;
-  u8       *pFreeEnd;
-  SPageFtr *pPageFtr;
-  int       nOverflow;
-  SCell    *apOvfl[4];
-  int       aiOvfl[4];
-  int       kLen;  // key length of the page, -1 for unknown
-  int       vLen;  // value length of the page, -1 for unknown
-  int       maxLocal;
-  int       minLocal;
-  int (*xCellSize)(const SPage *, SCell *);
-  // Fields used by SPCache
-  TDB_PCACHE_PAGE
-};
-
-// For page lock
-#define P_LOCK_SUCC 0
-#define P_LOCK_BUSY 1
-#define P_LOCK_FAIL -1
-
-static inline int tdbTryLockPage(tdb_spinlock_t *pLock) {
-  int ret;
-  if (tdbSpinlockTrylock(pLock) == 0) {
-    ret = P_LOCK_SUCC;
-  } else if (errno == EBUSY) {
-    ret = P_LOCK_BUSY;
-  } else {
-    ret = P_LOCK_FAIL;
-  }
-  return ret;
-}
-
-#define TDB_INIT_PAGE_LOCK(pPage)    tdbSpinlockInit(&((pPage)->lock), 0)
-#define TDB_DESTROY_PAGE_LOCK(pPage) tdbSpinlockDestroy(&((pPage)->lock))
-#define TDB_LOCK_PAGE(pPage)         tdbSpinlockLock(&((pPage)->lock))
-#define TDB_UNLOCK_PAGE(pPage)       tdbSpinlockUnlock(&((pPage)->lock))
-#define TDB_TRY_LOCK_PAGE(pPage)     tdbTryLockPage(&((pPage)->lock))
-
-// APIs
-#define TDB_PAGE_TOTAL_CELLS(pPage)        ((pPage)->nOverflow + (pPage)->pPageMethods->getCellNum(pPage))
-#define TDB_PAGE_USABLE_SIZE(pPage)        ((u8 *)(pPage)->pPageFtr - (pPage)->pCellIdx)
-#define TDB_PAGE_FREE_SIZE(pPage)          (*(pPage)->pPageMethods->getFreeBytes)(pPage)
-#define TDB_PAGE_PGNO(pPage)               ((pPage)->pgid.pgno)
-#define TDB_BYTES_CELL_TAKEN(pPage, pCell) ((*(pPage)->xCellSize)(pPage, pCell) + (pPage)->pPageMethods->szOffset)
-#define TDB_PAGE_OFFSET_SIZE(pPage)        ((pPage)->pPageMethods->szOffset)
-
-int  tdbPageCreate(int pageSize, SPage **ppPage, void *(*xMalloc)(void *, size_t), void *arg);
-int  tdbPageDestroy(SPage *pPage, void (*xFree)(void *arg, void *ptr), void *arg);
-void tdbPageZero(SPage *pPage, u8 szAmHdr, int (*xCellSize)(const SPage *, SCell *));
-void tdbPageInit(SPage *pPage, u8 szAmHdr, int (*xCellSize)(const SPage *, SCell *));
-int  tdbPageInsertCell(SPage *pPage, int idx, SCell *pCell, int szCell, u8 asOvfl);
-int  tdbPageDropCell(SPage *pPage, int idx);
-void tdbPageCopy(SPage *pFromPage, SPage *pToPage);
-int  tdbPageCapacity(int pageSize, int amHdrSize);
-
-static inline SCell *tdbPageGetCell(SPage *pPage, int idx) {
-  SCell *pCell;
-  int    iOvfl;
-  int    lidx;
-
-  ASSERT(idx >= 0 && idx < TDB_PAGE_TOTAL_CELLS(pPage));
-
-  iOvfl = 0;
-  for (; iOvfl < pPage->nOverflow; iOvfl++) {
-    if (pPage->aiOvfl[iOvfl] == idx) {
-      pCell = pPage->apOvfl[iOvfl];
-      return pCell;
-    } else if (pPage->aiOvfl[iOvfl] > idx) {
-      break;
-    }
-  }
-
-  lidx = idx - iOvfl;
-  ASSERT(lidx >= 0 && lidx < pPage->pPageMethods->getCellNum(pPage));
-  pCell = pPage->pData + pPage->pPageMethods->getCellOffset(pPage, lidx);
-
-  return pCell;
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TDB_PAGE_H_*/

source/libs/tdb/src/inc/tdbPager.h

@@ -1,54 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _TDB_PAGER_H_
-#define _TDB_PAGER_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct SPager {
-  char    *dbFileName;
-  char    *jFileName;
-  int      pageSize;
-  uint8_t  fid[TDB_FILE_ID_LEN];
-  tdb_fd_t fd;
-  tdb_fd_t jfd;
-  SPCache *pCache;
-  SPgno    dbFileSize;
-  SPgno    dbOrigSize;
-  SPage   *pDirty;
-  u8       inTran;
-  SPager  *pNext;      // used by TENV
-  SPager  *pHashNext;  // used by TENV
-};
-
-int  tdbPagerOpen(SPCache *pCache, const char *fileName, SPager **ppPager);
-int  tdbPagerClose(SPager *pPager);
-int  tdbPagerOpenDB(SPager *pPager, SPgno *ppgno, bool toCreate);
-int  tdbPagerWrite(SPager *pPager, SPage *pPage);
-int  tdbPagerBegin(SPager *pPager, TXN *pTxn);
-int  tdbPagerCommit(SPager *pPager, TXN *pTxn);
-int  tdbPagerFetchPage(SPager *pPager, SPgno *ppgno, SPage **ppPage, int (*initPage)(SPage *, void *, int), void *arg,
-                       TXN *pTxn);
-void tdbPagerReturnPage(SPager *pPager, SPage *pPage, TXN *pTxn);
-int  tdbPagerAllocPage(SPager *pPager, SPgno *ppgno);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TDB_PAGER_H_*/

source/libs/tdb/src/inc/tdbTxn.h

@@ -1,31 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _TDB_TXN_H_
-#define _TDB_TXN_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-int tdbTxnOpen(TXN *pTxn, int64_t txnid, void *(*xMalloc)(void *, size_t), void (*xFree)(void *, void *), void *xArg,
-               int flags);
-int tdbTxnClose(TXN *pTxn);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TDB_TXN_H_*/

source/libs/tdb/src/inc/tdbUtil.h

@@ -31,27 +31,7 @@ extern "C" {
 int tdbGnrtFileID(const char *fname, uint8_t *fileid, bool unique);
 int tdbGetFileSize(tdb_fd_t fd, int szPage, SPgno *size);
 
-static inline void *tdbRealloc(void *ptr, size_t size) {
+void *tdbRealloc(void *ptr, size_t size);
-  void *nPtr;
-  if ((ptr) == NULL || ((int *)(ptr))[-1] < (size)) {
-    nPtr = tdbOsRealloc((ptr) ? (char *)(ptr) - sizeof(int) : NULL, (size) + sizeof(int));
-    if (nPtr) {
-      ((int *)nPtr)[0] = (size);
-      nPtr = (char *)nPtr + sizeof(int);
-    }
-  } else {
-    nPtr = (ptr);
-  }
-  return nPtr;
-}
-#define TDB_REALLOC(PTR, SIZE)  tdbRealloc(PTR, SIZE)
-
-#define TDB_FREE(PTR)                         \
-  do {                                        \
-    if (PTR) {                                \
-      tdbOsFree((char *)(PTR) - sizeof(int)); \
-    }                                         \
-  } while (0)
 
 static inline void *tdbDefaultMalloc(void *arg, size_t size) {
   void *ptr;

source/libs/tdb/test/tdbTest.cpp

@@ -1,7 +1,7 @@
 #include <gtest/gtest.h>
 
 #include "os.h"
-#include "tdbInt.h"
+#include "tdb.h"
 
 #include <string>
 
@@ -12,7 +12,7 @@ typedef struct SPoolMem {
 } SPoolMem;
 
 static SPoolMem *openPool() {
-  SPoolMem *pPool = (SPoolMem *)tdbOsMalloc(sizeof(*pPool));
+  SPoolMem *pPool = (SPoolMem *)taosMemoryMalloc(sizeof(*pPool));
 
   pPool->prev = pPool->next = pPool;
   pPool->size = 0;
@@ -32,7 +32,7 @@ static void clearPool(SPoolMem *pPool) {
     pMem->prev->next = pMem->next;
     pPool->size -= pMem->size;
 
-    tdbOsFree(pMem);
+    taosMemoryFree(pMem);
   } while (1);
 
   assert(pPool->size == 0);
@@ -40,7 +40,7 @@ static void clearPool(SPoolMem *pPool) {
 
 static void closePool(SPoolMem *pPool) {
   clearPool(pPool);
-  tdbOsFree(pPool);
+  taosMemoryFree(pPool);
 }
 
 static void *poolMalloc(void *arg, size_t size) {
@@ -48,7 +48,7 @@ static void *poolMalloc(void *arg, size_t size) {
   SPoolMem *pPool = (SPoolMem *)arg;
   SPoolMem *pMem;
 
-  pMem = (SPoolMem *)tdbOsMalloc(sizeof(*pMem) + size);
+  pMem = (SPoolMem *)taosMemoryMalloc(sizeof(*pMem) + size);
   if (pMem == NULL) {
     assert(0);
   }
@@ -75,7 +75,7 @@ static void poolFree(void *arg, void *ptr) {
   pMem->prev->next = pMem->next;
   pPool->size -= pMem->size;
 
-  tdbOsFree(pMem);
+  taosMemoryFree(pMem);
 }
 
 static int tKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2) {
@@ -116,12 +116,12 @@ static int tDefaultKeyCmpr(const void *pKey1, int keyLen1, const void *pKey2, in
 }
 
 TEST(tdb_test, simple_test) {
-  int            ret;
+  int           ret;
-  TENV          *pEnv;
+  TENV         *pEnv;
-  TDB           *pDb;
+  TDB          *pDb;
-  FKeyComparator compFunc;
+  tdb_cmpr_fn_t compFunc;
-  int            nData = 10000000;
+  int           nData = 10000000;
-  TXN            txn;
+  TXN           txn;
 
   taosRemoveDir("tdb");
 
@@ -131,7 +131,7 @@ TEST(tdb_test, simple_test) {
 
   // Create a database
   compFunc = tKeyCmpr;
-  ret = tdbDbOpen("db.db", TDB_VARIANT_LEN, TDB_VARIANT_LEN, compFunc, pEnv, &pDb);
+  ret = tdbDbOpen("db.db", -1, -1, compFunc, pEnv, &pDb);
   GTEST_ASSERT_EQ(ret, 0);
 
   {
@@ -152,7 +152,7 @@ TEST(tdb_test, simple_test) {
     for (int iData = 1; iData <= nData; iData++) {
       sprintf(key, "key%d", iData);
       sprintf(val, "value%d", iData);
-      ret = tdbDbInsert(pDb, key, strlen(key), val, strlen(val), &txn);
+      ret = tdbDbPut(pDb, key, strlen(key), val, strlen(val), &txn);
       GTEST_ASSERT_EQ(ret, 0);
 
       // if pool is full, commit the transaction and start a new one
@@ -189,7 +189,7 @@ TEST(tdb_test, simple_test) {
         GTEST_ASSERT_EQ(memcmp(val, pVal, vLen), 0);
       }
 
-      TDB_FREE(pVal);
+      tdbFree(pVal);
     }
 
     {  // Iterate to query the DB data
@@ -199,11 +199,11 @@ TEST(tdb_test, simple_test) {
       int   vLen, kLen;
       int   count = 0;
 
-      ret = tdbDbcOpen(pDb, &pDBC);
+      ret = tdbDbcOpen(pDb, &pDBC, NULL);
       GTEST_ASSERT_EQ(ret, 0);
 
       for (;;) {
-        ret = tdbDbNext(pDBC, &pKey, &kLen, &pVal, &vLen);
+        ret = tdbDbcNext(pDBC, &pKey, &kLen, &pVal, &vLen);
         if (ret < 0) break;
 
         // std::cout.write((char *)pKey, kLen) /* << " " << kLen */ << " ";
@@ -217,8 +217,8 @@ TEST(tdb_test, simple_test) {
 
       tdbDbcClose(pDBC);
 
-      TDB_FREE(pKey);
+      tdbFree(pKey);
-      TDB_FREE(pVal);
+      tdbFree(pVal);
     }
   }
 
@@ -234,12 +234,12 @@ TEST(tdb_test, simple_test) {
 }
 
 TEST(tdb_test, simple_test2) {
-  int            ret;
+  int           ret;
-  TENV          *pEnv;
+  TENV         *pEnv;
-  TDB           *pDb;
+  TDB          *pDb;
-  FKeyComparator compFunc;
+  tdb_cmpr_fn_t compFunc;
-  int            nData = 1000000;
+  int           nData = 1000000;
-  TXN            txn;
+  TXN           txn;
 
   taosRemoveDir("tdb");
 
@@ -249,7 +249,7 @@ TEST(tdb_test, simple_test2) {
 
   // Create a database
   compFunc = tDefaultKeyCmpr;
-  ret = tdbDbOpen("db.db", TDB_VARIANT_LEN, TDB_VARIANT_LEN, compFunc, pEnv, &pDb);
+  ret = tdbDbOpen("db.db", -1, -1, compFunc, pEnv, &pDb);
   GTEST_ASSERT_EQ(ret, 0);
 
   {
@@ -269,7 +269,7 @@ TEST(tdb_test, simple_test2) {
     for (int iData = 1; iData <= nData; iData++) {
       sprintf(key, "key%d", iData);
       sprintf(val, "value%d", iData);
-      ret = tdbDbInsert(pDb, key, strlen(key), val, strlen(val), &txn);
+      ret = tdbDbPut(pDb, key, strlen(key), val, strlen(val), &txn);
       GTEST_ASSERT_EQ(ret, 0);
     }
 
@@ -280,11 +280,11 @@ TEST(tdb_test, simple_test2) {
       int   vLen, kLen;
       int   count = 0;
 
-      ret = tdbDbcOpen(pDb, &pDBC);
+      ret = tdbDbcOpen(pDb, &pDBC, NULL);
       GTEST_ASSERT_EQ(ret, 0);
 
       for (;;) {
-        ret = tdbDbNext(pDBC, &pKey, &kLen, &pVal, &vLen);
+        ret = tdbDbcNext(pDBC, &pKey, &kLen, &pVal, &vLen);
         if (ret < 0) break;
 
         std::cout.write((char *)pKey, kLen) /* << " " << kLen */ << " ";
@@ -298,8 +298,8 @@ TEST(tdb_test, simple_test2) {
 
       tdbDbcClose(pDBC);
 
-      TDB_FREE(pKey);
+      tdbFree(pKey);
-      TDB_FREE(pVal);
+      tdbFree(pVal);
     }
   }
 

source/libs/tdb/test/tdbUtilTest.cpp

@@ -1,20 +1,20 @@
 #include <gtest/gtest.h>
 
-#include "tdbInt.h"
+#include "tdb.h"
 
 #include <string>
 
 TEST(tdb_util_test, simple_test) {
-  int vEncode = 5000;
+  // int     vEncode = 5000;
-  int vDecode;
+  // int     vDecode;
-  int nEncode;
+  // int     nEncode;
-  int nDecode;
+  // int     nDecode;
-  u8  buffer[128];
+  // uint8_t buffer[128];
 
-  nEncode = tdbPutVarInt(buffer, vEncode);
+  // nEncode = tdbPutVarInt(buffer, vEncode);
 
-  nDecode = tdbGetVarInt(buffer, &vDecode);
+  // nDecode = tdbGetVarInt(buffer, &vDecode);
 
-  GTEST_ASSERT_EQ(nEncode, nDecode);
+  // GTEST_ASSERT_EQ(nEncode, nDecode);
-  GTEST_ASSERT_EQ(vEncode, vDecode);
+  // GTEST_ASSERT_EQ(vEncode, vDecode);
 }

source/libs/transport/src/trans.c

@@ -101,18 +101,8 @@ void* rpcReallocCont(void* ptr, int contLen) {
 }
 
 void rpcSendRedirectRsp(void* thandle, const SEpSet* pEpSet) {
-  SRpcMsg rpcMsg;
+  // deprecated api
-  memset(&rpcMsg, 0, sizeof(rpcMsg));
+  assert(0);
-
-  SMEpSet msg = {.epSet = *pEpSet};
-  int32_t len = tSerializeSMEpSet(NULL, 0, &msg);
-  rpcMsg.pCont = rpcMallocCont(len);
-  tSerializeSMEpSet(rpcMsg.pCont, len, &msg);
-
-  rpcMsg.code = TSDB_CODE_RPC_REDIRECT;
-  rpcMsg.handle = thandle;
-
-  rpcSendResponse(&rpcMsg);
 }
 
 int  rpcReportProgress(void* pConn, char* pCont, int contLen) { return -1; }

source/libs/transport/src/transCli.c

@@ -914,8 +914,9 @@ int cliAppCb(SCliConn* pConn, STransMsg* pResp, SCliMsg* pMsg) {
   tmsg_t msgType = pCtx->msgType;
   if ((pTransInst->retry != NULL && (pTransInst->retry(pResp->code))) ||
       ((pResp->code == TSDB_CODE_RPC_NETWORK_UNAVAIL) && msgType == TDMT_MND_CONNECT)) {
-    pCtx->retryCount += 1;
+    pMsg->sent = 0;
     pMsg->st = taosGetTimestampUs();
+    pCtx->retryCount += 1;
     if (msgType == TDMT_MND_CONNECT && pResp->code == TSDB_CODE_RPC_NETWORK_UNAVAIL) {
       if (pCtx->retryCount < pEpSet->numOfEps) {
         pEpSet->inUse = (++pEpSet->inUse) % pEpSet->numOfEps;
@@ -936,12 +937,14 @@ int cliAppCb(SCliConn* pConn, STransMsg* pResp, SCliMsg* pMsg) {
         tDeserializeSMEpSet(pResp->pCont, pResp->contLen, &emsg);
         pCtx->epSet = emsg.epSet;
       }
+      addConnToPool(pThrd, pConn);
+      tTrace("use remote epset, current in use: %d, retry count%d, try limit: %d", pEpSet->inUse, pCtx->retryCount + 1,
+             TRANS_RETRY_COUNT_LIMIT);
+
       STaskArg* arg = taosMemoryMalloc(sizeof(STaskArg));
       arg->param1 = pMsg;
       arg->param2 = pThrd;
-
       transDQSched(pThrd->delayQueue, doDelayTask, arg, TRANS_RETRY_INTERVAL);
-      addConnToPool(pThrd, pConn);
       return -1;
     }
   }

source/libs/transport/src/transSrv.c

@@ -207,7 +207,7 @@ static bool addHandleToAcceptloop(void* arg);
       SExHandle* exh2 = uvAcquireExHandle(refId);                                                                     \
       if (exh2 == NULL || refId != exh2->refId) {                                                                     \
         tTrace("server handle %p except, may already freed, ignore msg, ref1: %" PRIu64 ", ref2 : %" PRIu64 "", exh1, \
-               exh1->refId, refId);                                                                                   \
+               exh2 ? exh2->refId : 0, refId);                                                                        \
         goto _return1;                                                                                                \
       }                                                                                                               \
     } else if (refId == 0) {                                                                                          \
@@ -765,8 +765,10 @@ static void destroyConn(SSrvConn* conn, bool clear) {
   transDestroyBuffer(&conn->readBuf);
   if (clear) {
     tTrace("server conn %p to be destroyed", conn);
-    uv_shutdown_t* req = taosMemoryMalloc(sizeof(uv_shutdown_t));
+    // uv_shutdown_t* req = taosMemoryMalloc(sizeof(uv_shutdown_t));
-    uv_shutdown(req, (uv_stream_t*)conn->pTcp, uvShutDownCb);
+    uv_close((uv_handle_t*)conn->pTcp, uvDestroyConn);
+    // uv_close(conn->pTcp)
+    // uv_shutdown(req, (uv_stream_t*)conn->pTcp, uvShutDownCb);
   }
 }
 static void uvDestroyConn(uv_handle_t* handle) {

source/util/src/terror.c

@@ -93,6 +93,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_OPS_NOT_SUPPORT,              "Operation not support
 TAOS_DEFINE_ERROR(TSDB_CODE_MSG_NOT_PROCESSED,            "Message not processed")
 TAOS_DEFINE_ERROR(TSDB_CODE_CFG_NOT_FOUND,                "Config not found")
 TAOS_DEFINE_ERROR(TSDB_CODE_REPEAT_INIT,                  "Repeat initialization")
+TAOS_DEFINE_ERROR(TSDB_CODE_DUP_KEY,                      "Cannot add duplicate keys to hash")
 
 TAOS_DEFINE_ERROR(TSDB_CODE_REF_NO_MEMORY,                "Ref out of memory")
 TAOS_DEFINE_ERROR(TSDB_CODE_REF_FULL,                     "too many Ref Objs")
@@ -317,6 +318,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_VND_INVALID_TSDB_STATE,       "Invalid tsdb state")
 TAOS_DEFINE_ERROR(TSDB_CODE_VND_TB_NOT_EXIST,             "Table not exists")
 TAOS_DEFINE_ERROR(TSDB_CODE_VND_SMA_NOT_EXIST,            "SMA not exists")
 TAOS_DEFINE_ERROR(TSDB_CODE_VND_HASH_MISMATCH,            "Hash value mismatch")
+TAOS_DEFINE_ERROR(TSDB_CODE_VND_TABLE_NOT_EXIST,          "Table does not exists")
 
 // tsdb
 TAOS_DEFINE_ERROR(TSDB_CODE_TDB_INVALID_TABLE_ID,         "Invalid table ID")

source/util/src/thash.c

@@ -310,6 +310,7 @@ int32_t taosHashGetSize(const SHashObj *pHashObj) {
 
 int32_t taosHashPut(SHashObj *pHashObj, const void *key, size_t keyLen, const void *data, size_t size) {
   if (pHashObj == NULL || key == NULL || keyLen == 0) {
+    terrno = TSDB_CODE_INVALID_PTR;
     return -1;
   }
 
@@ -378,6 +379,8 @@ int32_t taosHashPut(SHashObj *pHashObj, const void *key, size_t keyLen, const vo
       }
 
       doUpdateHashNode(pHashObj, pe, prev, pNode, pNewNode);
+    } else {
+      terrno = TSDB_CODE_DUP_KEY;
     }
 
     taosHashEntryWUnlock(pHashObj, pe);

source/util/src/tprocess.c

@@ -175,7 +175,6 @@ static int32_t taosProcQueuePush(SProcObj *pProc, SProcQueue *pQueue, const char
   if (handle != 0 && ftype == PROC_FUNC_REQ) {
     if (taosHashPut(pProc->hash, &handle, sizeof(int64_t), &handleRef, sizeof(int64_t)) != 0) {
       taosThreadMutexUnlock(&pQueue->mutex);
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
       return -1;
     }
   }
@@ -227,8 +226,8 @@ static int32_t taosProcQueuePush(SProcObj *pProc, SProcQueue *pQueue, const char
   taosThreadMutexUnlock(&pQueue->mutex);
   tsem_post(&pQueue->sem);
 
-  uTrace("proc:%s, push msg at pos:%d ftype:%d remain:%d, head:%d %p body:%d %p", pQueue->name, pos, ftype,
+  uTrace("proc:%s, push msg at pos:%d ftype:%d remain:%d handle:%p ref:%" PRId64 ", head:%d %p body:%d %p",
-         pQueue->items, headLen, pHead, bodyLen, pBody);
+         pQueue->name, pos, ftype, pQueue->items, (void *)handle, handleRef, headLen, pHead, bodyLen, pBody);
   return 0;
 }
 
@@ -455,25 +454,28 @@ void taosProcCleanup(SProcObj *pProc) {
 }
 
 int32_t taosProcPutToChildQ(SProcObj *pProc, const void *pHead, int16_t headLen, const void *pBody, int32_t bodyLen,
-                            void *handle, int64_t handleRef, EProcFuncType ftype) {
+                            void *handle, int64_t ref, EProcFuncType ftype) {
   if (ftype != PROC_FUNC_REQ) {
     terrno = TSDB_CODE_INVALID_PARA;
     return -1;
   }
-  return taosProcQueuePush(pProc, pProc->pChildQueue, pHead, headLen, pBody, bodyLen, (int64_t)handle, handleRef,
+  return taosProcQueuePush(pProc, pProc->pChildQueue, pHead, headLen, pBody, bodyLen, (int64_t)handle, ref, ftype);
-                           ftype);
 }
 
 int64_t taosProcRemoveHandle(SProcObj *pProc, void *handle) {
   int64_t h = (int64_t)handle;
   taosThreadMutexLock(&pProc->pChildQueue->mutex);
 
-  int64_t *handleRef = taosHashGet(pProc->hash, &h, sizeof(int64_t));
+  int64_t *pRef = taosHashGet(pProc->hash, &h, sizeof(int64_t));
+  int64_t  ref = 0;
+  if (pRef != NULL) {
+    ref = *pRef;
+  }
+
   taosHashRemove(pProc->hash, &h, sizeof(int64_t));
   taosThreadMutexUnlock(&pProc->pChildQueue->mutex);
 
-  if (handleRef == NULL) return 0;
+  return ref;
-  return *handleRef;
 }
 
 void taosProcCloseHandles(SProcObj *pProc, void (*HandleFp)(void *handle)) {

tests/script/api/batchprepare.c

@@ -11,7 +11,8 @@
 
 int32_t shortColList[] = {TSDB_DATA_TYPE_TIMESTAMP, TSDB_DATA_TYPE_INT};
 int32_t fullColList[] = {TSDB_DATA_TYPE_TIMESTAMP, TSDB_DATA_TYPE_BOOL, TSDB_DATA_TYPE_TINYINT, TSDB_DATA_TYPE_UTINYINT, TSDB_DATA_TYPE_SMALLINT, TSDB_DATA_TYPE_USMALLINT, TSDB_DATA_TYPE_INT, TSDB_DATA_TYPE_UINT, TSDB_DATA_TYPE_BIGINT, TSDB_DATA_TYPE_UBIGINT, TSDB_DATA_TYPE_FLOAT, TSDB_DATA_TYPE_DOUBLE, TSDB_DATA_TYPE_BINARY, TSDB_DATA_TYPE_NCHAR};
-int32_t bindColTypeList[] = {TSDB_DATA_TYPE_TIMESTAMP};
+int32_t bindColTypeList[] = {TSDB_DATA_TYPE_TIMESTAMP, TSDB_DATA_TYPE_NCHAR, TSDB_DATA_TYPE_BOOL};
+int32_t optrIdxList[] = {2, 11, 6};
 
 typedef struct {
   char*   oper;
@@ -32,7 +33,7 @@ OperInfo operInfo[] = {
   {"like",     2, false},  
   {"not like", 2, false},  
   {"match",    2, false},  
-  {"nmake",    2, false},  
+  {"nmatch",   2, false},  
 };
 
 int32_t operatorList[] = {0, 1, 2, 3, 4, 5, 6, 7};
@@ -139,9 +140,7 @@ CaseCfg gCase[] = {
   {"insert:MPME1-C012", tListLen(fullColList), fullColList, TTYPE_INSERT, false, false, insertMPMETest1, 10, 10, 2, 12, 0, 1, -1},
 
   // 22
-  //{"query:SUBT-FULL", tListLen(fullColList), fullColList, TTYPE_QUERY, false, false, querySUBTTest1, 10, 10, 1, 3, 0, 1, 2},
+  {"query:SUBT-FULL", tListLen(fullColList), fullColList, TTYPE_QUERY, false, false, querySUBTTest1, 10, 10, 1, 3, 0, 1, 2},
-
-  {"query:SUBT-FULL", tListLen(fullColList), fullColList, TTYPE_QUERY, false, false, querySUBTTest1, 1, 10, 1, 3, 0, 1, 2},
 
 };
 
@@ -161,6 +160,8 @@ typedef struct {
   int32_t  bindRowNum;           //row num for once bind
   int32_t  bindColTypeNum;
   int32_t* bindColTypeList;
+  int32_t  optrIdxListNum;
+  int32_t* optrIdxList;
   int32_t  runTimes;
   int32_t  caseIdx;              // static case idx
   int32_t  caseNum;              // num in static case list
@@ -178,8 +179,10 @@ CaseCtrl gCaseCtrl = {
   .rowNum = 0,
   .bindColNum = 0,
   .bindRowNum = 0,
-//  .bindColTypeNum = 0,
+  .bindColTypeNum = 0,
-//  .bindColTypeList = NULL,
+  .bindColTypeList = NULL,
+  .optrIdxListNum = 0,
+  .optrIdxList = NULL,
   .checkParamNum = false,
   .printRes = true,
   .runTimes = 0,
@@ -188,8 +191,11 @@ CaseCtrl gCaseCtrl = {
   .caseRunIdx = -1,
 //  .caseRunNum = -1,
 
-  .bindColTypeNum = tListLen(bindColTypeList),
+
-  .bindColTypeList = bindColTypeList,
+//  .optrIdxListNum = tListLen(optrIdxList),
+//  .optrIdxList = optrIdxList,
+//  .bindColTypeNum = tListLen(bindColTypeList),
+//  .bindColTypeList = bindColTypeList,
   .caseIdx = 22,
   .caseNum = 1,
   .caseRunNum = 1,
@@ -210,10 +216,10 @@ CaseCtrl gCaseCtrl = {
   .checkParamNum = false,
   .printRes = true,
   .runTimes = 0,
-  .caseIdx = -1,
+  .caseIdx = 2,
-  .caseNum = -1,
+  .caseNum = 1,
   .caseRunIdx = -1,
-  .caseRunNum = -1,
+  .caseRunNum = 1,
 };
 
 #endif
@@ -318,7 +324,7 @@ void generateInsertSQL(BindData *data) {
           len += sprintf(data->sql + len, "ubigdata");
           break;
         default:
-          printf("invalid col type:%d", data->pBind[c].buffer_type);
+          printf("!!!invalid col type:%d", data->pBind[c].buffer_type);
           exit(1);
       }
     }
@@ -336,19 +342,23 @@ void generateInsertSQL(BindData *data) {
   len += sprintf(data->sql + len, ")");
 
   if (gCaseCtrl.printStmtSql) {
-    printf("SQL: %s\n", data->sql);
+    printf("\tSQL: %s\n", data->sql);
   }  
 }
 
-void bpAppendOperatorParam(BindData *data, int32_t *len, int32_t dataType) {
+void bpAppendOperatorParam(BindData *data, int32_t *len, int32_t dataType, int32_t idx) {
   OperInfo *pInfo = NULL;
-  
-  if (TSDB_DATA_TYPE_VARCHAR == dataType || TSDB_DATA_TYPE_NCHAR == dataType) {
-    pInfo = &operInfo[varoperatorList[rand() % tListLen(varoperatorList)]];
-  } else {
-    pInfo = &operInfo[operatorList[rand() % tListLen(operatorList)]];
-  }
 
+  if (gCaseCtrl.optrIdxListNum > 0) {
+    pInfo = &operInfo[gCaseCtrl.optrIdxList[idx]];
+  } else {
+    if (TSDB_DATA_TYPE_VARCHAR == dataType || TSDB_DATA_TYPE_NCHAR == dataType) {
+      pInfo = &operInfo[varoperatorList[rand() % tListLen(varoperatorList)]];
+    } else {
+      pInfo = &operInfo[operatorList[rand() % tListLen(operatorList)]];
+    }
+  }
+  
   switch (pInfo->paramNum) {
     case 2:
       if (pInfo->enclose) {
@@ -358,7 +368,7 @@ void bpAppendOperatorParam(BindData *data, int32_t *len, int32_t dataType) {
       }
       break;
     default:
-      printf("invalid paramNum:%d\n", pInfo->paramNum);
+      printf("!!!invalid paramNum:%d\n", pInfo->paramNum);
       exit(1);
   }
 }
@@ -414,16 +424,16 @@ void generateQuerySQL(BindData *data, int32_t tblIdx) {
           len += sprintf(data->sql + len, "ubigdata");
           break;
         default:
-          printf("invalid col type:%d", data->pBind[c].buffer_type);
+          printf("!!!invalid col type:%d", data->pBind[c].buffer_type);
           exit(1);
       }
       
-      bpAppendOperatorParam(data, &len, data->pBind[c].buffer_type);
+      bpAppendOperatorParam(data, &len, data->pBind[c].buffer_type, c);
     }
   }
 
   if (gCaseCtrl.printStmtSql) {
-    printf("SQL: %s\n", data->sql);
+    printf("\tSTMT SQL: %s\n", data->sql);
   }  
 }
 
@@ -551,7 +561,7 @@ int32_t prepareColData(BindData *data, int32_t bindIdx, int32_t rowIdx, int32_t
       data->pBind[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL;
       break;
     default:
-      printf("invalid col type:%d", dataType);
+      printf("!!!invalid col type:%d", dataType);
       exit(1);
   }
 
@@ -709,7 +719,7 @@ void bpFetchRows(TAOS_RES *result, bool printr, int32_t *rows) {
     if (printr) {
       memset(temp, 0, sizeof(temp));
       taos_print_row(temp, row, fields, num_fields);
-      printf("[%s]\n", temp);
+      printf("\t[%s]\n", temp);
     }
   }
 }
@@ -718,7 +728,7 @@ void bpExecQuery(TAOS    * taos, char* sql, bool printr, int32_t *rows) {
   TAOS_RES *result = taos_query(taos, sql);
   int code = taos_errno(result);
   if (code != 0) {
-    printf("failed to query table, reason:%s\n", taos_errstr(result));
+    printf("!!!failed to query table, reason:%s\n", taos_errstr(result));
     taos_free_result(result);
     exit(1);
   }
@@ -791,7 +801,7 @@ int32_t bpAppendValueString(char *buf, int type, void *value, int32_t valueLen,
       break;
 
     default:
-      printf("invalid data type:%d\n", type);
+      printf("!!!invalid data type:%d\n", type);
       exit(1);
   }
 }
@@ -803,13 +813,13 @@ int32_t bpBindParam(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind) {
   if (gCurCase->bindRowNum > 1) {
     if (0 == (n++%2)) {
       if (taos_stmt_bind_param_batch(stmt, bind)) {
-        printf("taos_stmt_bind_param_batch error:%s\n", taos_stmt_errstr(stmt));
+        printf("!!!taos_stmt_bind_param_batch error:%s\n", taos_stmt_errstr(stmt));
         exit(1);
       }
     } else {
       for (int32_t i = 0; i < gCurCase->bindColNum; ++i) {
         if (taos_stmt_bind_single_param_batch(stmt, bind++, i)) {
-          printf("taos_stmt_bind_single_param_batch error:%s\n", taos_stmt_errstr(stmt));
+          printf("!!!taos_stmt_bind_single_param_batch error:%s\n", taos_stmt_errstr(stmt));
           exit(1);
         }
       }
@@ -817,12 +827,12 @@ int32_t bpBindParam(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind) {
   } else {
     if (0 == (n++%2)) {
       if (taos_stmt_bind_param_batch(stmt, bind)) {
-        printf("taos_stmt_bind_param_batch error:%s\n", taos_stmt_errstr(stmt));
+        printf("!!!taos_stmt_bind_param_batch error:%s\n", taos_stmt_errstr(stmt));
         exit(1);
       }
     } else {
       if (taos_stmt_bind_param(stmt, bind)) {
-        printf("taos_stmt_bind_param error:%s\n", taos_stmt_errstr(stmt));
+        printf("!!!taos_stmt_bind_param error:%s\n", taos_stmt_errstr(stmt));
         exit(1);
       }
     }
@@ -834,12 +844,12 @@ int32_t bpBindParam(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind) {
 void bpCheckIsInsert(TAOS_STMT *stmt, int32_t insert) {
   int32_t isInsert = 0;
   if (taos_stmt_is_insert(stmt, &isInsert)) {
-    printf("taos_stmt_is_insert error:%s\n", taos_stmt_errstr(stmt));
+    printf("!!!taos_stmt_is_insert error:%s\n", taos_stmt_errstr(stmt));
     exit(1);
   }
 
   if (insert != isInsert) {
-    printf("is insert failed\n");
+    printf("!!!is insert failed\n");
     exit(1);
   }
 }
@@ -847,12 +857,12 @@ void bpCheckIsInsert(TAOS_STMT *stmt, int32_t insert) {
 void bpCheckParamNum(TAOS_STMT *stmt) {
   int32_t num = 0;
   if (taos_stmt_num_params(stmt, &num)) {
-    printf("taos_stmt_num_params error:%s\n", taos_stmt_errstr(stmt));
+    printf("!!!taos_stmt_num_params error:%s\n", taos_stmt_errstr(stmt));
     exit(1);
   }
 
   if (gCurCase->bindColNum != num) {
-    printf("is insert failed\n");
+    printf("!!!is insert failed\n");
     exit(1);
   }
 }
@@ -861,7 +871,7 @@ void bpCheckAffectedRows(TAOS_STMT *stmt, int32_t times) {
   int32_t rows = taos_stmt_affected_rows(stmt);
   int32_t insertNum = gCurCase->rowNum * gCurCase->tblNum * times;
   if (insertNum != rows) {
-    printf("affected rows %d mis-match with insert num %d\n", rows, insertNum);
+    printf("!!!affected rows %d mis-match with insert num %d\n", rows, insertNum);
     exit(1);
   }
 }
@@ -869,7 +879,7 @@ void bpCheckAffectedRows(TAOS_STMT *stmt, int32_t times) {
 void bpCheckAffectedRowsOnce(TAOS_STMT *stmt, int32_t expectedNum) {
   int32_t rows = taos_stmt_affected_rows_once(stmt);
   if (expectedNum != rows) {
-    printf("affected rows %d mis-match with expected num %d\n", rows, expectedNum);
+    printf("!!!affected rows %d mis-match with expected num %d\n", rows, expectedNum);
     exit(1);
   }
 }
@@ -904,16 +914,16 @@ void bpCheckQueryResult(TAOS_STMT *stmt, TAOS *taos, char *stmtSql, TAOS_MULTI_B
   }
 
   if (gCaseCtrl.printQuerySql) {
-    printf("Query SQL: %s\n", sql);
+    printf("\tQuery SQL: %s\n", sql);
   }
 
   bpExecQuery(taos, sql, gCaseCtrl.printRes, &sqlResNum);
   if (sqlResNum != stmtResNum) {
-    printf("sql res num %d mis-match stmt res num %d\n", sqlResNum, stmtResNum);
+    printf("!!!sql res num %d mis-match stmt res num %d\n", sqlResNum, stmtResNum);
     exit(1);
   }
 
-  printf("sql res num match stmt res num %d\n", stmtResNum);
+  printf("***sql res num match stmt res num %d\n", stmtResNum);
 }
 
 /* prepare [settbname [bind add]] exec */
@@ -923,7 +933,7 @@ int insertMBSETest1(TAOS_STMT *stmt, TAOS *taos) {
 
   int code = taos_stmt_prepare(stmt, data.sql, 0);
   if (code != 0){
-    printf("failed to execute taos_stmt_prepare. error:%s\n", taos_stmt_errstr(stmt));
+    printf("!!!failed to execute taos_stmt_prepare. error:%s\n", taos_stmt_errstr(stmt));
     exit(1);
   }
 
@@ -936,7 +946,7 @@ int insertMBSETest1(TAOS_STMT *stmt, TAOS *taos) {
       sprintf(buf, "t%d", t);
       code = taos_stmt_set_tbname(stmt, buf);
       if (code != 0){
-        printf("taos_stmt_set_tbname error:%s\n", taos_stmt_errstr(stmt));
+        printf("!!!taos_stmt_set_tbname error:%s\n", taos_stmt_errstr(stmt));
         exit(1);
       }  
     }
@@ -951,14 +961,14 @@ int insertMBSETest1(TAOS_STMT *stmt, TAOS *taos) {
       }
       
       if (taos_stmt_add_batch(stmt)) {
-        printf("taos_stmt_add_batch error:%s\n", taos_stmt_errstr(stmt));
+        printf("!!!taos_stmt_add_batch error:%s\n", taos_stmt_errstr(stmt));
         exit(1);
       }
     }
   }
 
   if (taos_stmt_execute(stmt) != 0) {
-    printf("taos_stmt_execute error:%s\n", taos_stmt_errstr(stmt));
+    printf("!!!taos_stmt_execute error:%s\n", taos_stmt_errstr(stmt));
     exit(1);
   }
 
@@ -978,7 +988,7 @@ int insertMBSETest2(TAOS_STMT *stmt, TAOS *taos) {
 
   int code = taos_stmt_prepare(stmt, data.sql, 0);
   if (code != 0){
-    printf("failed to execute taos_stmt_prepare. error:%s\n", taos_stmt_errstr(stmt));
+    printf("!!!failed to execute taos_stmt_prepare. error:%s\n", taos_stmt_errstr(stmt));
     exit(1);
   }
 
@@ -993,7 +1003,7 @@ int insertMBSETest2(TAOS_STMT *stmt, TAOS *taos) {
         sprintf(buf, "t%d", t);
         code = taos_stmt_set_tbname(stmt, buf);
         if (code != 0){
-          printf("taos_stmt_set_tbname error:%s\n", taos_stmt_errstr(stmt));
+          printf("!!!taos_stmt_set_tbname error:%s\n", taos_stmt_errstr(stmt));
           exit(1);
         }  
       }
@@ -1007,14 +1017,14 @@ int insertMBSETest2(TAOS_STMT *stmt, TAOS *taos) {
       }
     
       if (taos_stmt_add_batch(stmt)) {
-        printf("taos_stmt_add_batch error:%s\n", taos_stmt_errstr(stmt));
+        printf("!!!taos_stmt_add_batch error:%s\n", taos_stmt_errstr(stmt));
         exit(1);
       }
     }
   }
 
   if (taos_stmt_execute(stmt) != 0) {
-    printf("taos_stmt_execute error:%s\n", taos_stmt_errstr(stmt));
+    printf("!!!taos_stmt_execute error:%s\n", taos_stmt_errstr(stmt));
     exit(1);
   }
 
@@ -1033,7 +1043,7 @@ int insertMBMETest1(TAOS_STMT *stmt, TAOS *taos) {
   
   int code = taos_stmt_prepare(stmt, data.sql, 0);
   if (code != 0){
-    printf("failed to execute taos_stmt_prepare. error:%s\n", taos_stmt_errstr(stmt));
+    printf("!!!failed to execute taos_stmt_prepare. error:%s\n", taos_stmt_errstr(stmt));
     exit(1);
   }
 
@@ -1046,7 +1056,7 @@ int insertMBMETest1(TAOS_STMT *stmt, TAOS *taos) {
       sprintf(buf, "t%d", t);
       code = taos_stmt_set_tbname(stmt, buf);
       if (code != 0){
-        printf("taos_stmt_set_tbname error:%s\n", taos_stmt_errstr(stmt));
+        printf("!!!taos_stmt_set_tbname error:%s\n", taos_stmt_errstr(stmt));
         exit(1);
       }  
     }
@@ -1061,13 +1071,13 @@ int insertMBMETest1(TAOS_STMT *stmt, TAOS *taos) {
       }
       
       if (taos_stmt_add_batch(stmt)) {
-        printf("taos_stmt_add_batch error:%s\n", taos_stmt_errstr(stmt));
+        printf("!!!taos_stmt_add_batch error:%s\n", taos_stmt_errstr(stmt));
         exit(1);
       }
     }
 
     if (taos_stmt_execute(stmt) != 0) {
-      printf("taos_stmt_execute error:%s\n", taos_stmt_errstr(stmt));
+      printf("!!!taos_stmt_execute error:%s\n", taos_stmt_errstr(stmt));
       exit(1);
     }
   }
@@ -1087,7 +1097,7 @@ int insertMBMETest2(TAOS_STMT *stmt, TAOS *taos) {
 
   int code = taos_stmt_prepare(stmt, data.sql, 0);
   if (code != 0){
-    printf("failed to execute taos_stmt_prepare. error:%s\n", taos_stmt_errstr(stmt));
+    printf("!!!failed to execute taos_stmt_prepare. error:%s\n", taos_stmt_errstr(stmt));
     exit(1);
   }
 
@@ -1100,7 +1110,7 @@ int insertMBMETest2(TAOS_STMT *stmt, TAOS *taos) {
       sprintf(buf, "t%d", t);
       code = taos_stmt_set_tbname(stmt, buf);
       if (code != 0){
-        printf("taos_stmt_set_tbname error:%s\n", taos_stmt_errstr(stmt));
+        printf("!!!taos_stmt_set_tbname error:%s\n", taos_stmt_errstr(stmt));
         exit(1);
       }  
     }
@@ -1115,12 +1125,12 @@ int insertMBMETest2(TAOS_STMT *stmt, TAOS *taos) {
       }
     
       if (taos_stmt_add_batch(stmt)) {
-        printf("taos_stmt_add_batch error:%s\n", taos_stmt_errstr(stmt));
+        printf("!!!taos_stmt_add_batch error:%s\n", taos_stmt_errstr(stmt));
         exit(1);
       }
 
       if (taos_stmt_execute(stmt) != 0) {
-        printf("taos_stmt_execute error:%s\n", taos_stmt_errstr(stmt));
+        printf("!!!taos_stmt_execute error:%s\n", taos_stmt_errstr(stmt));
         exit(1);
       }
     }
@@ -1141,7 +1151,7 @@ int insertMBMETest3(TAOS_STMT *stmt, TAOS *taos) {
 
   int code = taos_stmt_prepare(stmt, data.sql, 0);
   if (code != 0){
-    printf("failed to execute taos_stmt_prepare. error:%s\n", taos_stmt_errstr(stmt));
+    printf("!!!failed to execute taos_stmt_prepare. error:%s\n", taos_stmt_errstr(stmt));
     exit(1);
   }
 
@@ -1154,7 +1164,7 @@ int insertMBMETest3(TAOS_STMT *stmt, TAOS *taos) {
       sprintf(buf, "t%d", t);
       code = taos_stmt_set_tbname(stmt, buf);
       if (code != 0){
-        printf("taos_stmt_set_tbname error:%s\n", taos_stmt_errstr(stmt));
+        printf("!!!taos_stmt_set_tbname error:%s\n", taos_stmt_errstr(stmt));
         exit(1);
       }  
     }
@@ -1169,7 +1179,7 @@ int insertMBMETest3(TAOS_STMT *stmt, TAOS *taos) {
         sprintf(buf, "t%d", t);
         code = taos_stmt_set_tbname(stmt, buf);
         if (code != 0){
-          printf("taos_stmt_set_tbname error:%s\n", taos_stmt_errstr(stmt));
+          printf("!!!taos_stmt_set_tbname error:%s\n", taos_stmt_errstr(stmt));
           exit(1);
         }  
       }
@@ -1179,12 +1189,12 @@ int insertMBMETest3(TAOS_STMT *stmt, TAOS *taos) {
       }
       
       if (taos_stmt_add_batch(stmt)) {
-        printf("taos_stmt_add_batch error:%s\n", taos_stmt_errstr(stmt));
+        printf("!!!taos_stmt_add_batch error:%s\n", taos_stmt_errstr(stmt));
         exit(1);
       }
 
       if (taos_stmt_execute(stmt) != 0) {
-        printf("taos_stmt_execute error:%s\n", taos_stmt_errstr(stmt));
+        printf("!!!taos_stmt_execute error:%s\n", taos_stmt_errstr(stmt));
         exit(1);
       }
     }
@@ -1206,7 +1216,7 @@ int insertMBMETest4(TAOS_STMT *stmt, TAOS *taos) {
 
   int code = taos_stmt_prepare(stmt, data.sql, 0);
   if (code != 0){
-    printf("failed to execute taos_stmt_prepare. error:%s\n", taos_stmt_errstr(stmt));
+    printf("!!!failed to execute taos_stmt_prepare. error:%s\n", taos_stmt_errstr(stmt));
     exit(1);
   }
 
@@ -1221,7 +1231,7 @@ int insertMBMETest4(TAOS_STMT *stmt, TAOS *taos) {
         sprintf(buf, "t%d", t);
         code = taos_stmt_set_tbname(stmt, buf);
         if (code != 0){
-          printf("taos_stmt_set_tbname error:%s\n", taos_stmt_errstr(stmt));
+          printf("!!!taos_stmt_set_tbname error:%s\n", taos_stmt_errstr(stmt));
           exit(1);
         }  
       }
@@ -1235,12 +1245,12 @@ int insertMBMETest4(TAOS_STMT *stmt, TAOS *taos) {
       }
     
       if (taos_stmt_add_batch(stmt)) {
-        printf("taos_stmt_add_batch error:%s\n", taos_stmt_errstr(stmt));
+        printf("!!!taos_stmt_add_batch error:%s\n", taos_stmt_errstr(stmt));
         exit(1);
       }
 
       if (taos_stmt_execute(stmt) != 0) {
-        printf("taos_stmt_execute error:%s\n", taos_stmt_errstr(stmt));
+        printf("!!!taos_stmt_execute error:%s\n", taos_stmt_errstr(stmt));
         exit(1);
       }
     }
@@ -1264,7 +1274,7 @@ int insertMPMETest1(TAOS_STMT *stmt, TAOS *taos) {
 
     int code = taos_stmt_prepare(stmt, data.sql, 0);
     if (code != 0){
-      printf("failed to execute taos_stmt_prepare. error:%s\n", taos_stmt_errstr(stmt));
+      printf("!!!failed to execute taos_stmt_prepare. error:%s\n", taos_stmt_errstr(stmt));
       exit(1);
     }
 
@@ -1277,7 +1287,7 @@ int insertMPMETest1(TAOS_STMT *stmt, TAOS *taos) {
         sprintf(buf, "t%d", t);
         code = taos_stmt_set_tbname(stmt, buf);
         if (code != 0){
-          printf("taos_stmt_set_tbname error:%s\n", taos_stmt_errstr(stmt));
+          printf("!!!taos_stmt_set_tbname error:%s\n", taos_stmt_errstr(stmt));
           exit(1);
         }  
       }
@@ -1292,13 +1302,13 @@ int insertMPMETest1(TAOS_STMT *stmt, TAOS *taos) {
         }
         
         if (taos_stmt_add_batch(stmt)) {
-          printf("taos_stmt_add_batch error:%s\n", taos_stmt_errstr(stmt));
+          printf("!!!taos_stmt_add_batch error:%s\n", taos_stmt_errstr(stmt));
           exit(1);
         }
       }
 
       if (taos_stmt_execute(stmt) != 0) {
-        printf("taos_stmt_execute error:%s\n", taos_stmt_errstr(stmt));
+        printf("!!!taos_stmt_execute error:%s\n", taos_stmt_errstr(stmt));
         exit(1);
       }
     }
@@ -1328,7 +1338,7 @@ int querySUBTTest1(TAOS_STMT *stmt, TAOS *taos) {
 
     int code = taos_stmt_prepare(stmt, data.sql, 0);
     if (code != 0){
-      printf("failed to execute taos_stmt_prepare. error:%s\n", taos_stmt_errstr(stmt));
+      printf("!!!failed to execute taos_stmt_prepare. error:%s\n", taos_stmt_errstr(stmt));
       exit(1);
     }
 
@@ -1344,12 +1354,12 @@ int querySUBTTest1(TAOS_STMT *stmt, TAOS *taos) {
       }
       
       if (taos_stmt_add_batch(stmt)) {
-        printf("taos_stmt_add_batch error:%s\n", taos_stmt_errstr(stmt));
+        printf("!!!taos_stmt_add_batch error:%s\n", taos_stmt_errstr(stmt));
         exit(1);
       }
 
       if (taos_stmt_execute(stmt) != 0) {
-        printf("taos_stmt_execute error:%s\n", taos_stmt_errstr(stmt));
+        printf("!!!taos_stmt_execute error:%s\n", taos_stmt_errstr(stmt));
         exit(1);
       }
 
@@ -4249,10 +4259,10 @@ void prepareCheckResultImpl(TAOS     * taos, char *tname, bool printr, int expec
   
   if (rows == expected) {
     if (!silent) {
-      printf("%d rows are fetched as expected from %s\n", rows, tname);
+      printf("***%d rows are fetched as expected from %s\n", rows, tname);
     }
   } else {
-    printf("!!!expect %d rows, but %d rows are fetched from %s\n", expected, rows, tname);
+    printf("!!!expect rows %d mis-match rows %d fetched from %s\n", expected, rows, tname);
     exit(1);
   }
 }
@@ -4302,7 +4312,7 @@ int sql_perf1(TAOS     *taos) {
       result = taos_query(taos, sql[i]);
       int code = taos_errno(result);
       if (code != 0) {
-        printf("failed to query table, reason:%s\n", taos_errstr(result));
+        printf("%d failed to query table, reason:%s\n", taos_errstr(result));
         taos_free_result(result);
         exit(1);
     }
@@ -4539,7 +4549,7 @@ void generateCreateTableSQL(char *buf, int32_t tblIdx, int32_t colNum, int32_t *
   blen += sprintf(buf + blen, ")");
 
   if (gCaseCtrl.printCreateTblSql) {
-    printf("Create Table SQL:%s\n", buf);
+    printf("\tCreate Table SQL:%s\n", buf);
   }
 }
 
@@ -4553,7 +4563,7 @@ void prepare(TAOS     *taos, int32_t colNum, int32_t *colList, int prepareStb) {
   result = taos_query(taos, "create database demo keep 36500");
   code = taos_errno(result);
   if (code != 0) {
-    printf("failed to create database, reason:%s\n", taos_errstr(result));
+    printf("!!!failed to create database, reason:%s\n", taos_errstr(result));
     taos_free_result(result);
     exit(1);
   }
@@ -4570,7 +4580,7 @@ void prepare(TAOS     *taos, int32_t colNum, int32_t *colList, int prepareStb) {
       result = taos_query(taos, buf);
       code = taos_errno(result);
       if (code != 0) {
-        printf("failed to create table, reason:%s\n", taos_errstr(result));
+        printf("!!!failed to create table, reason:%s\n", taos_errstr(result));
         taos_free_result(result);
         exit(1);
       }
@@ -4583,7 +4593,7 @@ void prepare(TAOS     *taos, int32_t colNum, int32_t *colList, int prepareStb) {
     result = taos_query(taos, buf);
     code = taos_errno(result);
     if (code != 0) {
-      printf("failed to create table, reason:%s\n", taos_errstr(result));
+      printf("!!!failed to create table, reason:%s\n", taos_errstr(result));
       taos_free_result(result);
       exit(1);
     }
@@ -4654,7 +4664,7 @@ int32_t runCase(TAOS *taos, int32_t caseIdx, int32_t caseRunIdx, bool silent) {
    
     stmt = taos_stmt_init(taos);
     if (NULL == stmt) {
-      printf("taos_stmt_init failed, error:%s\n", taos_stmt_errstr(stmt));
+      printf("!!!taos_stmt_init failed, error:%s\n", taos_stmt_errstr(stmt));
       exit(1);
     }
   

tests/script/jenkins/basic.txt

@@ -66,10 +66,10 @@
 
 # --- stable
 ./test.sh -f tsim/stable/disk.sim
-#./test.sh -f tsim/stable/dnode3.sim
+./test.sh -f tsim/stable/dnode3.sim
 ./test.sh -f tsim/stable/metrics.sim
 ./test.sh -f tsim/stable/refcount.sim
-# ./test.sh -f tsim/stable/show.sim
+#./test.sh -f tsim/stable/show.sim
 ./test.sh -f tsim/stable/values.sim
 ./test.sh -f tsim/stable/vnode3.sim
 
@@ -81,7 +81,7 @@
 ./test.sh -f tsim/insert/backquote.sim -m
 ./test.sh -f tsim/parser/fourArithmetic-basic.sim -m
 ./test.sh -f tsim/query/interval-offset.sim -m
-#./test.sh -f tsim/tmq/basic3.sim -m
+./test.sh -f tsim/tmq/basic3.sim -m
 ./test.sh -f tsim/stable/vnode3.sim -m
 ./test.sh -f tsim/qnode/basic1.sim -m
 ./test.sh -f tsim/mnode/basic1.sim -m

tests/script/tsim/show/basic.sim

@@ -3,9 +3,6 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/deploy.sh -n dnode2 -i 2
 system sh/exec.sh -n dnode1 -s start
 system sh/exec.sh -n dnode2 -s start
-
-# after mnode support, del sleep 2000, and check dnode status
-sleep 2000
 sql connect
 
 #$loop_cnt = 0