Merge branch 'develop' into feature/wal

.appveyor.yml

+version: 1.0.{build}
+os: Visual Studio 2015
+environment:
+  matrix:
+    - ARCH: amd64
+
+clone_folder: c:\dev\TDengine
+clone_depth: 1
+
+init:
+  - call "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" %ARCH%
+
+before_build:
+  - cd c:\dev\TDengine
+  - md build
+
+build_script:
+  - cd build
+  - cmake -G "NMake Makefiles" ..
+  - nmake install
+
+notifications:
+- provider: Email
+  to:
+  - sangshuduo@gmail.com
+  on_build_success: true
+  on_build_failure: true
+  on_build_status_changed: true

.gitignore

@@ -12,6 +12,7 @@ rpms/
 mac/
 *.pyc
 *.tmp
+*.swp
 src/connector/nodejs/node_modules/
 src/connector/nodejs/out/
 tests/test/

.travis.yml

+#
+# Configuration
+#
+git:
+  depth: 1
+
+language: c
+
+compiler:
+  - clang
+  - gcc
+
+os:
+  - linux
+  - osx
+
+addons:
+  coverity_scan:
+
+    # GitHub project metadata
+    # ** specific to your project **
+    project:
+      name: TDengine
+      version: 2.x
+      description: TDengine
+
+    # Where email notification of build analysis results will be sent
+    notification_email: sdsang@taosdata.com
+
+    # Commands to prepare for build_command
+    # ** likely specific to your build **
+    build_command_prepend: cmake ..
+
+    # The command that will be added as an argument to "cov-build" to compile your project for analysis,
+    # ** likely specific to your build **
+    build_command: cmake --build .
+
+    # Pattern to match selecting branches that will run analysis. We recommend leaving this set to 'coverity_scan'.
+    # Take care in resource usage, and consider the build frequency allowances per
+    #   https://scan.coverity.com/faq#frequency
+    branch_pattern: coverity_scan
+
+before_script:
+  - mkdir build
+  - cd build
+
+script:
+  - cmake .. 
+  - cmake --build .
+
+#
+# Build Matrix
+#
+matrix:
+  - os: linux
+    addons:
+      apt:
+        packages:
+          - build-essential
+          - cmake
+
+  - os: osx
+    addons:
+      homebrew:
+        - cmake
+

README.md

+[![Build Status](https://travis-ci.org/taosdata/TDengine.svg?branch=master)](https://travis-ci.org/taosdata/TDengine)
+[![Build status](https://ci.appveyor.com/api/projects/status/kf3pwh2or5afsgl9/branch/master?svg=true)](https://ci.appveyor.com/project/sangshuduo/tdengine-2n8ge/branch/master)
+
 [![TDengine](TDenginelogo.png)](https://www.taosdata.com)
 
 # What is TDengine？

src/client/inc/tsclient.h

@@ -357,7 +357,6 @@ typedef struct SSqlObj {
   char              freed : 4;
   char              listed : 4;
   tsem_t            rspSem;
-  tsem_t            emptyRspSem;
   SSqlCmd           cmd;
   SSqlRes           res;
   uint8_t           numOfSubs;
@@ -409,7 +408,7 @@ int  tscProcessSql(SSqlObj *pSql);
 int  tscRenewMeterMeta(SSqlObj *pSql, char *tableId);
 void tscQueueAsyncRes(SSqlObj *pSql);
 
-void tscQueueAsyncError(void(*fp), void *param);
+void tscQueueAsyncError(void(*fp), void *param, int32_t code);
 
 int tscProcessLocalCmd(SSqlObj *pSql);
 int tscCfgDynamicOptions(char *msg);
@@ -450,7 +449,7 @@ void tscFreeSqlObj(SSqlObj *pObj);
 
 void tscCloseTscObj(STscObj *pObj);
 
-void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, void (*fp)(), void* param, const char* sqlstr, int32_t sqlLen);
+void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, void (*fp)(), void* param, const char* sqlstr, size_t sqlLen);
 
 void tscProcessMultiVnodesInsert(SSqlObj *pSql);
 void tscProcessMultiVnodesInsertFromFile(SSqlObj *pSql);

src/client/src/tscAsync.c

@@ -40,7 +40,7 @@ static void tscProcessAsyncRetrieveImpl(void *param, TAOS_RES *tres, int numOfRo
 static void tscAsyncFetchRowsProxy(void *param, TAOS_RES *tres, int numOfRows);
 static void tscAsyncFetchSingleRowProxy(void *param, TAOS_RES *tres, int numOfRows);
 
-void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, void (*fp)(), void* param, const char* sqlstr, int32_t sqlLen) {
+void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, void (*fp)(), void* param, const char* sqlstr, size_t sqlLen) {
   SSqlCmd *pCmd = &pSql->cmd;
   SSqlRes *pRes = &pSql->res;
   
@@ -51,17 +51,15 @@ void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, void (*fp)(), void* param, const
   
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, TSDB_DEFAULT_PAYLOAD_SIZE)) {
     tscError("failed to malloc payload");
-    tfree(pSql);
-    tscQueueAsyncError(fp, param);
+    tscQueueAsyncError(fp, param, TSDB_CODE_CLI_OUT_OF_MEMORY);
     return;
   }
   
-  pSql->sqlstr = malloc(sqlLen + 1);
+  pSql->sqlstr = realloc(pSql->sqlstr, sqlLen + 1);
   if (pSql->sqlstr == NULL) {
     tscError("%p failed to malloc sql string buffer", pSql);
-    tscQueueAsyncError(fp, param);
+    tscQueueAsyncError(fp, param, TSDB_CODE_CLI_OUT_OF_MEMORY);
     free(pCmd->payload);
-    free(pSql);
     return;
   }
   
@@ -75,7 +73,7 @@ void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, void (*fp)(), void* param, const
   if (code == TSDB_CODE_ACTION_IN_PROGRESS) return;
   
   if (code != TSDB_CODE_SUCCESS) {
-    pSql->res.code = (uint8_t)code;
+    pSql->res.code = code;
     tscQueueAsyncRes(pSql);
     return;
   }
@@ -88,15 +86,16 @@ void taos_query_a(TAOS *taos, const char *sqlstr, __async_cb_func_t fp, void *pa
   STscObj *pObj = (STscObj *)taos;
   if (pObj == NULL || pObj->signature != pObj) {
     tscError("bug!!! pObj:%p", pObj);
-    globalCode = TSDB_CODE_DISCONNECTED;
-    tscQueueAsyncError(fp, param);
+    terrno = TSDB_CODE_DISCONNECTED;
+    tscQueueAsyncError(fp, param, TSDB_CODE_DISCONNECTED);
     return;
   }
   
   int32_t sqlLen = strlen(sqlstr);
   if (sqlLen > tsMaxSQLStringLen) {
     tscError("sql string too long");
-    tscQueueAsyncError(fp, param);
+    terrno = TSDB_CODE_INVALID_SQL;
+    tscQueueAsyncError(fp, param, TSDB_CODE_INVALID_SQL);
     return;
   }
   
@@ -105,7 +104,8 @@ void taos_query_a(TAOS *taos, const char *sqlstr, __async_cb_func_t fp, void *pa
   SSqlObj *pSql = (SSqlObj *)calloc(1, sizeof(SSqlObj));
   if (pSql == NULL) {
     tscError("failed to malloc sqlObj");
-    tscQueueAsyncError(fp, param);
+    terrno = TSDB_CODE_CLI_OUT_OF_MEMORY;
+    tscQueueAsyncError(fp, param, TSDB_CODE_CLI_OUT_OF_MEMORY);
     return;
   }
   
@@ -170,7 +170,7 @@ static void tscProcessAsyncRetrieveImpl(void *param, TAOS_RES *tres, int numOfRo
       pRes->code = numOfRows;
     }
 
-    tscQueueAsyncError(pSql->fetchFp, param);
+    tscQueueAsyncError(pSql->fetchFp, param, pRes->code);
     return;
   }
 
@@ -200,8 +200,8 @@ void taos_fetch_rows_a(TAOS_RES *taosa, void (*fp)(void *, TAOS_RES *, int), voi
   SSqlObj *pSql = (SSqlObj *)taosa;
   if (pSql == NULL || pSql->signature != pSql) {
     tscError("sql object is NULL");
-    globalCode = TSDB_CODE_DISCONNECTED;
-    tscQueueAsyncError(fp, param);
+//    globalCode = TSDB_CODE_DISCONNECTED;
+    tscQueueAsyncError(fp, param, TSDB_CODE_DISCONNECTED);
     return;
   }
 
@@ -210,7 +210,7 @@ void taos_fetch_rows_a(TAOS_RES *taosa, void (*fp)(void *, TAOS_RES *, int), voi
 
   if (pRes->qhandle == 0) {
     tscError("qhandle is NULL");
-    tscQueueAsyncError(fp, param);
+    tscQueueAsyncError(fp, param, TSDB_CODE_INVALID_QHANDLE);
     return;
   }
 
@@ -232,8 +232,8 @@ void taos_fetch_row_a(TAOS_RES *taosa, void (*fp)(void *, TAOS_RES *, TAOS_ROW),
   SSqlObj *pSql = (SSqlObj *)taosa;
   if (pSql == NULL || pSql->signature != pSql) {
     tscError("sql object is NULL");
-    globalCode = TSDB_CODE_DISCONNECTED;
-    tscQueueAsyncError(fp, param);
+//    globalCode = TSDB_CODE_DISCONNECTED;
+    tscQueueAsyncError(fp, param, TSDB_CODE_DISCONNECTED);
     return;
   }
 
@@ -242,7 +242,7 @@ void taos_fetch_row_a(TAOS_RES *taosa, void (*fp)(void *, TAOS_RES *, TAOS_ROW),
 
   if (pRes->qhandle == 0) {
     tscError("qhandle is NULL");
-    tscQueueAsyncError(fp, param);
+    tscQueueAsyncError(fp, param, TSDB_CODE_INVALID_QHANDLE);
     return;
   }
 
@@ -331,7 +331,7 @@ void tscProcessAsyncRes(SSchedMsg *pMsg) {
 
   // pCmd may be released, so cache pCmd->command
   int cmd = pCmd->command;
-  int code = pRes->code ? -pRes->code : pRes->numOfRows;
+  int code = pRes->code;
 
   // in case of async insert, restore the user specified callback function
   bool shouldFree = tscShouldFreeAsyncSqlObj(pSql);
@@ -349,18 +349,20 @@ void tscProcessAsyncRes(SSchedMsg *pMsg) {
   }
 }
 
-void tscProcessAsyncError(SSchedMsg *pMsg) {
+static void tscProcessAsyncError(SSchedMsg *pMsg) {
   void (*fp)() = pMsg->ahandle;
-
-  (*fp)(pMsg->thandle, NULL, -1);
+  (*fp)(pMsg->thandle, NULL, *(int32_t*)pMsg->msg);
 }
 
-void tscQueueAsyncError(void(*fp), void *param) {
+void tscQueueAsyncError(void(*fp), void *param, int32_t code) {
+  int32_t* c = malloc(sizeof(int32_t));
+  *c = code;
+  
   SSchedMsg schedMsg;
   schedMsg.fp = tscProcessAsyncError;
   schedMsg.ahandle = fp;
   schedMsg.thandle = param;
-  schedMsg.msg = NULL;
+  schedMsg.msg = c;
   taosScheduleTask(tscQhandle, &schedMsg);
 }
 
@@ -412,7 +414,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
     if (code != 0) {
       pRes->code = code;
       tscTrace("%p failed to renew tableMeta", pSql);
-      tsem_post(&pSql->rspSem);
+//      tsem_post(&pSql->rspSem);
     } else {
       tscTrace("%p renew tableMeta successfully, command:%d, code:%d, retry:%d",
           pSql, pSql->cmd.command, pSql->res.code, pSql->retry);
@@ -424,7 +426,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
       code = tscSendMsgToServer(pSql);
       if (code != 0) {
         pRes->code = code;
-        tsem_post(&pSql->rspSem);
+//        tsem_post(&pSql->rspSem);
       }
     }
 

src/client/src/tscParseInsert.c

@@ -1291,9 +1291,18 @@ int tsParseInsertSql(SSqlObj *pSql) {
   return doParseInsertSql(pSql, pSql->sqlstr + index);
 }
 
-int tsParseSql(SSqlObj *pSql, bool multiVnodeInsertion) {
+int tsParseSql(SSqlObj *pSql, bool initialParse) {
   int32_t ret = TSDB_CODE_SUCCESS;
-  tscTrace("continue parse sql: %s", pSql->asyncTblPos);
+  
+  if (initialParse) {
+    char* p = pSql->sqlstr;
+    pSql->sqlstr = NULL;
+    
+    tscFreeSqlObjPartial(pSql);
+    pSql->sqlstr = p;
+  } else {
+    tscTrace("continue parse sql: %s", pSql->asyncTblPos);
+  }
   
   if (tscIsInsertOrImportData(pSql->sqlstr)) {
     /*
@@ -1301,18 +1310,19 @@ int tsParseSql(SSqlObj *pSql, bool multiVnodeInsertion) {
      * Set the fp before parse the sql string, in case of getmetermeta failed, in which
      * the error handle callback function can rightfully restore the user defined function (fp)
      */
-    if (pSql->fp != NULL && multiVnodeInsertion) {
-      pSql->fetchFp = pSql->fp;
-
+    if (initialParse) {
       // replace user defined callback function with multi-insert proxy function
+      pSql->fetchFp = pSql->fp;
       pSql->fp = (void(*)())tscHandleMultivnodeInsert;
     }
 
     ret = tsParseInsertSql(pSql);
   } else {
     ret = tscAllocPayload(&pSql->cmd, TSDB_DEFAULT_PAYLOAD_SIZE);
-    if (TSDB_CODE_SUCCESS != ret) return ret;
-
+    if (TSDB_CODE_SUCCESS != ret) {
+      return ret;
+    }
+    
     SSqlInfo SQLInfo = {0};
     tSQLParse(&SQLInfo, pSql->sqlstr);
 
@@ -1443,57 +1453,6 @@ static int tscInsertDataFromFile(SSqlObj *pSql, FILE *fp, char *tmpTokenBuf) {
   return numOfRows;
 }
 
-/* multi-vnodes insertion in sync query model
- *
- * modify history
- * 2019.05.10 lihui
- * Remove the code for importing records from files
- */
-void tscProcessMultiVnodesInsert(SSqlObj *pSql) {
-  SSqlCmd *pCmd = &pSql->cmd;
-
-  // not insert/import, return directly
-  if (pCmd->command != TSDB_SQL_INSERT) {
-    return;
-  }
-
-  // SSqlCmd may have been released
-  if (pCmd->pDataBlocks == NULL) {
-    return;
-  }
-
-  STableDataBlocks *pDataBlock = NULL;
-  STableMetaInfo *  pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
-  assert(pCmd->numOfClause == 1);
-  
-  int32_t           code = TSDB_CODE_SUCCESS;
-
-  /* the first block has been sent to server in processSQL function */
-  assert(pTableMetaInfo->vnodeIndex >= 1 && pCmd->pDataBlocks != NULL);
-
-  if (pTableMetaInfo->vnodeIndex < pCmd->pDataBlocks->nSize) {
-    SDataBlockList *pDataBlocks = pCmd->pDataBlocks;
-
-    for (int32_t i = pTableMetaInfo->vnodeIndex; i < pDataBlocks->nSize; ++i) {
-      pDataBlock = pDataBlocks->pData[i];
-      if (pDataBlock == NULL) {
-        continue;
-      }
-
-      if ((code = tscCopyDataBlockToPayload(pSql, pDataBlock)) != TSDB_CODE_SUCCESS) {
-        tscTrace("%p build submit data block failed, vnodeIdx:%d, total:%d", pSql, pTableMetaInfo->vnodeIndex,
-                 pDataBlocks->nSize);
-        continue;
-      }
-
-      tscProcessSql(pSql);
-    }
-  }
-
-  // all data have been submit to vnode, release data blocks
-  pCmd->pDataBlocks = tscDestroyBlockArrayList(pCmd->pDataBlocks);
-}
-
 // multi-vnodes insertion in sync query model
 void tscProcessMultiVnodesInsertFromFile(SSqlObj *pSql) {
   SSqlCmd *pCmd = &pSql->cmd;

src/client/src/tscPrepare.c

@@ -488,7 +488,6 @@ TAOS_STMT* taos_stmt_init(TAOS* taos) {
   }
 
   tsem_init(&pSql->rspSem, 0, 0);
-  tsem_init(&pSql->emptyRspSem, 0, 1);
   pSql->signature = pSql;
   pSql->pTscObj = pObj;
 

src/client/src/tscSQLParser.c

@@ -117,7 +117,7 @@ static int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo);
 static int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo);
 static int32_t doCheckForQuery(SSqlObj* pSql, SQuerySQL* pQuerySql, int32_t index);
 
-static int32_t tSQLBinaryExprCreateFromSqlExpr(tSQLSyntaxNode **pExpr, tSQLExpr* pAst, int32_t* num,
+static int32_t convertSyntaxTreeToExprTree(tExprNode **pExpr, tSQLExpr* pAst, int32_t* num,
     SColIndexEx** pColIndex, SSqlExprInfo* pExprInfo);
 
 /*
@@ -215,7 +215,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
   if (pQueryInfo->numOfTables == 0) {
     pTableMetaInfo = tscAddEmptyMetaInfo(pQueryInfo);
   } else {
-    pTableMetaInfo = &pQueryInfo->pTableMetaInfo[0];
+    pTableMetaInfo = pQueryInfo->pTableMetaInfo[0];
   }
 
   pCmd->command = pInfo->type;
@@ -497,6 +497,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
         }
 
       } else if (pCreateTable->type == TSQL_CREATE_TABLE_FROM_STABLE) {
+        assert(pCmd->numOfCols == 0);
         if ((code = doCheckForCreateFromStable(pSql, pInfo)) != TSDB_CODE_SUCCESS) {
           return code;
         }
@@ -1208,12 +1209,12 @@ int32_t parseSelectClause(SSqlCmd* pCmd, int32_t clauseIndex, tSQLExprList* pSel
 
           SSqlBinaryExprInfo* pBinExprInfo = &pFuncExpr->binExprInfo;
           
-          tSQLSyntaxNode* pNode = NULL;
+          tExprNode* pNode = NULL;
           SColIndexEx* pColIndex = NULL;
           
-          int32_t ret = tSQLBinaryExprCreateFromSqlExpr(&pNode, pItem->pNode, &pBinExprInfo->numOfCols, &pColIndex, &pQueryInfo->exprsInfo);
+          int32_t ret = convertSyntaxTreeToExprTree(&pNode, pItem->pNode, &pBinExprInfo->numOfCols, &pColIndex, &pQueryInfo->exprsInfo);
           if (ret != TSDB_CODE_SUCCESS) {
-            tSQLBinaryExprDestroy(&pNode, NULL);
+            tExprTreeDestroy(&pNode, NULL);
             return invalidSqlErrMsg(pQueryInfo->msg, "invalid expression in select clause");
           }
           
@@ -5807,20 +5808,20 @@ int32_t doCheckForQuery(SSqlObj* pSql, SQuerySQL* pQuerySql, int32_t index) {
   return TSDB_CODE_SUCCESS;  // Does not build query message here
 }
 
-static int32_t tSQLBinaryExprCreateFromSqlExpr(tSQLSyntaxNode **pExpr, tSQLExpr* pAst, int32_t* num,
+static int32_t convertSyntaxTreeToExprTree(tExprNode **pExpr, tSQLExpr* pAst, int32_t* num,
     SColIndexEx** pColIndex, SSqlExprInfo* pExprInfo) {
-  tSQLSyntaxNode* pLeft = NULL;
-  tSQLSyntaxNode* pRight= NULL;
+  tExprNode* pLeft = NULL;
+  tExprNode* pRight= NULL;
   
   if (pAst->pLeft != NULL) {
-    int32_t ret = tSQLBinaryExprCreateFromSqlExpr(&pLeft, pAst->pLeft, num, pColIndex, pExprInfo);
+    int32_t ret = convertSyntaxTreeToExprTree(&pLeft, pAst->pLeft, num, pColIndex, pExprInfo);
     if (ret != TSDB_CODE_SUCCESS) {
       return ret;
     }
   }
   
   if (pAst->pRight != NULL) {
-    int32_t ret = tSQLBinaryExprCreateFromSqlExpr(&pRight, pAst->pRight, num, pColIndex, pExprInfo);
+    int32_t ret = convertSyntaxTreeToExprTree(&pRight, pAst->pRight, num, pColIndex, pExprInfo);
     if (ret != TSDB_CODE_SUCCESS) {
       return ret;
     }
@@ -5828,14 +5829,14 @@ static int32_t tSQLBinaryExprCreateFromSqlExpr(tSQLSyntaxNode **pExpr, tSQLExpr*
   
   if (pAst->pLeft == NULL) {
     if (pAst->nSQLOptr >= TK_TINYINT && pAst->nSQLOptr <= TK_DOUBLE) {
-      *pExpr = calloc(1, sizeof(tSQLSyntaxNode) + sizeof(tVariant));
+      *pExpr = calloc(1, sizeof(tExprNode) + sizeof(tVariant));
       (*pExpr)->nodeType = TSQL_NODE_VALUE;
-      (*pExpr)->pVal = (tVariant*) ((char*)(*pExpr) + sizeof(tSQLSyntaxNode));
+      (*pExpr)->pVal = (tVariant*) ((char*)(*pExpr) + sizeof(tExprNode));
       tVariantAssign((*pExpr)->pVal, &pAst->val);
     } else if (pAst->nSQLOptr >= TK_COUNT && pAst->nSQLOptr <= TK_AVG_IRATE) {
-      *pExpr = calloc(1, sizeof(tSQLSyntaxNode) + sizeof(SSchemaEx));
+      *pExpr = calloc(1, sizeof(tExprNode) + sizeof(SSchemaEx));
       (*pExpr)->nodeType = TSQL_NODE_COL;
-      (*pExpr)->pSchema = (SSchema*)((char*)(*pExpr) + sizeof(tSQLSyntaxNode));
+      (*pExpr)->pSchema = (SSchema*)((char*)(*pExpr) + sizeof(tExprNode));
       strncpy((*pExpr)->pSchema->name, pAst->operand.z, pAst->operand.n);
 
       // set the input column data byte and type.
@@ -5855,7 +5856,7 @@ static int32_t tSQLBinaryExprCreateFromSqlExpr(tSQLSyntaxNode **pExpr, tSQLExpr*
     
     strncpy((*pColIndex)[(*num) - 1].name, pAst->operand.z, pAst->operand.n);
   } else {
-    *pExpr = (tSQLSyntaxNode *)calloc(1, sizeof(tSQLSyntaxNode));
+    *pExpr = (tExprNode *)calloc(1, sizeof(tExprNode));
     (*pExpr)->_node.hasPK = false;
     (*pExpr)->_node.pLeft = pLeft;
     (*pExpr)->_node.pRight = pRight;

src/client/src/tscServer.c

@@ -285,14 +285,16 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg) {
     pRes->rspType = rpcMsg->msgType;
     pRes->rspLen  = rpcMsg->contLen;
 
-    char *tmp = (char *)realloc(pRes->pRsp, pRes->rspLen);
-    if (tmp == NULL) {
-      pRes->code = TSDB_CODE_CLI_OUT_OF_MEMORY;
-    } else {
-      pRes->pRsp = tmp;
-      if (pRes->rspLen) {
+    if (pRes->rspLen > 0) {
+      char *tmp = (char *)realloc(pRes->pRsp, pRes->rspLen);
+      if (tmp == NULL) {
+        pRes->code = TSDB_CODE_CLI_OUT_OF_MEMORY;
+      } else {
+        pRes->pRsp = tmp;
         memcpy(pRes->pRsp, rpcMsg->pCont, pRes->rspLen);
       }
+    } else {
+      pRes->pRsp = NULL;
     }
 
     // ignore the error information returned from mnode when set ignore flag in sql
@@ -327,7 +329,7 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg) {
     void *taosres = tscKeepConn[pCmd->command] ? pSql : NULL;
     rpcMsg->code = pRes->code ? pRes->code : pRes->numOfRows;
     
-    tscTrace("%p Async SQL result:%s res:%p", pSql, tstrerror(pRes->code), taosres);
+    tscTrace("%p Async SQL result:%s res:%p", pSql, tstrerror(pRes->code), pSql);
 
     /*
      * Whether to free sqlObj or not should be decided before call the user defined function, since this SqlObj
@@ -893,11 +895,6 @@ int32_t tscBuildCreateDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   pCmd->payloadLen = sizeof(SCMCreateDbMsg);
   pCmd->msgType = TSDB_MSG_TYPE_CM_CREATE_DB;
 
-  if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
-    tscError("%p failed to malloc for query msg", pSql);
-    return TSDB_CODE_CLI_OUT_OF_MEMORY;
-  }
-
   SCMCreateDbMsg *pCreateDbMsg = (SCMCreateDbMsg*)pCmd->payload;
 
   assert(pCmd->numOfClause == 1);
@@ -1228,7 +1225,6 @@ int tscBuildCreateTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SCreateTableSQL *pCreateTable = pInfo->pCreateTableInfo;
 
   pCreateTableMsg->igExists = pCreateTable->existCheck ? 1 : 0;
-
   pCreateTableMsg->numOfColumns = htons(pCmd->numOfCols);
   pCreateTableMsg->numOfTags = htons(pCmd->count);
 

src/client/src/tscSql.c

@@ -155,6 +155,10 @@ static void syncConnCallback(void *param, TAOS_RES *tres, int code) {
   STscObj *pObj = (STscObj *)param;
   assert(pObj != NULL && pObj->pSql != NULL);
   
+  if (code < 0) {
+    pObj->pSql->res.code = code;
+  }
+  
   sem_post(&pObj->pSql->rspSem);
 }
 
@@ -177,17 +181,17 @@ TAOS *taos_connect(const char *ip, const char *user, const char *pass, const cha
     sem_wait(&pSql->rspSem);
     
     if (pSql->res.code != TSDB_CODE_SUCCESS) {
+      terrno = pSql->res.code;
       taos_close(pObj);
       return NULL;
     }
     
     tscTrace("%p DB connection is opening", pObj);
-
+    
     // version compare only requires the first 3 segments of the version string
     int code = taosCheckVersion(version, taos_get_server_info(pObj), 3);
     if (code != 0) {
-      pSql->res.code = code;
-      
+      terrno = code;
       taos_close(pObj);
       return NULL;
     } else {
@@ -267,35 +271,32 @@ int taos_query_imp(STscObj *pObj, SSqlObj *pSql) {
   return pRes->code;
 }
 
-static void syncQueryCallback(void *param, TAOS_RES *tres, int code) {
-  STscObj *pObj = (STscObj *)param;
-  assert(pObj != NULL && pObj->pSql != NULL);
+static void waitForQueryRsp(void *param, TAOS_RES *tres, int code) {
+  assert(param != NULL);
+  SSqlObj *pSql = ((STscObj *)param)->pSql;
   
-  sem_post(&pObj->pSql->rspSem);
+  // valid error code is less than 0
+  if (code < 0) {
+    pSql->res.code = code;
+  }
+  
+  sem_post(&pSql->rspSem);
 }
 
 int taos_query(TAOS *taos, const char *sqlstr) {
   STscObj *pObj = (STscObj *)taos;
   if (pObj == NULL || pObj->signature != pObj) {
-    globalCode = TSDB_CODE_DISCONNECTED;
+    terrno = TSDB_CODE_DISCONNECTED;
     return TSDB_CODE_DISCONNECTED;
   }
   
-  SSqlObj *pSql = (SSqlObj *)calloc(1, sizeof(SSqlObj));
-  if (pSql == NULL) {
-    tscError("failed to malloc sqlObj");
-    return TSDB_CODE_CLI_OUT_OF_MEMORY;
-  }
-  
-  pObj->pSql = pSql;
-  tsem_init(&pSql->rspSem, 0, 0);
+  SSqlObj* pSql = pObj->pSql;
   
-  int32_t sqlLen = strlen(sqlstr);
-  doAsyncQuery(pObj, pObj->pSql, syncQueryCallback, taos, sqlstr, sqlLen);
+  size_t sqlLen = strlen(sqlstr);
+  doAsyncQuery(pObj, pSql, waitForQueryRsp, taos, sqlstr, sqlLen);
 
   // wait for the callback function to post the semaphore
   sem_wait(&pSql->rspSem);
-  
   return pSql->res.code;
 }
 
@@ -649,12 +650,12 @@ static void **tscBuildResFromSubqueries(SSqlObj *pSql) {
   return pRes->tsrow;
 }
 
-static void asyncFetchCallback(void *param, TAOS_RES *tres, int numOfRows) {
+static void waitForRetrieveRsp(void *param, TAOS_RES *tres, int numOfRows) {
   SSqlObj* pSql = (SSqlObj*) tres;
+  
   if (numOfRows < 0) { // set the error code
     pSql->res.code = -numOfRows;
   }
-  
   sem_post(&pSql->rspSem);
 }
 
@@ -677,7 +678,7 @@ TAOS_ROW taos_fetch_row(TAOS_RES *res) {
   // current data are exhausted, fetch more data
   if (pRes->data == NULL || (pRes->data != NULL && pRes->row >= pRes->numOfRows && pRes->completed != true &&
       (pCmd->command == TSDB_SQL_RETRIEVE || pCmd->command == TSDB_SQL_RETRIEVE_METRIC || pCmd->command == TSDB_SQL_FETCH))) {
-    taos_fetch_rows_a(res, asyncFetchCallback, pSql->pTscObj);
+    taos_fetch_rows_a(res, waitForRetrieveRsp, pSql->pTscObj);
     
     sem_wait(&pSql->rspSem);
   }
@@ -754,20 +755,18 @@ void taos_free_result_imp(TAOS_RES *res, int keepCmd) {
   if (pRes == NULL || pRes->qhandle == 0) {
     /* Query rsp is not received from vnode, so the qhandle is NULL */
     tscTrace("%p qhandle is null, abort free, fp:%p", pSql, pSql->fp);
-    if (pSql->fp != NULL) {
-      STscObj* pObj = pSql->pTscObj;
-  
-      if (pSql == pObj->pSql) {
-        pObj->pSql = NULL;
-        tscFreeSqlObj(pSql);
-      }
-      
+    
+    if (tscShouldFreeAsyncSqlObj(pSql)) {
+      tscFreeSqlObj(pSql);
       tscTrace("%p Async SqlObj is freed by app", pSql);
-    } else if (keepCmd) {
-      tscFreeSqlResult(pSql);
     } else {
-      tscFreeSqlObjPartial(pSql);
+      if (keepCmd) {
+        tscFreeSqlResult(pSql);
+      } else {
+        tscFreeSqlObjPartial(pSql);
+      }
     }
+    
     return;
   }
 
@@ -792,10 +791,11 @@ void taos_free_result_imp(TAOS_RES *res, int keepCmd) {
    *         for each subquery. Because the failure of execution tsProcessSql may trigger the callback function
    *         be executed, and the retry efforts may result in double free the resources, e.g.,SRetrieveSupport
    */
-  if (pRes->code != TSDB_CODE_QUERY_CANCELLED &&
-      ((pRes->numOfRows > 0 && pCmd->command < TSDB_SQL_LOCAL) ||
+  if ((pCmd->command == TSDB_SQL_SELECT || pCmd->command == TSDB_SQL_SHOW || pCmd->command == TSDB_SQL_RETRIEVE ||
+      pCmd->command == TSDB_SQL_FETCH) &&
+      (pRes->code != TSDB_CODE_QUERY_CANCELLED && ((pRes->numOfRows > 0 && pCmd->command < TSDB_SQL_LOCAL && pRes->completed == false) ||
        (pRes->code == TSDB_CODE_SUCCESS && pRes->numOfRows == 0 && pCmd->command == TSDB_SQL_SELECT &&
-        pSql->pStream == NULL && pTableMetaInfo->pTableMeta != NULL))) {
+        pSql->pStream == NULL && pTableMetaInfo->pTableMeta != NULL)))) {
     pCmd->command = (pCmd->command > TSDB_SQL_MGMT) ? TSDB_SQL_RETRIEVE : TSDB_SQL_FETCH;
 
     tscTrace("%p code:%d, numOfRows:%d, command:%d", pSql, pRes->code, pRes->numOfRows, pCmd->command);
@@ -836,39 +836,37 @@ void taos_free_result_imp(TAOS_RES *res, int keepCmd) {
     }
   } else {
     // if no free resource msg is sent to vnode, we free this object immediately.
-
-    if (pSql->fp) {
+    bool free = tscShouldFreeAsyncSqlObj(pSql);
+    if (free) {
       assert(pRes->numOfRows == 0 || (pCmd->command > TSDB_SQL_LOCAL));
+  
       tscFreeSqlObj(pSql);
       tscTrace("%p Async sql result is freed by app", pSql);
-    } else if (keepCmd) {
-      tscFreeSqlResult(pSql);
-      tscTrace("%p sql result is freed while sql command is kept", pSql);
     } else {
-      tscFreeSqlObjPartial(pSql);
-      tscTrace("%p sql result is freed", pSql);
+      if (keepCmd) {
+        tscFreeSqlResult(pSql);
+        tscTrace("%p sql result is freed while sql command is kept", pSql);
+      } else {
+        tscFreeSqlObjPartial(pSql);
+        tscTrace("%p sql result is freed by app", pSql);
+      }
     }
   }
 }
 
 void taos_free_result(TAOS_RES *res) { taos_free_result_imp(res, 0); }
 
+// todo should not be used in async query
 int taos_errno(TAOS *taos) {
   STscObj *pObj = (STscObj *)taos;
-  int      code;
-
-  if (pObj == NULL || pObj->signature != pObj) return globalCode;
 
-  if ((int8_t)(pObj->pSql->res.code) == -1)
-    code = TSDB_CODE_OTHERS;
-  else
-    code = pObj->pSql->res.code;
+  if (pObj == NULL || pObj->signature != pObj) {
+    return terrno;
+  }
 
-  return code;
+  return pObj->pSql->res.code;
 }
 
-//static bool validErrorCode(int32_t code) { return code >= TSDB_CODE_SUCCESS && code < TSDB_CODE_MAX_ERROR_CODE; }
-
 /*
  * In case of invalid sql error, additional information is attached to explain
  * why the sql is invalid
@@ -888,13 +886,15 @@ static bool hasAdditionalErrorInfo(int32_t code, SSqlCmd *pCmd) {
   return z != NULL;
 }
 
+// todo should not be used in async model
 char *taos_errstr(TAOS *taos) {
   STscObj *pObj = (STscObj *)taos;
 
   if (pObj == NULL || pObj->signature != pObj)
-    return (char*)tstrerror(globalCode);
+    return (char*)tstrerror(terrno);
 
-  SSqlObj *pSql = pObj->pSql;
+  SSqlObj* pSql = pObj->pSql;
+  
   if (hasAdditionalErrorInfo(pSql->res.code, &pSql->cmd)) {
     return pSql->cmd.payload;
   } else {

src/client/src/tscSub.c

@@ -124,7 +124,6 @@ static SSub* tscCreateSubscription(STscObj* pObj, const char* topic, const char*
   pSql->sqlstr = sqlstr;
 
   tsem_init(&pSql->rspSem, 0, 0);
-  tsem_init(&pSql->emptyRspSem, 0, 1);
 
   SSqlRes *pRes = &pSql->res;
   pRes->numOfRows = 1;

src/client/src/tscSubquery.c

@@ -392,10 +392,10 @@ void freeSubqueryObj(SSqlObj* pSql) {
 static void doQuitSubquery(SSqlObj* pParentSql) {
   freeSubqueryObj(pParentSql);
 
-  tsem_wait(&pParentSql->emptyRspSem);
-  tsem_wait(&pParentSql->emptyRspSem);
+//  tsem_wait(&pParentSql->emptyRspSem);
+//  tsem_wait(&pParentSql->emptyRspSem);
 
-  tsem_post(&pParentSql->rspSem);
+//  tsem_post(&pParentSql->rspSem);
 }
 
 static void quitAllSubquery(SSqlObj* pSqlObj, SJoinSubquerySupporter* pSupporter) {
@@ -567,7 +567,7 @@ static void joinRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) {
         freeSubqueryObj(pParentSql);
       }
 
-      tsem_post(&pParentSql->rspSem);
+//      tsem_post(&pParentSql->rspSem);
     } else {
       tscTrace("%p sub:%p completed, completed:%d, total:%d", pParentSql, tres, finished, numOfTotal);
     }
@@ -662,7 +662,7 @@ void tscFetchDatablockFromSubquery(SSqlObj* pSql) {
   }
 
   // wait for all subquery completed
-  tsem_wait(&pSql->rspSem);
+//  tsem_wait(&pSql->rspSem);
   
   // update the records for each subquery
   for(int32_t i = 0; i < pSql->numOfSubs; ++i) {
@@ -797,10 +797,7 @@ void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code) {
           tscProcessSql(pSql);
         } else {  // first retrieve from vnode during the secondary stage sub-query
           if (pParentSql->fp == NULL) {
-            tsem_wait(&pParentSql->emptyRspSem);
-            tsem_wait(&pParentSql->emptyRspSem);
-
-            tsem_post(&pParentSql->rspSem);
+//            tsem_post(&pParentSql->rspSem);
           } else {
             // set the command flag must be after the semaphore been correctly set.
             //    pPObj->cmd.command = TSDB_SQL_RETRIEVE_METRIC;
@@ -954,10 +951,7 @@ int32_t tscHandleMasterJoinQuery(SSqlObj* pSql) {
     }
   }
   
-  tsem_post(&pSql->emptyRspSem);
-  tsem_wait(&pSql->rspSem);
-  
-  tsem_post(&pSql->emptyRspSem);
+//  tsem_wait(&pSql->rspSem);
   
   if (pSql->numOfSubs <= 0) {
     pSql->cmd.command = TSDB_SQL_RETRIEVE_EMPTY_RESULT;

src/client/src/tscSystem.c

@@ -40,15 +40,10 @@ void *  tscQhandle;
 void *  tscCheckDiskUsageTmr;
 int     tsInsertHeadSize;
 
-extern int            tscEmbedded;
-int                   tscNumOfThreads;
-static pthread_once_t tscinit = PTHREAD_ONCE_INIT;
-static pthread_mutex_t tscMutex;
+int tscNumOfThreads;
 
-extern int  tsTscEnableRecordSql;
-extern int  tsNumOfLogLines;
+static pthread_once_t tscinit = PTHREAD_ONCE_INIT;
 void taosInitNote(int numOfNoteLines, int maxNotes, char* lable);
-void deltaToUtcInitOnce();
 
 void tscCheckDiskUsage(void *para, void *unused) {
   taosGetDisk();
@@ -60,7 +55,6 @@ int32_t tscInitRpc(const char *user, const char *secret) {
   char secretEncrypt[32] = {0};
   taosEncryptPass((uint8_t *)secret, strlen(secret), secretEncrypt);
 
-  pthread_mutex_lock(&tscMutex);
   if (pVnodeConn == NULL) {
     memset(&rpcInit, 0, sizeof(rpcInit));
     rpcInit.localIp = tsLocalIp;
@@ -78,7 +72,6 @@ int32_t tscInitRpc(const char *user, const char *secret) {
     pVnodeConn = rpcOpen(&rpcInit);
     if (pVnodeConn == NULL) {
       tscError("failed to init connection to vnode");
-      pthread_mutex_unlock(&tscMutex);
       return -1;
     }
   }
@@ -100,12 +93,10 @@ int32_t tscInitRpc(const char *user, const char *secret) {
     pTscMgmtConn = rpcOpen(&rpcInit);
     if (pTscMgmtConn == NULL) {
       tscError("failed to init connection to mgmt");
-      pthread_mutex_unlock(&tscMutex);
       return -1;
     }
   }
 
-  pthread_mutex_unlock(&tscMutex);
   return 0;
 }
 
@@ -113,7 +104,7 @@ void taos_init_imp() {
   char        temp[128];
   struct stat dirstat;
 
-  pthread_mutex_init(&tscMutex, NULL);
+  errno = TSDB_CODE_SUCCESS;
   srand(taosGetTimestampSec());
   deltaToUtcInitOnce();
 

src/client/src/tscUtil.c

@@ -394,6 +394,10 @@ void tscDestroyResPointerInfo(SSqlRes* pRes) {
 }
 
 void tscFreeSqlCmdData(SSqlCmd* pCmd) {
+  pCmd->command = 0;
+  pCmd->numOfCols = 0;
+  pCmd->count = 0;
+  
   pCmd->pDataBlocks = tscDestroyBlockArrayList(pCmd->pDataBlocks);
   tscFreeSubqueryInfo(pCmd);
 }
@@ -454,9 +458,7 @@ void tscFreeSqlObjPartial(SSqlObj* pSql) {
       cmd == TSDB_SQL_METRIC_JOIN_RETRIEVE) {
     tscRemoveFromSqlList(pSql);
   }
-
-  pCmd->command = 0;
-
+  
   // pSql->sqlstr will be used by tscBuildQueryStreamDesc
   pthread_mutex_lock(&pObj->mutex);
   tfree(pSql->sqlstr);
@@ -464,12 +466,17 @@ void tscFreeSqlObjPartial(SSqlObj* pSql) {
   
   tscFreeSqlResult(pSql);
   tfree(pSql->pSubs);
-  pSql->numOfSubs = 0;
+  
+  taosHashCleanup(pSql->pTableHashList);
   
   pSql->freed = 0;
+  pSql->numOfSubs = 0;
+  pSql->pTableHashList = NULL;
+  pSql->asyncTblPos = NULL;
+  
   tscFreeSqlCmdData(pCmd);
   
-  tscTrace("%p free sqlObj partial completed", pSql);
+  tscTrace("%p partially free sqlObj completed", pSql);
 }
 
 void tscFreeSqlObj(SSqlObj* pSql) {
@@ -487,8 +494,6 @@ void tscFreeSqlObj(SSqlObj* pSql) {
   tfree(pCmd->payload);
 
   pCmd->allocSize = 0;
-
-  tsem_destroy(&pSql->rspSem);
   free(pSql);
 }
 
@@ -820,7 +825,9 @@ void tscCloseTscObj(STscObj* pObj) {
   taosTmrStopA(&(pObj->pTimer));
   tscFreeSqlObj(pSql);
 
+  sem_destroy(&pSql->rspSem);
   pthread_mutex_destroy(&pObj->mutex);
+  
   tscTrace("%p DB connection is closed", pObj);
   tfree(pObj);
 }
@@ -842,10 +849,9 @@ int tscAllocPayload(SSqlCmd* pCmd, int size) {
   if (pCmd->payload == NULL) {
     assert(pCmd->allocSize == 0);
 
-    pCmd->payload = (char*)malloc(size);
+    pCmd->payload = (char*)calloc(1, size);
     if (pCmd->payload == NULL) return TSDB_CODE_CLI_OUT_OF_MEMORY;
     pCmd->allocSize = size;
-    memset(pCmd->payload, 0, pCmd->allocSize);
   } else {
     if (pCmd->allocSize < size) {
       char* b = realloc(pCmd->payload, size);
@@ -853,6 +859,8 @@ int tscAllocPayload(SSqlCmd* pCmd, int size) {
       pCmd->payload = b;
       pCmd->allocSize = size;
     }
+    
+    memset(pCmd->payload, 0, pCmd->payloadLen);
   }
 
   //memset(pCmd->payload, 0, pCmd->allocSize);
@@ -1105,7 +1113,7 @@ void tscClearFieldInfo(SFieldInfo* pFieldInfo) {
   
   for(int32_t i = 0; i < pFieldInfo->numOfOutputCols; ++i) {
     if (pFieldInfo->pExpr[i] != NULL) {
-      tSQLBinaryExprDestroy(&pFieldInfo->pExpr[i]->binExprInfo.pBinExpr, NULL);
+      tExprTreeDestroy(&pFieldInfo->pExpr[i]->binExprInfo.pBinExpr, NULL);
       tfree(pFieldInfo->pExpr[i]->binExprInfo.pReqColumns);
       tfree(pFieldInfo->pExpr[i]);
     }
@@ -1742,7 +1750,7 @@ bool tscShouldFreeAsyncSqlObj(SSqlObj* pSql) {
   }
 
   STscObj* pTscObj = pSql->pTscObj;
-  if (pSql->pStream != NULL || pTscObj->pHb == pSql) {
+  if (pSql->pStream != NULL || pTscObj->pHb == pSql || pTscObj->pSql == pSql) {
     return false;
   }
 
@@ -1898,7 +1906,6 @@ void tscFreeSubqueryInfo(SSqlCmd* pCmd) {
 
   for (int32_t i = 0; i < pCmd->numOfClause; ++i) {
     char* addr = (char*)pCmd - offsetof(SSqlObj, cmd);
-
     SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, i);
 
     doClearSubqueryInfo(pQueryInfo);
@@ -1929,7 +1936,6 @@ STableMetaInfo* tscAddMeterMetaInfo(SQueryInfo* pQueryInfo, const char* name, ST
   }
 
   pTableMetaInfo->pTableMeta = pTableMeta;
-//  pTableMetaInfo->pMetricMeta = pMetricMeta;
   pTableMetaInfo->numOfTags = numOfTags;
 
   if (tags != NULL) {
@@ -1963,7 +1969,7 @@ void doRemoveMeterMetaInfo(SQueryInfo* pQueryInfo, int32_t index, bool removeFro
 }
 
 void tscRemoveAllMeterMetaInfo(SQueryInfo* pQueryInfo, const char* address, bool removeFromCache) {
-  tscTrace("%p deref the metric/meter meta in cache, numOfTables:%d", address, pQueryInfo->numOfTables);
+  tscTrace("%p deref the table meta in cache, numOfTables:%d", address, pQueryInfo->numOfTables);
 
   int32_t index = pQueryInfo->numOfTables;
   while (index >= 0) {

src/dnode/src/dnodeRead.c

@@ -289,6 +289,7 @@ static void dnodeProcessRetrieveMsg(void *pVnode, SReadMsg *pMsg) {
       dnodeContinueExecuteQuery(pVnode, pQInfo, pMsg);
     } else {  // no further execution invoked, release the ref to vnode
       dnodeProcessReadResult(pVnode, pMsg);
+      dnodeReleaseVnode(pVnode);
     }
   }
   

src/inc/mnode.h

@@ -59,6 +59,7 @@ typedef struct {
   char     mnodeName[TSDB_DNODE_NAME_LEN + 1];
   int8_t   reserved[15];
   int8_t   updateEnd[1];
+  int32_t  refCount;
   int      syncFd;
   void    *hbTimer;
   void    *pSync;
@@ -84,6 +85,7 @@ typedef struct {
   char       dnodeName[TSDB_DNODE_NAME_LEN + 1];
   int8_t     reserved[15];
   int8_t     updateEnd[1];
+  int32_t    refCount;
   SVnodeLoad vload[TSDB_MAX_VNODES];
   int32_t    status;
   uint32_t   lastReboot;       // time stamp for last reboot
@@ -102,9 +104,8 @@ typedef struct {
 } SVnodeGid;
 
 typedef struct {
-  char   tableId[TSDB_TABLE_ID_LEN];
+  char   tableId[TSDB_TABLE_ID_LEN + 1];
   int8_t type;
-  int8_t dirty;
 } STableInfo;
 
 typedef struct SSuperTableObj {
@@ -116,6 +117,7 @@ typedef struct SSuperTableObj {
   int32_t    numOfTags;
   int8_t     reserved[15];
   int8_t     updateEnd[1];
+  int32_t    refCount;
   int32_t    numOfTables;
   int16_t    nextColId;
   SSchema *  schema;
@@ -134,6 +136,7 @@ typedef struct {
   int8_t     reserved[1]; 
   int8_t     updateEnd[1];
   int16_t    nextColId;    //used by normal table
+  int32_t    refCount;
   char*      sql;          //used by normal table
   SSchema*   schema;       //used by normal table
   SSuperTableObj *superTable;
@@ -150,6 +153,7 @@ typedef struct _vg_obj {
   int8_t          lbStatus;
   int8_t          reserved[14];
   int8_t          updateEnd[1];
+  int32_t         refCount;
   struct _vg_obj *prev, *next;
   struct _db_obj *pDb;
   int32_t         numOfTables;
@@ -164,7 +168,7 @@ typedef struct _db_obj {
   SDbCfg  cfg;
   int8_t  reserved[15];
   int8_t  updateEnd[1];
-  struct _db_obj *prev, *next;
+  int32_t refCount;
   int32_t numOfVgroups;
   int32_t numOfTables;
   int32_t numOfSuperTables;
@@ -182,7 +186,7 @@ typedef struct _user_obj {
   int8_t            writeAuth;
   int8_t            reserved[13];
   int8_t            updateEnd[1];
-  struct _user_obj *prev, *next;
+  int32_t           refCount;
   struct _acctObj * pAcct;
   SQqueryList *     pQList;  // query list
   SStreamList *     pSList;  // stream list
@@ -215,9 +219,8 @@ typedef struct _acctObj {
   int8_t    dirty;
   int8_t    reserved[14];
   int8_t    updateEnd[1];
+  int32_t  refCount;
   SAcctInfo acctInfo;
-  SDbObj *         pHead;
-  SUserObj *       pUser;
   pthread_mutex_t  mutex;
 } SAcctObj;
 
@@ -247,8 +250,12 @@ typedef struct {
   void     *ahandle;
   void     *thandle;
   void     *pCont;
-  SDbObj   *pDb;
+  SAcctObj *pAcct;
+  SDnodeObj*pDnode;
   SUserObj *pUser;
+  SDbObj   *pDb;
+  SVgObj   *pVgroup;
+  STableInfo *pTable;
 } SQueuedMsg;
 
 int32_t mgmtInitSystem();

src/mnode/CMakeLists.txt

@@ -14,6 +14,4 @@ IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
 
   ADD_LIBRARY(mnode ${SRC})
   TARGET_LINK_LIBRARIES(mnode trpc tutil pthread)
-ENDIF ()
-
+ENDIF ()
\ No newline at end of file
-

src/mnode/inc/mgmtAcct.h

@@ -30,12 +30,14 @@ typedef enum {
 int32_t   acctInit();
 void      acctCleanUp();
 SAcctObj *acctGetAcct(char *acctName);
+void      acctIncRef(SAcctObj *pAcct);
+void      acctDecRef(SAcctObj *pAcct);
 int32_t   acctCheck(SAcctObj *pAcct, EAcctGrantType type);
 
-int32_t acctAddDb(SAcctObj *pAcct, SDbObj *pDb);
-int32_t acctRemoveDb(SAcctObj *pAcct, SDbObj *pDb);
-int32_t acctAddUser(SAcctObj *pAcct, SUserObj *pUser);
-int32_t acctRemoveUser(SAcctObj *pAcct, SUserObj *pUser);
+void      acctAddDb(SAcctObj *pAcct, SDbObj *pDb);
+void      acctRemoveDb(SAcctObj *pAcct, SDbObj *pDb);
+void      acctAddUser(SAcctObj *pAcct, SUserObj *pUser);
+void      acctRemoveUser(SAcctObj *pAcct, SUserObj *pUser);
 
 #ifdef __cplusplus
 }

src/mnode/inc/mgmtChildTable.h

-/*
- * 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 TBASE_MNODE_CHILD_TABLE_H
-#define TBASE_MNODE_CHILD_TABLE_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stdint.h>
-#include <stdbool.h>
-#include "taosdef.h"
-#include "mnode.h"
-
-int32_t mgmtInitChildTables();
-void    mgmtCleanUpChildTables();
-void *  mgmtGetChildTable(char *tableId);
-
-void    mgmtCreateChildTable(SQueuedMsg *pMsg);
-void    mgmtDropChildTable(SQueuedMsg *pMsg, SChildTableObj *pTable);
-void    mgmtGetChildTableMeta(SQueuedMsg *pMsg, SChildTableObj *pTable);
-void    mgmtAlterChildTable(SQueuedMsg *pMsg, SChildTableObj *pTable);
-void    mgmtDropAllChildTables(SDbObj *pDropDb);
-void    mgmtDropAllChildTablesInStable(SSuperTableObj *pStable);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/mnode/inc/mgmtDb.h

@@ -27,6 +27,8 @@ int32_t mgmtInitDbs();
 void    mgmtCleanUpDbs();
 SDbObj *mgmtGetDb(char *db);
 SDbObj *mgmtGetDbByTableId(char *db);
+void    mgmtIncDbRef(SDbObj *pDb);
+void    mgmtDecDbRef(SDbObj *pDb);
 bool    mgmtCheckIsMonitorDB(char *db, char *monitordb);
 void    mgmtDropAllDbs(SAcctObj *pAcct);
 

src/mnode/inc/mgmtDnode.h

@@ -25,6 +25,8 @@ int32_t mgmtInitDnodes();
 void    mgmtCleanUpDnodes();
 int32_t mgmtGetDnodesNum();
 void *  mgmtGetNextDnode(void *pNode, SDnodeObj **pDnode);
+void    mgmtIncDnodeRef(SDnodeObj *pDnode);
+void    mgmtDecDnodeRef(SDnodeObj *pDnode);
 SDnodeObj* mgmtGetDnode(int32_t dnodeId);
 SDnodeObj* mgmtGetDnodeByIp(uint32_t ip);
 

src/mnode/inc/mgmtProfile.h

@@ -28,6 +28,8 @@ bool    mgmtCheckQhandle(uint64_t qhandle);
 void    mgmtSaveQhandle(void *qhandle);
 void    mgmtFreeQhandle(void *qhandle);
 
+void *  mgmtMallocQueuedMsg(SRpcMsg *rpcMsg);
+void *  mgmtCloneQueuedMsg(SQueuedMsg *pSrcMsg);
 void    mgmtFreeQueuedMsg(SQueuedMsg *pMsg);
 
 #ifdef __cplusplus

src/mnode/inc/mgmtSdb.h

@@ -44,6 +44,7 @@ typedef struct {
   char   *tableName;
   int32_t hashSessions;
   int32_t maxRowSize;
+  int32_t refCountPos;
   ESdbKeyType keyType;
   int32_t (*insertFp)(SSdbOperDesc *pOper);
   int32_t (*deleteFp)(SSdbOperDesc *pOper);
@@ -62,6 +63,8 @@ int32_t sdbUpdateRow(SSdbOperDesc *pOper);
 
 void    *sdbGetRow(void *handle, void *key);
 void    *sdbFetchRow(void *handle, void *pNode, void **ppRow);
+void     sdbIncRef(void *thandle, void *pRow);
+void     sdbDecRef(void *thandle, void *pRow);
 int64_t  sdbGetNumOfRows(void *handle);
 int64_t  sdbGetId(void *handle);
 uint64_t sdbGetVersion();

src/mnode/inc/mgmtSuperTable.h

-/*
- * 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 TBASE_MNODE_SUPER_TABLE_H
-#define TBASE_MNODE_SUPER_TABLE_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stdint.h>
-#include <stdbool.h>
-#include "taosdef.h"
-#include "mnode.h"
-
-int32_t mgmtInitSuperTables();
-void    mgmtCleanUpSuperTables();
-void *  mgmtGetSuperTable(char *tableId);
-
-void    mgmtCreateSuperTable(SQueuedMsg *pMsg);
-void    mgmtDropSuperTable(SQueuedMsg *pMsg, SSuperTableObj *pTable);
-void    mgmtGetSuperTableMeta(SQueuedMsg *pMsg, SSuperTableObj *pTable);
-void    mgmtAlterSuperTable(SQueuedMsg *pMsg, SSuperTableObj *pTable);
-void    mgmtDropAllSuperTables(SDbObj *pDropDb);
-int32_t mgmtSetSchemaFromSuperTable(SSchema *pSchema, SSuperTableObj *pTable);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/mnode/inc/mgmtTable.h

@@ -28,7 +28,10 @@ extern "C" {
 int32_t     mgmtInitTables();
 void        mgmtCleanUpTables();
 STableInfo* mgmtGetTable(char* tableId);
-void        mgmtExtractTableName(char* tableId, char* tableName);
+void        mgmtIncTableRef(void *pTable); 
+void        mgmtDecTableRef(void *pTable);
+void        mgmtDropAllChildTables(SDbObj *pDropDb);
+void        mgmtDropAllSuperTables(SDbObj *pDropDb);
 
 #ifdef __cplusplus
 }

src/mnode/inc/mgmtUser.h

@@ -24,6 +24,8 @@ extern "C" {
 int32_t   mgmtInitUsers();
 void      mgmtCleanUpUsers();
 SUserObj *mgmtGetUser(char *name);
+void      mgmtIncUserRef(SUserObj *pUser);
+void      mgmtDecUserRef(SUserObj *pUser);
 SUserObj *mgmtGetUserFromConn(void *pConn, bool *usePublicIp);
 int32_t   mgmtCreateUser(SAcctObj *pAcct, char *name, char *pass);
 void      mgmtDropAllUsers(SAcctObj *pAcct);

src/mnode/inc/mgmtVgroup.h

@@ -27,9 +27,11 @@ extern "C" {
 int32_t mgmtInitVgroups();
 void    mgmtCleanUpVgroups();
 SVgObj *mgmtGetVgroup(int32_t vgId);
+void    mgmtIncVgroupRef(SVgObj *pVgroup);
+void    mgmtDecVgroupRef(SVgObj *pVgroup);
 void    mgmtDropAllVgroups(SDbObj *pDropDb);
 
-void    mgmtCreateVgroup(SQueuedMsg *pMsg);
+void    mgmtCreateVgroup(SQueuedMsg *pMsg, SDbObj *pDb);
 void    mgmtDropVgroup(SVgObj *pVgroup, void *ahandle);
 void    mgmtAlterVgroup(SVgObj *pVgroup, void *ahandle);
 SVgObj *mgmtGetAvailableVgroup(SDbObj *pDb);

src/mnode/src/mgmtAcct.c

@@ -18,6 +18,8 @@
 #include "taoserror.h"
 #include "mnode.h"
 #include "mgmtAcct.h"
+#include "mgmtDb.h"
+#include "mgmtUser.h"
 #ifndef _ACCOUNT
 
 static SAcctObj tsAcctObj = {0};
@@ -30,79 +32,31 @@ int32_t acctInit() {
 
 void      acctCleanUp() {}
 SAcctObj *acctGetAcct(char *acctName) { return &tsAcctObj; }
+void      acctIncRef(SAcctObj *pAcct) {}
+void      acctDecRef(SAcctObj *pAcct) {}
 int32_t   acctCheck(SAcctObj *pAcct, EAcctGrantType type) { return TSDB_CODE_SUCCESS; }
 #endif
 
-int32_t acctAddDb(SAcctObj *pAcct, SDbObj *pDb) {
-  pthread_mutex_lock(&pAcct->mutex);
-  pDb->next = pAcct->pHead;
-  pDb->prev = NULL;
+void acctAddDb(SAcctObj *pAcct, SDbObj *pDb) {
+  atomic_add_fetch_32(&pAcct->acctInfo.numOfDbs, 1);
   pDb->pAcct = pAcct;
-
-  if (pAcct->pHead) {
-    pAcct->pHead->prev = pDb;
-  }
-
-  pAcct->pHead = pDb;
-  pAcct->acctInfo.numOfDbs++;
-  pthread_mutex_unlock(&pAcct->mutex);
-
-  return 0;
+  acctIncRef(pAcct);
 }
 
-int32_t acctRemoveDb(SAcctObj *pAcct, SDbObj *pDb) {
-  pthread_mutex_lock(&pAcct->mutex);
-  if (pDb->prev) {
-    pDb->prev->next = pDb->next;
-  }
-
-  if (pDb->next) {
-    pDb->next->prev = pDb->prev;
-  }
-
-  if (pDb->prev == NULL) {
-    pAcct->pHead = pDb->next;
-  }
-
-  pAcct->acctInfo.numOfDbs--;
-  pthread_mutex_unlock(&pAcct->mutex);
-
-  return 0;
+void acctRemoveDb(SAcctObj *pAcct, SDbObj *pDb) {
+  atomic_sub_fetch_32(&pAcct->acctInfo.numOfDbs, 1);
+  pDb->pAcct = NULL;
+  acctIncRef(pAcct);
 }
 
-int32_t acctAddUser(SAcctObj *pAcct, SUserObj *pUser) {
-  pthread_mutex_lock(&pAcct->mutex);
-  pUser->next = pAcct->pUser;
-  pUser->prev = NULL;
-
-  if (pAcct->pUser) {
-    pAcct->pUser->prev = pUser;
-  }
-
-  pAcct->pUser = pUser;
-  pAcct->acctInfo.numOfUsers++;
+void acctAddUser(SAcctObj *pAcct, SUserObj *pUser) {
+  atomic_add_fetch_32(&pAcct->acctInfo.numOfUsers, 1);
   pUser->pAcct = pAcct;
-  pthread_mutex_unlock(&pAcct->mutex);
-
-  return 0;
+  acctIncRef(pAcct);
 }
 
-int32_t acctRemoveUser(SAcctObj *pAcct, SUserObj *pUser) {
-  pthread_mutex_lock(&pAcct->mutex);
-  if (pUser->prev) {
-    pUser->prev->next = pUser->next;
-  }
-
-  if (pUser->next) {
-    pUser->next->prev = pUser->prev;
-  }
-
-  if (pUser->prev == NULL) {
-    pAcct->pUser = pUser->next;
-  }
-
-  pAcct->acctInfo.numOfUsers--;
-  pthread_mutex_unlock(&pAcct->mutex);
-
-  return 0;
+void acctRemoveUser(SAcctObj *pAcct, SUserObj *pUser) {
+  atomic_sub_fetch_32(&pAcct->acctInfo.numOfUsers, 1);
+  pUser->pAcct = NULL;
+  acctIncRef(pAcct);
 }
\ No newline at end of file

src/mnode/src/mgmtBalance.c

@@ -29,6 +29,7 @@ int32_t mgmtAllocVnodes(SVgObj *pVgroup) {
   float      vnodeUsage = 1.0;
 
   while (1) {
+    mgmtDecDnodeRef(pDnode);
     pNode = mgmtGetNextDnode(pNode, &pDnode);
     if (pDnode == NULL) break;
     if (pDnode->numOfTotalVnodes <= 0) continue;

src/mnode/src/mgmtDb.c

@@ -22,24 +22,22 @@
 #include "mnode.h"
 #include "mgmtAcct.h"
 #include "mgmtBalance.h"
-#include "mgmtChildTable.h"
 #include "mgmtDb.h"
 #include "mgmtDnode.h"
 #include "mgmtGrant.h"
 #include "mgmtShell.h"
 #include "mgmtMnode.h"
-#include "mgmtChildTable.h"
+#include "mgmtProfile.h"
 #include "mgmtSdb.h"
-#include "mgmtSuperTable.h"
 #include "mgmtTable.h"
 #include "mgmtUser.h"
 #include "mgmtVgroup.h"
 
-void *         tsDbSdb = NULL;
+void *  tsDbSdb = NULL;
 static int32_t tsDbUpdateSize;
 
 static int32_t mgmtCreateDb(SAcctObj *pAcct, SCMCreateDbMsg *pCreate);
-static void    mgmtDropDb(void *handle, void *tmrId);
+static void    mgmtDropDb(SQueuedMsg *newMsg);
 static int32_t mgmtSetDbDirty(SDbObj *pDb);
 static int32_t mgmtGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
 static int32_t mgmtRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, void *pConn);
@@ -58,8 +56,6 @@ static int32_t mgmtDbActionInsert(SSdbOperDesc *pOper) {
 
   pDb->pHead = NULL;
   pDb->pTail = NULL;
-  pDb->prev = NULL;
-  pDb->next = NULL;
   pDb->numOfVgroups = 0;
   pDb->numOfTables = 0;
   pDb->numOfSuperTables = 0;
@@ -120,6 +116,7 @@ int32_t mgmtInitDbs() {
     .tableName    = "dbs",
     .hashSessions = TSDB_MAX_DBS,
     .maxRowSize   = tsDbUpdateSize,
+    .refCountPos  = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj,
     .keyType      = SDB_KEY_TYPE_STRING,
     .insertFp     = mgmtDbActionInsert,
     .deleteFp     = mgmtDbActionDelete,
@@ -149,6 +146,14 @@ SDbObj *mgmtGetDb(char *db) {
   return (SDbObj *)sdbGetRow(tsDbSdb, db);
 }
 
+void mgmtIncDbRef(SDbObj *pDb) { 
+  return sdbIncRef(tsDbSdb, pDb); 
+}
+
+void mgmtDecDbRef(SDbObj *pDb) { 
+  return sdbDecRef(tsDbSdb, pDb); 
+}
+
 SDbObj *mgmtGetDbByTableId(char *tableId) {
   char db[TSDB_TABLE_ID_LEN], *pos;
 
@@ -282,8 +287,9 @@ static int32_t mgmtCreateDb(SAcctObj *pAcct, SCMCreateDbMsg *pCreate) {
     return code;
   }
 
-  SDbObj *pDb = (SDbObj *)sdbGetRow(tsDbSdb, pCreate->db);
+  SDbObj *pDb = mgmtGetDb(pCreate->db);
   if (pDb != NULL) {
+    mgmtDecDbRef(pDb);
     return TSDB_CODE_DB_ALREADY_EXIST;
   }
 
@@ -511,16 +517,14 @@ static int32_t mgmtGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn)
   }
 
   pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-
   pShow->numOfRows = pUser->pAcct->acctInfo.numOfDbs;
-  pShow->pNode = pUser->pAcct->pHead;
 
+  mgmtDecUserRef(pUser);
   return 0;
 }
 
 static char *mgmtGetDbStr(char *src) {
   char *pos = strstr(src, TS_PATH_DELIMITER);
-
   return ++pos;
 }
 
@@ -533,14 +537,8 @@ static int32_t mgmtRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, void *
   if (pUser == NULL) return 0;
 
   while (numOfRows < rows) {
-    pDb = (SDbObj *)pShow->pNode;
+    pShow->pNode = sdbFetchRow(tsDbSdb, pShow->pNode, (void **) &pDb);
     if (pDb == NULL) break;
-    pShow->pNode = (void *)pDb->next;
-    if (mgmtCheckIsMonitorDB(pDb->name, tsMonitorDbName)) {
-      if (strcmp(pUser->user, "root") != 0 && strcmp(pUser->user, "_root") != 0 && strcmp(pUser->user, "monitor") != 0 ) {
-        continue;
-      }
-    }
 
     cols = 0;
 
@@ -637,25 +635,32 @@ static int32_t mgmtRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, void *
     cols++;
 
     numOfRows++;
+    mgmtDecDbRef(pDb);
   }
 
   pShow->numOfReads += numOfRows;
+  mgmtDecUserRef(pUser);
   return numOfRows;
 }
 
 void mgmtAddSuperTableIntoDb(SDbObj *pDb) {
   atomic_add_fetch_32(&pDb->numOfSuperTables, 1);
+  mgmtIncDbRef(pDb);
 }
 
 void mgmtRemoveSuperTableFromDb(SDbObj *pDb) {
   atomic_add_fetch_32(&pDb->numOfSuperTables, -1);
+  mgmtDecDbRef(pDb);
 }
+
 void mgmtAddTableIntoDb(SDbObj *pDb) {
   atomic_add_fetch_32(&pDb->numOfTables, 1);
+  mgmtIncDbRef(pDb);
 }
 
 void mgmtRemoveTableFromDb(SDbObj *pDb) {
   atomic_add_fetch_32(&pDb->numOfTables, -1);
+  mgmtDecDbRef(pDb);
 }
 
 static int32_t mgmtSetDbDirty(SDbObj *pDb) {
@@ -766,8 +771,6 @@ static int32_t mgmtAlterDb(SDbObj *pDb, SCMAlterDbMsg *pAlter) {
 }
 
 static void mgmtProcessAlterDbMsg(SQueuedMsg *pMsg) {
-  if (mgmtCheckRedirect(pMsg->thandle)) return;
-
   SCMAlterDbMsg *pAlter = pMsg->pCont;
   mTrace("db:%s, alter db msg is received from thandle:%p", pAlter->db, pMsg->thandle);
 
@@ -777,13 +780,7 @@ static void mgmtProcessAlterDbMsg(SQueuedMsg *pMsg) {
     return;
   }
 
-  if (!pMsg->pUser->writeAuth) {
-    mError("db:%s, failed to alter, no rights", pAlter->db);
-    mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_NO_RIGHTS);
-    return;
-  }
-
-  SDbObj *pDb = mgmtGetDb(pAlter->db);
+  SDbObj *pDb = pMsg->pDb = mgmtGetDb(pAlter->db);
   if (pDb == NULL) {
     mError("db:%s, failed to alter, invalid db", pAlter->db);
     mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_INVALID_DB);
@@ -794,15 +791,13 @@ static void mgmtProcessAlterDbMsg(SQueuedMsg *pMsg) {
   if (code != TSDB_CODE_SUCCESS) {
     mError("db:%s, failed to alter, invalid db option", pAlter->db);
     mgmtSendSimpleResp(pMsg->thandle, code);
+    return;
   }
 
-  SQueuedMsg *newMsg = malloc(sizeof(SQueuedMsg));
-  memcpy(newMsg, pMsg, sizeof(SQueuedMsg));
-  pMsg->pCont = NULL;
-
   SVgObj *pVgroup = pDb->pHead;
   if (pVgroup != NULL) {
     mPrint("vgroup:%d, will be altered", pVgroup->vgId);
+    SQueuedMsg *newMsg = mgmtCloneQueuedMsg(pMsg);
     newMsg->ahandle = pVgroup;
     newMsg->expected = pVgroup->numOfVnodes;
     mgmtAlterVgroup(pVgroup, newMsg);
@@ -810,15 +805,11 @@ static void mgmtProcessAlterDbMsg(SQueuedMsg *pMsg) {
   }
 
   mTrace("db:%s, all vgroups is altered", pDb->name);
-
-  mgmtSendSimpleResp(newMsg->thandle, TSDB_CODE_SUCCESS);
-  rpcFreeCont(newMsg->pCont);
-  free(newMsg);
+  mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SUCCESS);
 }
 
-static void mgmtDropDb(void *handle, void *tmrId) {
-  SQueuedMsg *newMsg = handle;
-  SDbObj *pDb = newMsg->ahandle;
+static void mgmtDropDb(SQueuedMsg *pMsg) {
+  SDbObj *pDb = pMsg->pDb;
   mPrint("db:%s, drop db from sdb", pDb->name);
 
   SSdbOperDesc oper = {
@@ -831,14 +822,10 @@ static void mgmtDropDb(void *handle, void *tmrId) {
     code = TSDB_CODE_SDB_ERROR;
   }
 
-  mgmtSendSimpleResp(newMsg->thandle, code);
-  rpcFreeCont(newMsg->pCont);
-  free(newMsg);
+  mgmtSendSimpleResp(pMsg->thandle, code);
 }
 
 static void mgmtProcessDropDbMsg(SQueuedMsg *pMsg) {
-  if (mgmtCheckRedirect(pMsg->thandle)) return;
-
   SCMDropDbMsg *pDrop = pMsg->pCont;
   mTrace("db:%s, drop db msg is received from thandle:%p", pDrop->db, pMsg->thandle);
 
@@ -848,13 +835,7 @@ static void mgmtProcessDropDbMsg(SQueuedMsg *pMsg) {
     return;
   }
 
-  if (!pMsg->pUser->writeAuth) {
-    mError("db:%s, failed to drop, no rights", pDrop->db);
-    mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_NO_RIGHTS);
-    return;
-  }
-
-  SDbObj *pDb = mgmtGetDb(pDrop->db);
+  SDbObj *pDb = pMsg->pDb = mgmtGetDb(pDrop->db);
   if (pDb == NULL) {
     if (pDrop->ignoreNotExists) {
       mTrace("db:%s, db is not exist, think drop success", pDrop->db);
@@ -880,13 +861,10 @@ static void mgmtProcessDropDbMsg(SQueuedMsg *pMsg) {
     return;
   }
 
-  SQueuedMsg *newMsg = malloc(sizeof(SQueuedMsg));
-  memcpy(newMsg, pMsg, sizeof(SQueuedMsg));
-  pMsg->pCont = NULL;
-
   SVgObj *pVgroup = pDb->pHead;
   if (pVgroup != NULL) {
     mPrint("vgroup:%d, will be dropped", pVgroup->vgId);
+    SQueuedMsg *newMsg = mgmtCloneQueuedMsg(pMsg);
     newMsg->ahandle = pVgroup;
     newMsg->expected = pVgroup->numOfVnodes;
     mgmtDropVgroup(pVgroup, newMsg);
@@ -894,10 +872,7 @@ static void mgmtProcessDropDbMsg(SQueuedMsg *pMsg) {
   }
 
   mTrace("db:%s, all vgroups is dropped", pDb->name);
-
-  void *tmpTmr;
-  newMsg->ahandle = pDb;
-  taosTmrReset(mgmtDropDb, 10, newMsg, tsMgmtTmr, &tmpTmr);
+  mgmtDropDb(pMsg);
 }
 
 void  mgmtDropAllDbs(SAcctObj *pAcct)  {
@@ -913,6 +888,7 @@ void  mgmtDropAllDbs(SAcctObj *pAcct)  {
       mgmtSetDbDirty(pDb);
       numOfDbs++;
     }
+    mgmtDecDbRef(pDb);
   }
 
   mTrace("acct:%s, all dbs is is set dirty", pAcct->user, numOfDbs);

src/mnode/src/mgmtDnode.c

@@ -42,6 +42,8 @@ extern int32_t clusterInit();
 extern void    clusterCleanUp();
 extern int32_t clusterGetDnodesNum();
 extern void *  clusterGetNextDnode(void *pNode, void **pDnode);
+extern void    clusterIncDnodeRef(SDnodeObj *pDnode);
+extern void    clusterDecDnodeRef(SDnodeObj *pDnode);
 extern SDnodeObj* clusterGetDnode(int32_t dnodeId);
 extern SDnodeObj* clusterGetDnodeByIp(uint32_t ip);
 #ifndef _CLUSTER
@@ -118,6 +120,18 @@ int32_t mgmtGetDnodesNum() {
 #endif
 }
 
+void mgmtIncDnodeRef(SDnodeObj *pDnode) {
+#ifdef _CLUSTER
+  return clusterIncDnodeRef(pDnode);
+#endif
+}
+
+void mgmtDecDnodeRef(SDnodeObj *pDnode) {
+#ifdef _CLUSTER
+  return clusterDecDnodeRef(pDnode);
+#endif
+}
+
 void *  mgmtGetNextDnode(void *pNode, SDnodeObj **pDnode) {
 #ifdef _CLUSTER
   return clusterGetNextDnode(pNode, pDnode);
@@ -183,6 +197,13 @@ void mgmtProcessDnodeStatusMsg(SRpcMsg *rpcMsg) {
   pStatus->numOfCores = htons(pStatus->numOfCores);
   pStatus->numOfTotalVnodes = htons(pStatus->numOfTotalVnodes);
 
+  uint32_t version = htonl(pStatus->version);
+  if (version != tsVersion) {
+    mError("status msg version:%d not equal with mnode:%d", version, tsVersion);
+    mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_INVALID_MSG_VERSION);
+    return ;
+  }
+
   SDnodeObj *pDnode = NULL;
   if (pStatus->dnodeId == 0) {
     pDnode = mgmtGetDnodeByIp(pStatus->privateIp);
@@ -199,13 +220,6 @@ void mgmtProcessDnodeStatusMsg(SRpcMsg *rpcMsg) {
       return;
     }
   }
-
-  uint32_t version = htonl(pStatus->version);
-  if (version != tsVersion) {
-    mError("dnode:%d, status msg version:%d not equal with mnode:%d", pDnode->dnodeId, version, tsVersion);
-    mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_INVALID_MSG_VERSION);
-    return ;
-  }
   
   pDnode->privateIp        = pStatus->privateIp;
   pDnode->publicIp         = pStatus->publicIp;
@@ -232,6 +246,7 @@ void mgmtProcessDnodeStatusMsg(SRpcMsg *rpcMsg) {
       mPrint("dnode:%d, vgroup:%d not exist in mnode, drop it", pDnode->dnodeId, pDnode->vload[j].vgId);
       mgmtSendDropVnodeMsg(pDnode->vload[j].vgId, &ipSet, NULL);
     }
+    mgmtDecVgroupRef(pVgroup);
   }
 
   if (pDnode->status != TSDB_DN_STATUS_READY) {
@@ -240,6 +255,8 @@ void mgmtProcessDnodeStatusMsg(SRpcMsg *rpcMsg) {
     mgmtStartBalanceTimer(200);
   }
 
+  mgmtDecDnodeRef(pDnode);
+
   int32_t contLen = sizeof(SDMStatusRsp) + TSDB_MAX_VNODES * sizeof(SVnodeAccess);
   SDMStatusRsp *pRsp = rpcMallocCont(contLen);
   if (pRsp == NULL) {
@@ -339,6 +356,8 @@ static int32_t mgmtGetDnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pCo
   pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
   pShow->pNode = NULL;
 
+  mgmtDecUserRef(pUser);
+
   return 0;
 }
 
@@ -350,6 +369,7 @@ static int32_t mgmtRetrieveDnodes(SShowObj *pShow, char *data, int32_t rows, voi
   char       ipstr[32];
 
   while (numOfRows < rows) {
+    mgmtDecDnodeRef(pDnode);
     pShow->pNode = mgmtGetNextDnode(pShow->pNode, (SDnodeObj **)&pDnode);
     if (pDnode == NULL) break;
 
@@ -453,6 +473,7 @@ static int32_t mgmtGetModuleMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pC
 
   pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
   pShow->pNode = NULL;
+  mgmtDecUserRef(pUser);
 
   return 0;
 }
@@ -465,6 +486,7 @@ int32_t mgmtRetrieveModules(SShowObj *pShow, char *data, int32_t rows, void *pCo
   char       ipstr[20];
 
   while (numOfRows < rows) {
+    mgmtDecDnodeRef(pDnode);
     pShow->pNode = mgmtGetNextDnode(pShow->pNode, (SDnodeObj **)&pDnode);
     if (pDnode == NULL) break;
 
@@ -539,6 +561,7 @@ static int32_t mgmtGetConfigMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pC
 
   pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
   pShow->pNode = NULL;
+  mgmtDecUserRef(pUser);
 
   return 0;
 }
@@ -653,6 +676,8 @@ static int32_t mgmtGetVnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pCo
   } 
 
   pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
+  mgmtDecDnodeRef(pDnode);
+  mgmtDecUserRef(pUser);
 
   return 0;
 }

src/mnode/src/mgmtMnode.c

@@ -48,7 +48,7 @@ int32_t mgmtInitMnodes() {
 void mgmtCleanupMnodes() {}
 bool mgmtInServerStatus() { return tsMnodeObj.status == TSDB_MN_STATUS_SERVING; }
 bool mgmtIsMaster() { return tsMnodeObj.role == TSDB_MN_ROLE_MASTER; }
-bool mgmtCheckRedirect(void *handle) { return false; }
+bool mgmtCheckRedirect(void *thandle) { return false; }
 
 static int32_t mgmtGetMnodesNum() {
   return 1;
@@ -117,9 +117,10 @@ static int32_t mgmtGetMnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pCo
     pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
   }
 
-  pShow->numOfRows = mgmtGetDnodesNum();
+  pShow->numOfRows = mgmtGetMnodesNum();
   pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
   pShow->pNode = NULL;
+  mgmtDecUserRef(pUser);
 
   return 0;
 }
@@ -167,6 +168,7 @@ static int32_t mgmtRetrieveMnodes(SShowObj *pShow, char *data, int32_t rows, voi
   }
 
   pShow->numOfReads += numOfRows;
+
   return numOfRows;
 }
 

src/mnode/src/mgmtProfile.c

@@ -16,10 +16,13 @@
 #define _DEFAULT_SOURCE
 #include "os.h"
 #include "taosmsg.h"
+#include "mgmtDb.h"
 #include "mgmtMnode.h"
 #include "mgmtProfile.h"
 #include "mgmtShell.h"
+#include "mgmtTable.h"
 #include "mgmtUser.h"
+#include "mgmtVgroup.h"
 
 int32_t mgmtSaveQueryStreamList(SCMHeartBeatMsg *pHBMsg);
 
@@ -763,12 +766,49 @@ int32_t mgmtInitProfile() {
 void mgmtCleanUpProfile() {
 }
 
+void *mgmtMallocQueuedMsg(SRpcMsg *rpcMsg) {
+  bool usePublicIp = false;
+  SUserObj *pUser = mgmtGetUserFromConn(rpcMsg->handle, &usePublicIp);
+  if (pUser == NULL) {
+    return NULL;
+  }
+
+  SQueuedMsg *pMsg = calloc(1, sizeof(SQueuedMsg));
+  pMsg->thandle = rpcMsg->handle;
+  pMsg->msgType = rpcMsg->msgType;
+  pMsg->contLen = rpcMsg->contLen;
+  pMsg->pCont = rpcMsg->pCont;
+  pMsg->pUser = pUser;
+  pMsg->usePublicIp = usePublicIp;
+
+  return pMsg;
+}
+
 void mgmtFreeQueuedMsg(SQueuedMsg *pMsg) {
   if (pMsg != NULL) {
-    if (pMsg->pCont != NULL) {
-      rpcFreeCont(pMsg->pCont);
-      pMsg->pCont = NULL;
-    }
+    rpcFreeCont(pMsg->pCont);
+    if (pMsg->pUser) mgmtDecUserRef(pMsg->pUser);
+    if (pMsg->pDb) mgmtDecDbRef(pMsg->pDb);
+    if (pMsg->pVgroup) mgmtDecVgroupRef(pMsg->pVgroup);
+    if (pMsg->pTable) mgmtDecTableRef(pMsg->pTable);
+    // if (pMsg->pAcct) acctDecRef(pMsg->pAcct);
+    // if (pMsg->pDnode) mgmtDecTableRef(pMsg->pDnode);
     free(pMsg);
   }
+}
+
+void* mgmtCloneQueuedMsg(SQueuedMsg *pSrcMsg) {
+  SQueuedMsg *pDestMsg = calloc(1, sizeof(SQueuedMsg));
+  
+  pDestMsg->thandle = pSrcMsg->thandle;
+  pDestMsg->msgType = pSrcMsg->msgType;
+  pDestMsg->pCont   = pSrcMsg->pCont;
+  pDestMsg->contLen = pSrcMsg->contLen;
+  pDestMsg->pUser   = pSrcMsg->pUser;
+  pDestMsg->usePublicIp = pSrcMsg->usePublicIp;
+
+  pSrcMsg->pCont = NULL;
+  pSrcMsg->pUser = NULL;
+  
+  return pDestMsg;
 }
\ No newline at end of file

src/mnode/src/mgmtSdb.c

@@ -24,6 +24,7 @@
 #include "tutil.h"
 #include "hashint.h"
 #include "hashstr.h"
+
 #include "mgmtSdb.h"
 
 #define abs(x) (((x) < 0) ? -(x) : (x))
@@ -46,6 +47,7 @@ typedef struct _SSdbTable {
   int32_t     tableId;
   int32_t     hashSessions;
   int32_t     maxRowSize;
+  int32_t     refCountPos;
   int32_t     autoIndex;
   int32_t     fd;
   int64_t     numOfRows;
@@ -318,11 +320,6 @@ static int32_t sdbInitTableByFile(SSdbTable *pTable) {
       }
     } else {
       if (rowHead->version < 0) {
-        SSdbOperDesc oper = {
-          .table = pTable,
-          .pObj = pMetaRow
-        };
-        (*pTable->destroyFp)(&oper);
         (*sdbDeleteIndexFp[pTable->keyType])(pTable->iHandle, rowHead->data);
         pTable->numOfRows--;
         sdbTrace("table:%s, version:%" PRId64 " numOfRows:%d, read deleted record:%s",
@@ -338,8 +335,6 @@ static int32_t sdbInitTableByFile(SSdbTable *pTable) {
           .rowSize = rowHead->rowSize,
            .pObj = pMetaRow
         };
-        
-        (*pTable->destroyFp)(&oper);
         (*sdbDeleteIndexFp[pTable->keyType])(pTable->iHandle, rowHead->data);
         
         int32_t code = (*pTable->decodeFp)(&oper);
@@ -373,6 +368,7 @@ static int32_t sdbInitTableByFile(SSdbTable *pTable) {
       .version = pMeta->version,
     };
 
+    sdbIncRef(pTable, oper.pObj);
     int32_t code = (*pTable->insertFp)(&oper);
     if (code != TSDB_CODE_SUCCESS) {
       sdbError("table:%s, failed to insert record:%s", pTable->tableName, sdbGetkeyStr(pTable, rowHead->data));
@@ -396,6 +392,7 @@ void *sdbOpenTable(SSdbTableDesc *pDesc) {
   pTable->keyType = pDesc->keyType;
   pTable->hashSessions = pDesc->hashSessions;
   pTable->maxRowSize = pDesc->maxRowSize;
+  pTable->refCountPos = pDesc->refCountPos;
   pTable->insertFp = pDesc->insertFp;
   pTable->deleteFp = pDesc->deleteFp;
   pTable->updateFp = pDesc->updateFp;
@@ -433,6 +430,34 @@ static SRowMeta *sdbGetRowMeta(void *handle, void *key) {
   return pMeta;
 }
 
+void sdbIncRef(void *handle, void *pRow) {
+  if (pRow) {
+    SSdbTable *pTable = handle;
+    int32_t *pRefCount = (int32_t *)(pRow + pTable->refCountPos);
+    atomic_add_fetch_32(pRefCount, 1);
+    if (0) {
+      sdbTrace("table:%s, add ref to record:%s:%s:%d", pTable->tableName, pTable->tableName, sdbGetkeyStr(pTable, pRow), *pRefCount);
+    }
+  }
+}
+
+void sdbDecRef(void *handle, void *pRow) {
+  if (pRow) {
+    SSdbTable *pTable = handle;
+    int32_t *pRefCount = (int32_t *)(pRow + pTable->refCountPos);
+    int32_t  refCount = atomic_sub_fetch_32(pRefCount, 1);
+    if (0) {
+      sdbTrace("table:%s, def ref of record:%s:%s:%d", pTable->tableName, pTable->tableName, sdbGetkeyStr(pTable, pRow), *pRefCount);
+    }
+    int8_t* updateEnd = pRow + pTable->refCountPos - 1;
+    if (refCount <= 0 && *updateEnd) {
+      sdbTrace("table:%s, record:%s:%s:%d is destroyed", pTable->tableName, pTable->tableName, sdbGetkeyStr(pTable, pRow), *pRefCount);
+      SSdbOperDesc oper = {.pObj = pRow};
+      (*pTable->destroyFp)(&oper);
+    }
+  }
+}
+
 void *sdbGetRow(void *handle, void *key) {
   SSdbTable *pTable = (SSdbTable *)handle;
   SRowMeta * pMeta;
@@ -441,6 +466,7 @@ void *sdbGetRow(void *handle, void *key) {
 
   pthread_mutex_lock(&pTable->mutex);
   pMeta = (*sdbGetIndexFp[pTable->keyType])(pTable->iHandle, key);
+  if (pMeta) sdbIncRef(pTable, pMeta->row);
   pthread_mutex_unlock(&pTable->mutex);
 
   if (pMeta == NULL) {
@@ -459,6 +485,7 @@ int32_t sdbInsertRow(SSdbOperDesc *pOper) {
 
   if (sdbGetRow(pTable, pOper->pObj)) {
     sdbError("table:%s, failed to insert record:%s, already exist", pTable->tableName, sdbGetkeyStr(pTable, pOper->pObj));
+    sdbDecRef(pTable, pOper->pObj);
     return TSDB_CODE_ALREADY_THERE;
   }
 
@@ -526,6 +553,7 @@ int32_t sdbInsertRow(SSdbOperDesc *pOper) {
   rowMeta.rowSize = pOper->rowSize;
   rowMeta.row = pOper->pObj;
   (*sdbAddIndexFp[pTable->keyType])(pTable->iHandle, pOper->pObj, &rowMeta);
+  sdbIncRef(pTable, pOper->pObj);
 
   pTable->numOfRows++;  
   
@@ -626,8 +654,9 @@ int32_t sdbDeleteRow(SSdbOperDesc *pOper) {
   pthread_mutex_unlock(&pTable->mutex);
 
   (*pTable->deleteFp)(pOper);
-  (*pTable->destroyFp)(pOper);
-
+  int8_t* updateEnd = pOper->pObj + pTable->refCountPos - 1;
+  *updateEnd = 1;
+  sdbDecRef(pTable, pOper->pObj);
   return 0;
 }
 
@@ -762,6 +791,7 @@ void *sdbFetchRow(void *handle, void *pNode, void **ppRow) {
   if (pMeta == NULL) return NULL;
 
   *ppRow = pMeta->row;
+  sdbIncRef(handle, pMeta->row);
 
   return pNode;
 }

src/mnode/src/mgmtShell.c

@@ -25,7 +25,6 @@
 #include "mnode.h"
 #include "mgmtAcct.h"
 #include "mgmtBalance.h"
-#include "mgmtChildTable.h"
 #include "mgmtDb.h"
 #include "mgmtDnode.h"
 #include "mgmtGrant.h"
@@ -33,7 +32,6 @@
 #include "mgmtProfile.h"
 #include "mgmtSdb.h"
 #include "mgmtShell.h"
-#include "mgmtSuperTable.h"
 #include "mgmtTable.h"
 #include "mgmtUser.h"
 #include "mgmtVgroup.h"
@@ -42,7 +40,7 @@ typedef int32_t (*SShowMetaFp)(STableMetaMsg *pMeta, SShowObj *pShow, void *pCon
 typedef int32_t (*SShowRetrieveFp)(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 
 static int  mgmtShellRetriveAuth(char *user, char *spi, char *encrypt, char *secret, char *ckey);
-static bool mgmtCheckMsgReadOnly(int8_t type, void *pCont);
+static bool mgmtCheckMsgReadOnly(SQueuedMsg *pMsg);
 static void mgmtProcessMsgFromShell(SRpcMsg *pMsg);
 static void mgmtProcessUnSupportMsg(SRpcMsg *rpcMsg);
 static void mgmtProcessMsgWhileNotReady(SRpcMsg *rpcMsg);
@@ -121,8 +119,7 @@ void mgmtAddShellShowRetrieveHandle(uint8_t msgType, SShowRetrieveFp fp) {
 void mgmtProcessTranRequest(SSchedMsg *sched) {
   SQueuedMsg *queuedMsg = sched->msg;
   (*tsMgmtProcessShellMsgFp[queuedMsg->msgType])(queuedMsg);
-  rpcFreeCont(queuedMsg->pCont);
-  free(queuedMsg);
+  mgmtFreeQueuedMsg(queuedMsg);
 }
 
 void mgmtAddToShellQueue(SQueuedMsg *queuedMsg) {
@@ -137,6 +134,12 @@ static void mgmtProcessMsgFromShell(SRpcMsg *rpcMsg) {
     return;
   }
 
+  if (mgmtCheckRedirect(rpcMsg->handle)) {
+    // rpcSendRedirectRsp(rpcMsg->handle, mgmtGetMnodeIpListForRedirect());
+    rpcFreeCont(rpcMsg->pCont);
+    return;
+  }
+
   if (!mgmtInServerStatus()) {
     mgmtProcessMsgWhileNotReady(rpcMsg);
     rpcFreeCont(rpcMsg->pCont);
@@ -145,6 +148,7 @@ static void mgmtProcessMsgFromShell(SRpcMsg *rpcMsg) {
 
   if (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS) {
     mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_GRANT_EXPIRED);
+    rpcFreeCont(rpcMsg->pCont);
     return;
   }
 
@@ -154,50 +158,34 @@ static void mgmtProcessMsgFromShell(SRpcMsg *rpcMsg) {
     return;
   }
 
-  bool usePublicIp = false;
-  SUserObj *pUser = mgmtGetUserFromConn(rpcMsg->handle, &usePublicIp);
-  if (pUser == NULL) {
+  SQueuedMsg *pMsg = mgmtMallocQueuedMsg(rpcMsg);
+  if (pMsg == NULL) {
     mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_INVALID_USER);
     rpcFreeCont(rpcMsg->pCont);
     return;
   }
-
-  if (mgmtCheckMsgReadOnly(rpcMsg->msgType, rpcMsg->pCont)) {
-    SQueuedMsg queuedMsg = {0};
-    queuedMsg.thandle = rpcMsg->handle;
-    queuedMsg.msgType = rpcMsg->msgType;
-    queuedMsg.contLen = rpcMsg->contLen;
-    queuedMsg.pCont   = rpcMsg->pCont;
-    queuedMsg.pUser   = pUser;
-    queuedMsg.usePublicIp = usePublicIp;
-    (*tsMgmtProcessShellMsgFp[rpcMsg->msgType])(&queuedMsg);
-    rpcFreeCont(rpcMsg->pCont);
+  
+  if (mgmtCheckMsgReadOnly(pMsg)) {
+    (*tsMgmtProcessShellMsgFp[rpcMsg->msgType])(pMsg);
+    mgmtFreeQueuedMsg(pMsg);
   } else {
-    SQueuedMsg *queuedMsg = calloc(1, sizeof(SQueuedMsg));
-    queuedMsg->thandle = rpcMsg->handle;
-    queuedMsg->msgType = rpcMsg->msgType;
-    queuedMsg->contLen = rpcMsg->contLen;
-    queuedMsg->pCont   = rpcMsg->pCont;
-    queuedMsg->pUser   = pUser;
-    queuedMsg->usePublicIp = usePublicIp;
-    mgmtAddToShellQueue(queuedMsg);
+    if (!pMsg->pUser->writeAuth) {
+      mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_NO_RIGHTS);
+      mgmtFreeQueuedMsg(pMsg);
+    } else {
+      mgmtAddToShellQueue(pMsg);
+    }
   }
 }
 
 static void mgmtProcessShowMsg(SQueuedMsg *pMsg) {
   SCMShowMsg *pShowMsg = pMsg->pCont;
-  if (pShowMsg->type == TSDB_MGMT_TABLE_DNODE || TSDB_MGMT_TABLE_GRANTS || TSDB_MGMT_TABLE_SCORES) {
-    if (mgmtCheckRedirect(pMsg->thandle)) {
-      return;
-    }
-  }
-
   if (pShowMsg->type >= TSDB_MGMT_TABLE_MAX) {
     mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_INVALID_MSG_TYPE);
     return;
   }
 
-  if (!tsMgmtShowMetaFp[pShowMsg->type]) {
+  if (!tsMgmtShowMetaFp[pShowMsg->type] || !tsMgmtShowRetrieveFp[pShowMsg->type]) {
     mError("show type:%s is not support", taosGetShowTypeStr(pShowMsg->type));
     mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_OPS_NOT_SUPPORT);
     return;
@@ -311,22 +299,13 @@ static void mgmtProcessRetrieveMsg(SQueuedMsg *pMsg) {
 }
 
 static void mgmtProcessHeartBeatMsg(SQueuedMsg *pMsg) {
-  //SCMHeartBeatMsg *pHBMsg = (SCMHeartBeatMsg *) rpcMsg->pCont;
-  //mgmtSaveQueryStreamList(pHBMsg);
-
   SCMHeartBeatRsp *pHBRsp = (SCMHeartBeatRsp *) rpcMallocCont(sizeof(SCMHeartBeatRsp));
   if (pHBRsp == NULL) {
     mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SERV_OUT_OF_MEMORY);
     return;
   }
 
-  SRpcConnInfo connInfo;
-  if (rpcGetConnInfo(pMsg->thandle, &connInfo) != 0) {
-    mError("conn:%p is already released while process heart beat msg", pMsg->thandle);
-    return;
-  }
-
-  if (connInfo.serverIp == tsPublicIpInt) {
+  if (pMsg->usePublicIp) {
     mgmtGetMnodePublicIpList(&pHBRsp->ipList);
   } else {
     mgmtGetMnodePrivateIpList(&pHBRsp->ipList);
@@ -358,9 +337,11 @@ static int mgmtShellRetriveAuth(char *user, char *spi, char *encrypt, char *secr
   SUserObj *pUser = mgmtGetUser(user);
   if (pUser == NULL) {
     *secret = 0;
+    mgmtDecUserRef(pUser);
     return TSDB_CODE_INVALID_USER;
   } else {
     memcpy(secret, pUser->pass, TSDB_KEY_LEN);
+    mgmtDecUserRef(pUser);
     return TSDB_CODE_SUCCESS;
   }
 }
@@ -376,28 +357,19 @@ static void mgmtProcessConnectMsg(SQueuedMsg *pMsg) {
   }
 
   int32_t code;
-  SUserObj *pUser = mgmtGetUser(connInfo.user);
-  if (pUser == NULL) {
-    code = TSDB_CODE_INVALID_USER;
-    goto connect_over;
-  }
-
   if (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS) {
     code = TSDB_CODE_GRANT_EXPIRED;
     goto connect_over;
   }
 
-  SAcctObj *pAcct = acctGetAcct(pUser->acct);
-  if (pAcct == NULL) {
-    code = TSDB_CODE_INVALID_ACCT;
-    goto connect_over;
-  }
-
   code = taosCheckVersion(pConnectMsg->clientVersion, version, 3);
   if (code != TSDB_CODE_SUCCESS) {
     goto connect_over;
   }
 
+  SUserObj *pUser = pMsg->pUser;
+  SAcctObj *pAcct = pUser->pAcct;
+
   if (pConnectMsg->db[0]) {
     char dbName[TSDB_TABLE_ID_LEN * 3] = {0};
     sprintf(dbName, "%x%s%s", pAcct->acctId, TS_PATH_DELIMITER, pConnectMsg->db);
@@ -419,7 +391,7 @@ static void mgmtProcessConnectMsg(SQueuedMsg *pMsg) {
   pConnectRsp->writeAuth = pUser->writeAuth;
   pConnectRsp->superAuth = pUser->superAuth;
 
-  if (connInfo.serverIp == tsPublicIpInt) {
+  if (pMsg->usePublicIp) {
     mgmtGetMnodePublicIpList(&pConnectRsp->ipList);
   } else {
     mgmtGetMnodePrivateIpList(&pConnectRsp->ipList);
@@ -443,10 +415,10 @@ static void mgmtProcessUseMsg(SQueuedMsg *pMsg) {
   SCMUseDbMsg *pUseDbMsg = pMsg->pCont;
   
   // todo check for priority of current user
-  SDbObj* pDbObj = mgmtGetDb(pUseDbMsg->db);
+  pMsg->pDb = mgmtGetDb(pUseDbMsg->db);
   
   int32_t code = TSDB_CODE_SUCCESS;
-  if (pDbObj == NULL) {
+  if (pMsg->pDb == NULL) {
     code = TSDB_CODE_INVALID_DB;
   }
   
@@ -457,25 +429,29 @@ static void mgmtProcessUseMsg(SQueuedMsg *pMsg) {
 /**
  * check if we need to add mgmtProcessTableMetaMsg into tranQueue, which will be executed one-by-one.
  */
-static bool mgmtCheckMeterMetaMsgType(void *pMsg) {
-  SCMTableInfoMsg *pInfo = (SCMTableInfoMsg *) pMsg;
-  int16_t autoCreate = htons(pInfo->createFlag);
-  STableInfo *pTable = mgmtGetTable(pInfo->tableId);
+static bool mgmtCheckTableMetaMsgReadOnly(SQueuedMsg *pMsg) {
+  SCMTableInfoMsg *pInfo = pMsg->pCont;
+  pMsg->pTable = mgmtGetTable(pInfo->tableId);
+  if (pMsg->pTable != NULL) return true;
 
   // If table does not exists and autoCreate flag is set, we add the handler into task queue
-  bool addIntoTranQueue = (pTable == NULL && autoCreate == 1);
-  if (addIntoTranQueue) {
+  int16_t autoCreate = htons(pInfo->createFlag);
+  if (autoCreate == 1) {
     mTrace("table:%s auto created task added", pInfo->tableId);
+    return false;
   }
-
-  return addIntoTranQueue;
+  
+  return true;
 }
 
-static bool mgmtCheckMsgReadOnly(int8_t type, void *pCont) {
-  if ((type == TSDB_MSG_TYPE_CM_TABLE_META && (!mgmtCheckMeterMetaMsgType(pCont)))  ||
-       type == TSDB_MSG_TYPE_CM_STABLE_VGROUP || type == TSDB_MSG_TYPE_RETRIEVE ||
-       type == TSDB_MSG_TYPE_CM_SHOW || type == TSDB_MSG_TYPE_CM_TABLES_META      ||
-       type == TSDB_MSG_TYPE_CM_CONNECT) {
+static bool mgmtCheckMsgReadOnly(SQueuedMsg *pMsg) {
+  if (pMsg->msgType == TSDB_MSG_TYPE_CM_TABLE_META) {
+    return mgmtCheckTableMetaMsgReadOnly(pMsg);
+  }
+
+  if (pMsg->msgType == TSDB_MSG_TYPE_CM_STABLE_VGROUP || pMsg->msgType == TSDB_MSG_TYPE_RETRIEVE       ||
+      pMsg->msgType == TSDB_MSG_TYPE_CM_SHOW          || pMsg->msgType == TSDB_MSG_TYPE_CM_TABLES_META ||
+      pMsg->msgType == TSDB_MSG_TYPE_CM_CONNECT) {
     return true;
   }
 

src/mnode/src/mgmtUser.c

@@ -25,14 +25,10 @@
 #include "mgmtShell.h"
 #include "mgmtUser.h"
 
-void * tsUserSdb = NULL;
+void *  tsUserSdb = NULL;
 static int32_t tsUserUpdateSize = 0;
-
-static int32_t mgmtDropUser(SAcctObj *pAcct, char *name);
-static int32_t mgmtUpdateUser(SUserObj *pUser);
 static int32_t mgmtGetUserMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
 static int32_t mgmtRetrieveUsers(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-
 static void mgmtProcessCreateUserMsg(SQueuedMsg *pMsg);
 static void mgmtProcessAlterUserMsg(SQueuedMsg *pMsg);
 static void mgmtProcessDropUserMsg(SQueuedMsg *pMsg);
@@ -101,6 +97,7 @@ int32_t mgmtInitUsers() {
     .tableName    = "users",
     .hashSessions = TSDB_MAX_USERS,
     .maxRowSize   = tsUserUpdateSize,
+    .refCountPos  = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj,
     .keyType      = SDB_KEY_TYPE_STRING,
     .insertFp     = mgmtUserActionInsert,
     .deleteFp     = mgmtUserActionDelete,
@@ -120,6 +117,7 @@ int32_t mgmtInitUsers() {
   mgmtCreateUser(pAcct, "root", "taosdata");
   mgmtCreateUser(pAcct, "monitor", tsInternalPass);
   mgmtCreateUser(pAcct, "_root", tsInternalPass);
+  acctDecRef(pAcct);
 
   mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_CREATE_USER, mgmtProcessCreateUserMsg);
   mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_ALTER_USER, mgmtProcessAlterUserMsg);
@@ -139,6 +137,14 @@ SUserObj *mgmtGetUser(char *name) {
   return (SUserObj *)sdbGetRow(tsUserSdb, name);
 }
 
+void mgmtIncUserRef(SUserObj *pUser) { 
+  return sdbIncRef(tsUserSdb, pUser); 
+}
+
+void mgmtDecUserRef(SUserObj *pUser) { 
+  return sdbDecRef(tsUserSdb, pUser); 
+}
+
 static int32_t mgmtUpdateUser(SUserObj *pUser) {
   SSdbOperDesc oper = {
     .type = SDB_OPER_TYPE_GLOBAL,
@@ -149,7 +155,6 @@ static int32_t mgmtUpdateUser(SUserObj *pUser) {
 
   int32_t code = sdbUpdateRow(&oper);
   if (code != TSDB_CODE_SUCCESS) {
-    tfree(pUser);
     code = TSDB_CODE_SDB_ERROR;
   }
 
@@ -166,9 +171,10 @@ int32_t mgmtCreateUser(SAcctObj *pAcct, char *name, char *pass) {
     return TSDB_CODE_INVALID_MSG;
   }
 
-  SUserObj *pUser = (SUserObj *)sdbGetRow(tsUserSdb, name);
+  SUserObj *pUser = mgmtGetUser(name);
   if (pUser != NULL) {
     mTrace("user:%s is already there", name);
+    mgmtDecUserRef(pUser);
     return TSDB_CODE_USER_ALREADY_EXIST;
   }
 
@@ -204,19 +210,7 @@ int32_t mgmtCreateUser(SAcctObj *pAcct, char *name, char *pass) {
   return code;
 }
 
-static int32_t mgmtDropUser(SAcctObj *pAcct, char *name) {
-  SUserObj *pUser;
-
-  pUser = (SUserObj *)sdbGetRow(tsUserSdb, name);
-  if (pUser == NULL) {
-    mWarn("user:%s is not there", name);
-    return TSDB_CODE_INVALID_USER;
-  }
-
-  if (strcmp(pAcct->user, pUser->acct) != 0) {
-    return TSDB_CODE_NO_RIGHTS;
-  }
-
+static int32_t mgmtDropUser(SUserObj *pUser) {
   SSdbOperDesc oper = {
     .type = SDB_OPER_TYPE_GLOBAL,
     .table = tsUserSdb,
@@ -268,9 +262,9 @@ static int32_t mgmtGetUserMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pCon
   }
 
   pShow->numOfRows = pUser->pAcct->acctInfo.numOfUsers;
-  pShow->pNode = pUser->pAcct->pUser;
   pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
 
+  mgmtDecUserRef(pUser);
   return 0;
 }
 
@@ -281,10 +275,9 @@ static int32_t mgmtRetrieveUsers(SShowObj *pShow, char *data, int32_t rows, void
   char     *pWrite;
 
   while (numOfRows < rows) {
-    pUser = (SUserObj *)pShow->pNode;
+    pShow->pNode = sdbFetchRow(tsUserSdb, pShow->pNode, (void **) &pUser);
     if (pUser == NULL) break;
-    pShow->pNode = (void *)pUser->next;
-
+    
     cols = 0;
 
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
@@ -306,6 +299,7 @@ static int32_t mgmtRetrieveUsers(SShowObj *pShow, char *data, int32_t rows, void
     cols++;
 
     numOfRows++;
+    mgmtDecUserRef(pUser);
   }
   pShow->numOfReads += numOfRows;
   return numOfRows;
@@ -357,6 +351,7 @@ static void mgmtProcessAlterUserMsg(SQueuedMsg *pMsg) {
 
   if (strcmp(pUser->user, "monitor") == 0 || (strcmp(pUser->user + 1, pUser->acct) == 0 && pUser->user[0] == '_')) {
     mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_NO_RIGHTS);
+    mgmtDecUserRef(pUser);
     return;
   }
 
@@ -386,10 +381,7 @@ static void mgmtProcessAlterUserMsg(SQueuedMsg *pMsg) {
     }
 
     mgmtSendSimpleResp(pMsg->thandle, code);
-    return;
-  }
-
-  if ((pAlter->flag & TSDB_ALTER_USER_PRIVILEGES) != 0) {
+  } else if ((pAlter->flag & TSDB_ALTER_USER_PRIVILEGES) != 0) {
     bool hasRight = false;
 
     if (strcmp(pUser->user, "root") == 0) {
@@ -431,10 +423,11 @@ static void mgmtProcessAlterUserMsg(SQueuedMsg *pMsg) {
     }
 
     mgmtSendSimpleResp(pMsg->thandle, code);
-    return;
+  } else {
+    mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_NO_RIGHTS);
   }
 
-  mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_NO_RIGHTS);
+  mgmtDecUserRef(pUser);
 }
 
 static void mgmtProcessDropUserMsg(SQueuedMsg *pMsg) {
@@ -453,6 +446,7 @@ static void mgmtProcessDropUserMsg(SQueuedMsg *pMsg) {
   if (strcmp(pUser->user, "monitor") == 0 || strcmp(pUser->user, pUser->acct) == 0 ||
     (strcmp(pUser->user + 1, pUser->acct) == 0 && pUser->user[0] == '_')) {
     mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_NO_RIGHTS);
+    mgmtDecUserRef(pUser);
     return ;
   }
 
@@ -464,9 +458,7 @@ static void mgmtProcessDropUserMsg(SQueuedMsg *pMsg) {
   } else if (strcmp(pUser->user, pOperUser->user) == 0) {
     hasRight = false;
   } else if (pOperUser->superAuth) {
-    if (strcmp(pUser->user, "root") == 0) {
-      hasRight = false;
-    } else if (strcmp(pOperUser->acct, pUser->acct) != 0) {
+    if (strcmp(pOperUser->acct, pUser->acct) != 0) {
       hasRight = false;
     } else {
       hasRight = true;
@@ -474,22 +466,23 @@ static void mgmtProcessDropUserMsg(SQueuedMsg *pMsg) {
   }
 
   if (hasRight) {
-    code = mgmtDropUser(pUser->pAcct, pDrop->user);
+    code = mgmtDropUser(pUser);
     if (code == TSDB_CODE_SUCCESS) {
-       mLPrint("user:%s is dropped by %s, result:%d", pUser->user, pOperUser->user, tstrerror(code));
+       mLPrint("user:%s is dropped by %s, result:%s", pUser->user, pOperUser->user, tstrerror(code));
     }
   } else {
     code = TSDB_CODE_NO_RIGHTS;
   }
 
   mgmtSendSimpleResp(pMsg->thandle, code);
+  mgmtDecUserRef(pUser);
 }
 
 void  mgmtDropAllUsers(SAcctObj *pAcct)  {
-  void *pNode = NULL;
-  void *pLastNode = NULL;
-  int32_t numOfUsers = 0;
-  int32_t acctNameLen = strlen(pAcct->user);
+  void *    pNode = NULL;
+  void *    pLastNode = NULL;
+  int32_t   numOfUsers = 0;
+  int32_t   acctNameLen = strlen(pAcct->user);
   SUserObj *pUser = NULL;
 
   while (1) {
@@ -506,8 +499,9 @@ void  mgmtDropAllUsers(SAcctObj *pAcct)  {
       sdbDeleteRow(&oper);
       pNode = pLastNode;
       numOfUsers++;
-      continue;
     }
+
+    mgmtDecUserRef(pUser);
   }
 
   mTrace("acct:%s, all users:%d is dropped from sdb", pAcct->user, numOfUsers);

src/mnode/src/mgmtVgroup.c

@@ -20,7 +20,6 @@
 #include "tstatus.h"
 #include "mnode.h"
 #include "mgmtBalance.h"
-#include "mgmtChildTable.h"
 #include "mgmtDb.h"
 #include "mgmtDClient.h"
 #include "mgmtDnode.h"
@@ -59,6 +58,7 @@ static int32_t mgmtVgroupActionDestroy(SSdbOperDesc *pOper) {
     if (pDnode) {
       atomic_sub_fetch_32(&pDnode->openVnodes, 1);
     }
+    mgmtDecDnodeRef(pDnode);
   }
 
   tfree(pOper->pObj);
@@ -71,6 +71,7 @@ static int32_t mgmtVgroupActionInsert(SSdbOperDesc *pOper) {
   if (pDb == NULL) {
     return TSDB_CODE_INVALID_DB;
   }
+  mgmtDecDbRef(pDb);
 
   pVgroup->pDb = pDb;
   pVgroup->prev = NULL;
@@ -96,6 +97,7 @@ static int32_t mgmtVgroupActionInsert(SSdbOperDesc *pOper) {
     pVgroup->vnodeGid[i].publicIp = pDnode->publicIp;
     pVgroup->vnodeGid[i].vnode = pVgroup->vgId;
     atomic_add_fetch_32(&pDnode->openVnodes, 1);
+    mgmtDecDnodeRef(pDnode);
   }
 
   mgmtAddVgroupIntoDb(pVgroup);
@@ -110,6 +112,7 @@ static int32_t mgmtVgroupActionDelete(SSdbOperDesc *pOper) {
     mgmtRemoveVgroupFromDb(pVgroup);
   }
 
+  mgmtDecDbRef(pVgroup->pDb);
   return TSDB_CODE_SUCCESS;
 }
 
@@ -159,6 +162,7 @@ int32_t mgmtInitVgroups() {
     .tableName    = "vgroups",
     .hashSessions = TSDB_MAX_VGROUPS,
     .maxRowSize   = tsVgUpdateSize,
+    .refCountPos  = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj,
     .keyType      = SDB_KEY_TYPE_AUTO,
     .insertFp     = mgmtVgroupActionInsert,
     .deleteFp     = mgmtVgroupActionDelete,
@@ -184,6 +188,14 @@ int32_t mgmtInitVgroups() {
   return 0;
 }
 
+void mgmtIncVgroupRef(SVgObj *pVgroup) { 
+  return sdbIncRef(tsVgroupSdb, pVgroup); 
+}
+
+void mgmtDecVgroupRef(SVgObj *pVgroup) { 
+  return sdbDecRef(tsVgroupSdb, pVgroup); 
+}
+
 SVgObj *mgmtGetVgroup(int32_t vgId) {
   return (SVgObj *)sdbGetRow(tsVgroupSdb, &vgId);
 }
@@ -192,15 +204,7 @@ SVgObj *mgmtGetAvailableVgroup(SDbObj *pDb) {
   return pDb->pHead;
 }
 
-void mgmtCreateVgroup(SQueuedMsg *pMsg) {
-  SDbObj *pDb = pMsg->pDb;
-  if (pDb == NULL) {
-    mError("failed to create vgroup, db not found");
-    mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_INVALID_DB);
-    mgmtFreeQueuedMsg(pMsg);
-    return;
-  }
-
+void mgmtCreateVgroup(SQueuedMsg *pMsg, SDbObj *pDb) {
   SVgObj *pVgroup = (SVgObj *)calloc(1, sizeof(SVgObj));
   strcpy(pVgroup->dbName, pDb->name);
   pVgroup->numOfVnodes = pDb->cfg.replications;
@@ -287,16 +291,16 @@ int32_t mgmtGetVgroupMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
 
   int32_t maxReplica = 0;
   SVgObj  *pVgroup   = NULL;
-  SChildTableObj *pTable = NULL;
+  STableInfo *pTable = NULL;
   if (pShow->payloadLen > 0 ) {
-    pTable = mgmtGetChildTable(pShow->payload);
-    if (NULL == pTable) {
+    pTable = mgmtGetTable(pShow->payload);
+    if (NULL == pTable || pTable->type == TSDB_SUPER_TABLE) {
       return TSDB_CODE_INVALID_TABLE_ID;
     }
-
-    pVgroup = mgmtGetVgroup(pTable->vgId);
+    mgmtDecTableRef(pTable);
+    pVgroup = mgmtGetVgroup(((SChildTableObj*)pTable)->vgId);
     if (NULL == pVgroup) return TSDB_CODE_INVALID_TABLE_ID;
-
+    mgmtDecVgroupRef(pVgroup);
     maxReplica = pVgroup->numOfVnodes > maxReplica ? pVgroup->numOfVnodes : maxReplica;
   } else {
     SVgObj *pVgroup = pDb->pHead;
@@ -348,6 +352,8 @@ int32_t mgmtGetVgroupMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
     pShow->pNode = pVgroup;
   }
 
+   mgmtDecDbRef(pDb);
+
   return 0;
 }
 
@@ -357,6 +363,7 @@ char *mgmtGetVnodeStatus(SVgObj *pVgroup, SVnodeGid *pVnode) {
     mError("vgroup:%d, not exist in dnode:%d", pVgroup->vgId, pDnode->dnodeId);
     return "null";
   }
+  mgmtDecDnodeRef(pDnode);
 
   if (pDnode->status == TSDB_DN_STATUS_OFFLINE) {
     return "offline";
@@ -436,6 +443,8 @@ int32_t mgmtRetrieveVgroups(SShowObj *pShow, char *data, int32_t rows, void *pCo
   }
 
   pShow->numOfReads += numOfRows;
+  mgmtDecDbRef(pDb);
+
   return numOfRows;
 }
 
@@ -445,7 +454,8 @@ void mgmtAddTableIntoVgroup(SVgObj *pVgroup, SChildTableObj *pTable) {
     taosIdPoolMarkStatus(pVgroup->idPool, pTable->sid);
     pVgroup->numOfTables++;
   }
-
+  
+  mgmtIncVgroupRef(pVgroup);
   if (pVgroup->numOfTables >= pVgroup->pDb->cfg.maxSessions)
     mgmtAddVgroupIntoDbTail(pVgroup);
 }
@@ -457,6 +467,7 @@ void mgmtRemoveTableFromVgroup(SVgObj *pVgroup, SChildTableObj *pTable) {
     pVgroup->numOfTables--;
   }
 
+  mgmtDecVgroupRef(pVgroup);
   if (pVgroup->numOfTables >= pVgroup->pDb->cfg.maxSessions)
     mgmtAddVgroupIntoDbTail(pVgroup);
 }
@@ -554,15 +565,7 @@ static void mgmtProcessCreateVnodeRsp(SRpcMsg *rpcMsg) {
   if (queueMsg->received != queueMsg->expected) return;
 
   if (queueMsg->received == queueMsg->successed) {
-    SQueuedMsg *newMsg = calloc(1, sizeof(SQueuedMsg));
-    newMsg->msgType = queueMsg->msgType;
-    newMsg->thandle = queueMsg->thandle;
-    newMsg->pDb     = queueMsg->pDb;
-    newMsg->pUser   = queueMsg->pUser;
-    newMsg->contLen = queueMsg->contLen;
-    newMsg->pCont   = rpcMallocCont(newMsg->contLen);
-    memcpy(newMsg->pCont, queueMsg->pCont, newMsg->contLen);
-    queueMsg->pCont = NULL;
+    SQueuedMsg *newMsg = mgmtCloneQueuedMsg(queueMsg);
     mgmtAddToShellQueue(newMsg);
   } else {
     SSdbOperDesc oper = {
@@ -638,14 +641,7 @@ static void mgmtProcessDropVnodeRsp(SRpcMsg *rpcMsg) {
     code = TSDB_CODE_SDB_ERROR;
   }
 
-  SQueuedMsg *newMsg = calloc(1, sizeof(SQueuedMsg));
-  newMsg->msgType = queueMsg->msgType;
-  newMsg->thandle = queueMsg->thandle;
-  newMsg->pDb     = queueMsg->pDb;
-  newMsg->pUser   = queueMsg->pUser;
-  newMsg->contLen = queueMsg->contLen;
-  newMsg->pCont   = rpcMallocCont(newMsg->contLen);
-  memcpy(newMsg->pCont, queueMsg->pCont, newMsg->contLen);
+  SQueuedMsg *newMsg = mgmtCloneQueuedMsg(queueMsg);
   mgmtAddToShellQueue(newMsg);
 
   queueMsg->pCont = NULL;
@@ -665,6 +661,7 @@ static void mgmtProcessVnodeCfgMsg(SRpcMsg *rpcMsg) {
     mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_NOT_ACTIVE_VNODE);
     return;
   }
+  mgmtDecDnodeRef(pDnode);
 
   SVgObj *pVgroup = mgmtGetVgroup(pCfg->vgId);
   if (pVgroup == NULL) {
@@ -672,6 +669,7 @@ static void mgmtProcessVnodeCfgMsg(SRpcMsg *rpcMsg) {
     mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_NOT_ACTIVE_VNODE);
     return;
   }
+  mgmtDecVgroupRef(pVgroup);
 
   mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_SUCCESS);
 
@@ -687,6 +685,7 @@ void mgmtDropAllVgroups(SDbObj *pDropDb) {
   SVgObj *pVgroup = NULL;
 
   while (1) {
+    mgmtDecVgroupRef(pVgroup);
     pNode = sdbFetchRow(tsVgroupSdb, pNode, (void **)&pVgroup);
     if (pVgroup == NULL) break;
 

src/os/linux/src/tlinux.c

@@ -236,7 +236,7 @@ void *taosProcessAlarmSignal(void *tharg) {
   void (*callback)(int) = tharg;
 
   timer_t         timerId;
-  struct sigevent sevent;
+  struct sigevent sevent = {0};
 
   #ifdef _ALPINE
     sevent.sigev_notify = SIGEV_THREAD;

src/query/inc/qast.h

@@ -16,6 +16,7 @@
 #ifndef TDENGINE_TAST_H
 #define TDENGINE_TAST_H
 
+#include <tbuffer.h>
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -27,14 +28,14 @@ extern "C" {
 #include "taosdef.h"
 #include "tvariant.h"
 
-struct tSQLSyntaxNode;
+struct tExprNode;
 struct SSchema;
 struct tSkipList;
 struct tSkipListNode;
 
 enum {
-  TSQL_NODE_EXPR = 0x1,
-  TSQL_NODE_COL = 0x2,
+  TSQL_NODE_EXPR  = 0x1,
+  TSQL_NODE_COL   = 0x2,
   TSQL_NODE_VALUE = 0x4,
 };
 
@@ -60,44 +61,41 @@ typedef struct SBinaryFilterSupp {
   void *                 pExtInfo;
 } SBinaryFilterSupp;
 
-typedef struct tSQLSyntaxNode {
+typedef struct tExprNode {
   uint8_t nodeType;
   union {
     struct {
-      uint8_t optr;  // filter operator
-      uint8_t hasPK; // 0: do not contain primary filter, 1: contain
-      void *  info;  // support filter operation on this expression only available for leaf node
+      uint8_t optr;             // filter operator
+      uint8_t hasPK;            // 0: do not contain primary filter, 1: contain
+      void *  info;             // support filter operation on this expression only available for leaf node
       
-      struct tSQLSyntaxNode *pLeft;  // left child pointer
-      struct tSQLSyntaxNode *pRight; // right child pointer
+      struct tExprNode *pLeft;  // left child pointer
+      struct tExprNode *pRight; // right child pointer
     } _node;
     struct SSchema *pSchema;
     tVariant *      pVal;
   };
-} tSQLSyntaxNode;
+} tExprNode;
 
+void tSQLBinaryExprFromString(tExprNode **pExpr, SSchema *pSchema, int32_t numOfCols, char *src, int32_t len);
 
-typedef struct tQueryResultset {
-  void ** pRes;
-  int64_t num;
-} tQueryResultset;
+void tSQLBinaryExprToString(tExprNode *pExpr, char *dst, int32_t *len);
 
-void tSQLBinaryExprFromString(tSQLSyntaxNode **pExpr, SSchema *pSchema, int32_t numOfCols, char *src, int32_t len);
+void tExprTreeDestroy(tExprNode **pExprs, void (*fp)(void*));
 
-void tSQLBinaryExprToString(tSQLSyntaxNode *pExpr, char *dst, int32_t *len);
+void tSQLBinaryExprTraverse(tExprNode *pExpr, SSkipList *pSkipList, SArray *result, SBinaryFilterSupp *param);
 
-void tSQLBinaryExprDestroy(tSQLSyntaxNode **pExprs, void (*fp)(void*));
-
-void tSQLBinaryExprTraverse(tSQLSyntaxNode *pExpr, SSkipList *pSkipList, SArray *result, SBinaryFilterSupp *param);
-
-void tSQLBinaryExprCalcTraverse(tSQLSyntaxNode *pExprs, int32_t numOfRows, char *pOutput, void *param, int32_t order,
+void tSQLBinaryExprCalcTraverse(tExprNode *pExprs, int32_t numOfRows, char *pOutput, void *param, int32_t order,
                                 char *(*cb)(void *, char *, int32_t));
 
-void tSQLBinaryExprTrv(tSQLSyntaxNode *pExprs, int32_t *val, int16_t *ids);
-void tQueryResultClean(tQueryResultset *pRes);
+void tSQLBinaryExprTrv(tExprNode *pExprs, int32_t *val, int16_t *ids);
 
 uint8_t getBinaryExprOptr(SSQLToken *pToken);
 
+SBuffer exprTreeToBinary(tExprNode* pExprTree);
+
+tExprNode* exprTreeFromBinary(const void* pBuf, size_t size);
+
 #ifdef __cplusplus
 }
 #endif

src/query/inc/qsqlparser.h

@@ -13,8 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_QASTDEF_H
-#define TDENGINE_QASTDEF_H
+#ifndef TDENGINE_QSQLPARSER_H
+#define TDENGINE_QSQLPARSER_H
 
 #ifdef __cplusplus
 extern "C" {
@@ -329,4 +329,4 @@ int32_t tSQLParse(SSqlInfo *pSQLInfo, const char *pSql);
 }
 #endif
 
-#endif  // TDENGINE_QASTDEF_H
+#endif  // TDENGINE_QSQLPARSER_H

src/query/src/qtokenizer.c

@@ -13,10 +13,10 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "os.h"
+
 #include "hash.h"
 #include "hashfunc.h"
-#include "os.h"
-#include "shash.h"
 #include "taosdef.h"
 #include "tstoken.h"
 #include "ttokendef.h"

src/query/src/queryExecutor.c

@@ -87,8 +87,6 @@ typedef enum {
 static void setQueryStatus(SQuery *pQuery, int8_t status);
 bool        isIntervalQuery(SQuery *pQuery) { return pQuery->intervalTime > 0; }
 
-int32_t setQueryCtxForTableQuery(void *pReadMsg, SQInfo **pQInfo) {}
-
 enum {
   TS_JOIN_TS_EQUAL = 0,
   TS_JOIN_TS_NOT_EQUALS = 1,
@@ -1021,7 +1019,7 @@ static int32_t setGroupResultOutputBuf(SQueryRuntimeEnv *pRuntimeEnv, char *pDat
   return TSDB_CODE_SUCCESS;
 }
 
-static char *getGroupbyColumnData(SQuery *pQuery, SData **data, int16_t *type, int16_t *bytes) {
+static UNUSED_FUNC char *getGroupbyColumnData(SQuery *pQuery, SData **data, int16_t *type, int16_t *bytes) {
   char *groupbyColumnData = NULL;
 
   SSqlGroupbyExpr *pGroupbyExpr = pQuery->pGroupbyExpr;
@@ -1295,7 +1293,7 @@ static int32_t rowwiseApplyAllFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStat
   return num;
 }
 
-static int32_t reviseForwardSteps(SQueryRuntimeEnv *pRuntimeEnv, int32_t forwardStep) {
+static UNUSED_FUNC int32_t reviseForwardSteps(SQueryRuntimeEnv *pRuntimeEnv, int32_t forwardStep) {
   /*
    * 1. If value filter exists, we try all data in current block, and do not set the QUERY_RESBUF_FULL flag.
    *
@@ -1719,7 +1717,7 @@ void doGetAlignedIntervalQueryRangeImpl(SQuery *pQuery, int64_t key, int64_t key
   }
 }
 
-static bool doGetQueryPos(TSKEY key, SQInfo *pQInfo, SPointInterpoSupporter *pPointInterpSupporter) {
+static UNUSED_FUNC bool doGetQueryPos(TSKEY key, SQInfo *pQInfo, SPointInterpoSupporter *pPointInterpSupporter) {
 #if 0
   SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
   SQuery *          pQuery = pRuntimeEnv->pQuery;
@@ -1742,7 +1740,7 @@ static bool doGetQueryPos(TSKEY key, SQInfo *pQInfo, SPointInterpoSupporter *pPo
 #endif
 }
 
-static bool doSetDataInfo(SQInfo *pQInfo, SPointInterpoSupporter *pPointInterpSupporter, void *pMeterObj,
+static UNUSED_FUNC bool doSetDataInfo(SQInfo *pQInfo, SPointInterpoSupporter *pPointInterpSupporter, void *pMeterObj,
                           TSKEY nextKey) {
   SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
   SQuery *          pQuery = pRuntimeEnv->pQuery;
@@ -2175,7 +2173,7 @@ void pointInterpSupporterDestroy(SPointInterpoSupporter *pPointInterpSupport) {
   pPointInterpSupport->numOfCols = 0;
 }
 
-static void allocMemForInterpo(SQInfo *pQInfo, SQuery *pQuery, void *pMeterObj) {
+static UNUSED_FUNC void allocMemForInterpo(SQInfo *pQInfo, SQuery *pQuery, void *pMeterObj) {
 #if 0
   if (pQuery->interpoType != TSDB_INTERPO_NONE) {
     assert(isIntervalQuery(pQuery) || (pQuery->intervalTime == 0 && isPointInterpoQuery(pQuery)));
@@ -2609,7 +2607,6 @@ static int64_t doScanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
          GET_QINFO_ADDR(pRuntimeEnv), pQuery->window.skey, pQuery->window.ekey, pQuery->lastKey, pQuery->order.order);
 
   tsdb_query_handle_t pQueryHandle = pRuntimeEnv->pQueryHandle;
-
   while (tsdbNextDataBlock(pQueryHandle)) {
     // check if query is killed or not set the status of query to pass the status check
     if (isQueryKilled(GET_QINFO_ADDR(pRuntimeEnv))) {
@@ -2768,7 +2765,7 @@ static void doMerge(SQueryRuntimeEnv *pRuntimeEnv, int64_t timestamp, SWindowRes
   }
 }
 
-static void printBinaryData(int32_t functionId, char *data, int32_t srcDataType) {
+static UNUSED_FUNC void printBinaryData(int32_t functionId, char *data, int32_t srcDataType) {
   if (functionId == TSDB_FUNC_FIRST_DST || functionId == TSDB_FUNC_LAST_DST) {
     switch (srcDataType) {
       case TSDB_DATA_TYPE_BINARY:
@@ -4038,7 +4035,7 @@ bool vnodeHasRemainResults(void *handle) {
   }
 }
 
-static int32_t resultInterpolate(SQInfo *pQInfo, tFilePage **data, tFilePage **pDataSrc, int32_t numOfRows,
+static UNUSED_FUNC int32_t resultInterpolate(SQInfo *pQInfo, tFilePage **data, tFilePage **pDataSrc, int32_t numOfRows,
                                  int32_t outputRows) {
 #if 0
   SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
@@ -4130,6 +4127,8 @@ int32_t vnodeQueryResultInterpolate(SQInfo *pQInfo, tFilePage **pDst, tFilePage
     }
   }
 #endif
+
+  return 0;
 }
 
 void vnodePrintQueryStatistics(SQInfo *pQInfo) {
@@ -4300,7 +4299,7 @@ int32_t doInitializeQInfo(SQInfo *pQInfo, void *param, void* tsdb, bool isSTable
   return TSDB_CODE_SUCCESS;
 }
 
-static bool isGroupbyEachTable(SSqlGroupbyExpr *pGroupbyExpr, tSidSet *pSidset) {
+static UNUSED_FUNC bool isGroupbyEachTable(SSqlGroupbyExpr *pGroupbyExpr, tSidSet *pSidset) {
   if (pGroupbyExpr == NULL || pGroupbyExpr->numOfGroupCols == 0) {
     return false;
   }
@@ -4316,7 +4315,7 @@ static bool isGroupbyEachTable(SSqlGroupbyExpr *pGroupbyExpr, tSidSet *pSidset)
   return false;
 }
 
-static bool doCheckWithPrevQueryRange(SQuery *pQuery, TSKEY nextKey) {
+static UNUSED_FUNC bool doCheckWithPrevQueryRange(SQuery *pQuery, TSKEY nextKey) {
   if ((nextKey > pQuery->window.ekey && QUERY_IS_ASC_QUERY(pQuery)) ||
       (nextKey < pQuery->window.ekey && !QUERY_IS_ASC_QUERY(pQuery))) {
     return false;
@@ -4325,7 +4324,7 @@ static bool doCheckWithPrevQueryRange(SQuery *pQuery, TSKEY nextKey) {
   return true;
 }
 
-static void enableExecutionForNextTable(SQueryRuntimeEnv *pRuntimeEnv) {
+static UNUSED_FUNC void enableExecutionForNextTable(SQueryRuntimeEnv *pRuntimeEnv) {
   SQuery *pQuery = pRuntimeEnv->pQuery;
 
   for (int32_t i = 0; i < pQuery->numOfOutputCols; ++i) {
@@ -4443,7 +4442,7 @@ static bool multimeterMultioutputHelper(SQInfo *pQInfo, bool *dataInDisk, bool *
   return true;
 }
 
-static int64_t doCheckMetersInGroup(SQInfo *pQInfo, int32_t index, int32_t start) {
+static UNUSED_FUNC int64_t doCheckMetersInGroup(SQInfo *pQInfo, int32_t index, int32_t start) {
   SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
   SQuery *          pQuery = pRuntimeEnv->pQuery;
 
@@ -5149,7 +5148,7 @@ static void singleTableQueryImpl(SQInfo* pQInfo) {
   int64_t st = taosGetTimestampUs();
   
   // group by normal column, sliding window query, interval query are handled by interval query processor
-  if (pQuery->intervalTime != 0 || isGroupbyNormalCol(pQuery->pGroupbyExpr)) {  // interval (down sampling operation)
+  if (isIntervalQuery(pQuery) || isGroupbyNormalCol(pQuery->pGroupbyExpr)) {  // interval (down sampling operation)
     tableIntervalProcessor(pQInfo);
   } else {
     if (isFixedOutputQuery(pQuery)) {
@@ -5461,7 +5460,7 @@ static int32_t buildAirthmeticExprFromMsg(SSqlFunctionExpr *pExpr, SQueryTableMs
   SSqlBinaryExprInfo *pBinaryExprInfo = &pExpr->binExprInfo;
   SColumnInfo *       pColMsg = pQueryMsg->colList;
 #if 0
-  tSQLSyntaxNode* pBinExpr = NULL;
+  tExprNode* pBinExpr = NULL;
   SSchema*        pSchema = toSchema(pQueryMsg, pColMsg, pQueryMsg->numOfCols);
   
   dTrace("qmsg:%p create binary expr from string:%s", pQueryMsg, pExpr->pBase.arg[0].argValue.pz);
@@ -5527,8 +5526,6 @@ static int32_t createSqlFunctionExprFromMsg(SQueryTableMsg *pQueryMsg, SSqlFunct
     int16_t type = 0;
     int16_t bytes = 0;
 
-    SColIndexEx *pColumnIndexExInfo = &pExprs[i].pBase.colInfo;
-
     // parse the arithmetic expression
     if (pExprs[i].pBase.functionId == TSDB_FUNC_ARITHM) {
       code = buildAirthmeticExprFromMsg(&pExprs[i], pQueryMsg);
@@ -5962,7 +5959,7 @@ static void freeQInfo(SQInfo *pQInfo) {
       
       if (pBinExprInfo->numOfCols > 0) {
         tfree(pBinExprInfo->pReqColumns);
-        tSQLBinaryExprDestroy(&pBinExprInfo->pBinExpr, NULL);
+        tExprTreeDestroy(&pBinExprInfo->pBinExpr, NULL);
       }
     }
     

src/query/src/queryUtil.c

@@ -24,6 +24,7 @@
 #include "ttime.h"
 
 #include "queryExecutor.h"
+#include "queryUtil.h"
 
 int32_t initWindowResInfo(SWindowResInfo *pWindowResInfo, SQueryRuntimeEnv *pRuntimeEnv, int32_t size,
                           int32_t threshold, int16_t type) {

src/rpc/src/rpcMain.c

@@ -840,7 +840,7 @@ static void rpcProcessBrokenLink(SRpcConn *pConn) {
     rpcMsg.handle = pConn;
     rpcMsg.msgType = pConn->inType;
     rpcMsg.code = TSDB_CODE_NETWORK_UNAVAIL;
-    (*(pRpc->cfp))(&rpcMsg);
+    // (*(pRpc->cfp))(&rpcMsg);
   }
  
   rpcCloseConn(pConn);
@@ -1169,7 +1169,7 @@ static void rpcProcessIdleTimer(void *param, void *tmrId) {
       rpcMsg.handle = pConn;
       rpcMsg.msgType = pConn->inType;
       rpcMsg.code = TSDB_CODE_NETWORK_UNAVAIL; 
-      (*(pRpc->cfp))(&rpcMsg);
+      // (*(pRpc->cfp))(&rpcMsg);
     }
     rpcCloseConn(pConn);
   } else {

src/util/inc/tbuffer.h

@@ -13,14 +13,15 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <stddef.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <setjmp.h>
-
 #ifndef TDENGINE_TBUFFER_H
 #define TDENGINE_TBUFFER_H
 
+#include "setjmp.h"
+#include "os.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 /*
 SBuffer can be used to read or write a buffer, but cannot be used for both
@@ -80,37 +81,33 @@ int main(int argc, char** argv) {
 */
 typedef struct {
   jmp_buf jb;
-  char* data;
-  size_t pos;
-  size_t size;
+  char*   data;
+  size_t  pos;
+  size_t  size;
 } SBuffer;
 
-
 // common functions can be used in both read & write
 #define tbufThrowError(buf, code) longjmp((buf)->jb, (code))
 size_t tbufTell(SBuffer* buf);
 size_t tbufSeekTo(SBuffer* buf, size_t pos);
 size_t tbufSkip(SBuffer* buf, size_t size);
-void tbufClose(SBuffer* buf, bool keepData);
-
+void   tbufClose(SBuffer* buf, bool keepData);
 
 // basic read functions
-#define tbufBeginRead(buf, data, len) (((buf)->data = (char*)data), ((buf)->pos = 0), ((buf)->size = ((data) == NULL) ? 0 : (len)), setjmp((buf)->jb))
-char* tbufRead(SBuffer* buf, size_t size);
-void tbufReadToBuffer(SBuffer* buf, void* dst, size_t size);
+#define tbufBeginRead(buf, _data, len) ((buf)->data = (char*)(_data), ((buf)->pos = 0), ((buf)->size = ((_data) == NULL) ? 0 : (len)), setjmp((buf)->jb))
+char*       tbufRead(SBuffer* buf, size_t size);
+void        tbufReadToBuffer(SBuffer* buf, void* dst, size_t size);
 const char* tbufReadString(SBuffer* buf, size_t* len);
-size_t tbufReadToString(SBuffer* buf, char* dst, size_t size);
-
+size_t      tbufReadToString(SBuffer* buf, char* dst, size_t size);
 
 // basic write functions
 #define tbufBeginWrite(buf) ((buf)->data = NULL, ((buf)->pos = 0), ((buf)->size = 0), setjmp((buf)->jb))
-void tbufEnsureCapacity(SBuffer* buf, size_t size);
+void  tbufEnsureCapacity(SBuffer* buf, size_t size);
 char* tbufGetData(SBuffer* buf, bool takeOver);
-void tbufWrite(SBuffer* buf, const void* data, size_t size);
-void tbufWriteAt(SBuffer* buf, size_t pos, const void* data, size_t size);
-void tbufWriteStringLen(SBuffer* buf, const char* str, size_t len);
-void tbufWriteString(SBuffer* buf, const char* str);
-
+void  tbufWrite(SBuffer* buf, const void* data, size_t size);
+void  tbufWriteAt(SBuffer* buf, size_t pos, const void* data, size_t size);
+void  tbufWriteStringLen(SBuffer* buf, const char* str, size_t len);
+void  tbufWriteString(SBuffer* buf, const char* str);
 
 // read & write function for primitive types
 #ifndef TBUFFER_DEFINE_FUNCTION
@@ -120,17 +117,21 @@ void tbufWriteString(SBuffer* buf, const char* str);
   void tbufWrite##name##At(SBuffer* buf, size_t pos, type data);
 #endif
 
-TBUFFER_DEFINE_FUNCTION( bool, Bool )
-TBUFFER_DEFINE_FUNCTION( char, Char )
-TBUFFER_DEFINE_FUNCTION( int8_t, Int8 )
-TBUFFER_DEFINE_FUNCTION( uint8_t, Unt8 )
-TBUFFER_DEFINE_FUNCTION( int16_t, Int16 )
-TBUFFER_DEFINE_FUNCTION( uint16_t, Uint16 )
-TBUFFER_DEFINE_FUNCTION( int32_t, Int32 )
-TBUFFER_DEFINE_FUNCTION( uint32_t, Uint32 )
-TBUFFER_DEFINE_FUNCTION( int64_t, Int64 )
-TBUFFER_DEFINE_FUNCTION( uint64_t, Uint64 )
-TBUFFER_DEFINE_FUNCTION( float, Float )
-TBUFFER_DEFINE_FUNCTION( double, Double )
+TBUFFER_DEFINE_FUNCTION(bool, Bool)
+TBUFFER_DEFINE_FUNCTION(char, Char)
+TBUFFER_DEFINE_FUNCTION(int8_t, Int8)
+TBUFFER_DEFINE_FUNCTION(uint8_t, Unt8)
+TBUFFER_DEFINE_FUNCTION(int16_t, Int16)
+TBUFFER_DEFINE_FUNCTION(uint16_t, Uint16)
+TBUFFER_DEFINE_FUNCTION(int32_t, Int32)
+TBUFFER_DEFINE_FUNCTION(uint32_t, Uint32)
+TBUFFER_DEFINE_FUNCTION(int64_t, Int64)
+TBUFFER_DEFINE_FUNCTION(uint64_t, Uint64)
+TBUFFER_DEFINE_FUNCTION(float, Float)
+TBUFFER_DEFINE_FUNCTION(double, Double)
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif
\ No newline at end of file

src/util/src/ihash.c

@@ -221,10 +221,9 @@ void taosCleanUpIntHashWithFp(void *handle, void (*fp)(char *)) {
 void taosVisitIntHashWithFp(void *handle, int (*fp)(char *, void *), void *param) {
   IHashObj * pObj;
   IHashNode *pNode, *pNext;
-  char *     pData = NULL;
 
   pObj = (IHashObj *)handle;
-  if (pObj == NULL || pObj->maxSessions <= 0) return NULL;
+  if (pObj == NULL || pObj->maxSessions <= 0) return;
 
   pthread_mutex_lock(&pObj->mutex);
 
@@ -245,11 +244,10 @@ void taosVisitIntHashWithFp(void *handle, int (*fp)(char *, void *), void *param
 int32_t taosGetIntHashSize(void *handle) {
   IHashObj * pObj;
   IHashNode *pNode, *pNext;
-  char *     pData = NULL;
   int32_t    num = 0;
 
   pObj = (IHashObj *)handle;
-  if (pObj == NULL || pObj->maxSessions <= 0) return NULL;
+  if (pObj == NULL || pObj->maxSessions <= 0) return 0;
 
   pthread_mutex_lock(&pObj->mutex);
 

src/util/src/tbuffer.c

@@ -30,7 +30,7 @@
     tbufWriteAt(buf, pos, &data, sizeof(data));\
   }
 
-#include "../inc/tbuffer.h"
+#include "tbuffer.h"
 
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -119,13 +119,14 @@ void tbufEnsureCapacity(SBuffer* buf, size_t size) {
 }
 
 char* tbufGetData(SBuffer* buf, bool takeOver) {
-		char* ret = buf->data;
-		if (takeOver) {
-      buf->pos = 0;
-      buf->size = 0;
-			buf->data = NULL;
-    }
-		return ret;
+  char* ret = buf->data;
+  if (takeOver) {
+    buf->pos = 0;
+    buf->size = 0;
+    buf->data = NULL;
+  }
+
+  return ret;
 }
 
 void tbufEndWrite(SBuffer* buf) {

src/vnode/tsdb/src/tsdbFile.c

@@ -147,6 +147,11 @@ void tsdbInitFileGroupIter(STsdbFileH *pFileH, SFileGroupIter *pIter, int direct
 }
 
 void tsdbSeekFileGroupIter(SFileGroupIter *pIter, int fid) {
+  if (pIter->numOfFGroups == 0) {
+    assert(pIter->pFileGroup == NULL);
+    return;
+  }
+  
   int flags = (pIter->direction == TSDB_FGROUP_ITER_FORWARD) ? TD_GE : TD_LE;
   void *ptr = taosbsearch(&fid, pIter->base, sizeof(SFileGroup), pIter->numOfFGroups, compFGroupKey, flags);
   if (ptr == NULL) {

tests/script/basicSuite.sim

 ################################# 
-run general/user/testSuite.sim
-run general/table/testSuite.sim
+
+run general/user/basic1.sim
+
+run general/show/dnodes.sim
+
+run general/db/basic1.sim
+run general/db/basic2.sim
+run general/db/basic3.sim
+run general/db/basic4.sim
+run general/db/basic5.sim
+
+run general/table/basic1.sim
+run general/table/basic2.sim
+run general/table/basic3.sim
+
 ################################## 

tests/script/general/db/basic1.sim

+system sh/stop_dnodes.sh
+system sh/deploy.sh -n dnode1 -m 192.168.0.1 -i 192.168.0.1
+system sh/exec.sh -n dnode1 -s start
+sql connect
+
+print =============== create database
+sql create database d1
+sql show databases
+if $rows != 1 then 
+  return -1
+endi
+
+if $data00 != d1 then 
+  return -1
+endi
+
+if $data02 != 0 then 
+  return -1
+endi
+
+if $data03 != 0 then 
+  return -1
+endi
+
+print =============== drop database
+sql drop database d1
+sql show databases
+if $rows != 0 then 
+  return -1
+endi
+
+print =============== more databases
+sql create database d2
+sql create database d3
+sql create database d4
+sql show databases
+if $rows != 3 then 
+  return -1
+endi
+
+print =============== drop database
+sql drop database d2
+sql drop database d3
+sql show databases
+if $rows != 1 then 
+  return -1
+endi
+
+if $data00 != d4 then 
+  return -1
+endi
+
+if $data02 != 0 then 
+  return -1
+endi
+
+if $data03 != 0 then 
+  return -1
+endi
\ No newline at end of file

tests/script/general/table/testSuite.sim

-################################# 
-run general/table/basic.sim
-################################## 

tests/script/general/user/testSuite.sim

-################################# 
-#run general/user/basic.sim
-################################## 

tests/script/jenkins/basic1.txt

+./test.sh -f general/user/basic1.sim
+
+./test.sh -f general/db/basic1.sim
+./test.sh -f general/db/basic2.sim
+./test.sh -f general/db/basic3.sim
+./test.sh -f general/db/basic4.sim
+./test.sh -f general/db/basic5.sim
+
+./test.sh -f general/table/basic1.sim
+./test.sh -f general/table/basic2.sim
+./test.sh -f general/table/basic3.sim
\ No newline at end of file