fix: memory error

include/common/tmsg.h

@@ -1352,7 +1352,7 @@ typedef struct {
 
 typedef struct {
   int32_t code;
-  char tbFName[TSDB_TABLE_FNAME_LEN];
+  char    tbFName[TSDB_TABLE_FNAME_LEN];
   int32_t sversion;
   int32_t tversion;
 } SResReadyRsp;
@@ -2524,7 +2524,7 @@ static FORCE_INLINE void* tDecodeSMqDataBlkRsp(const void* buf, SMqDataBlkRsp* p
   buf = taosDecodeFixedI32(buf, &pRsp->skipLogNum);
   buf = taosDecodeFixedI32(buf, &pRsp->blockNum);
   pRsp->blockData = taosArrayInit(pRsp->blockNum, sizeof(void*));
-  pRsp->blockDataLen = taosArrayInit(pRsp->blockNum, sizeof(void*));
+  pRsp->blockDataLen = taosArrayInit(pRsp->blockNum, sizeof(int32_t));
   pRsp->blockTbName = taosArrayInit(pRsp->blockNum, sizeof(void*));
   pRsp->blockSchema = taosArrayInit(pRsp->blockNum, sizeof(void*));
   if (pRsp->blockNum != 0) {

source/libs/catalog/src/catalog.c

@@ -13,11 +13,11 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "trpc.h"
-#include "query.h"
-#include "tname.h"
 #include "catalogInt.h"
+#include "query.h"
 #include "systable.h"
+#include "tname.h"
+#include "trpc.h"
 
 int32_t ctgActUpdateVg(SCtgMetaAction *action);
 int32_t ctgActUpdateTbl(SCtgMetaAction *action);
@@ -27,38 +27,11 @@ int32_t ctgActRemoveTbl(SCtgMetaAction *action);
 int32_t ctgActUpdateUser(SCtgMetaAction *action);
 
 extern SCtgDebug gCTGDebug;
-SCatalogMgmt gCtgMgmt = {0};
-SCtgAction gCtgAction[CTG_ACT_MAX] = {{
-                            CTG_ACT_UPDATE_VG,
-                            "update vgInfo",
-                            ctgActUpdateVg
-                          },
-                          {
-                            CTG_ACT_UPDATE_TBL,
-                            "update tbMeta",
-                            ctgActUpdateTbl
-                          },
-                          {
-                            CTG_ACT_REMOVE_DB,
-                            "remove DB",
-                            ctgActRemoveDB
-                          },
-                          {
-                            CTG_ACT_REMOVE_STB,
-                            "remove stbMeta",
-                            ctgActRemoveStb
-                          },
-                          {
-                            CTG_ACT_REMOVE_TBL,
-                            "remove tbMeta",
-                            ctgActRemoveTbl
-                          },
-                          {
-                            CTG_ACT_UPDATE_USER,
-                            "update user",
-                            ctgActUpdateUser
-                          }
-};
+SCatalogMgmt     gCtgMgmt = {0};
+SCtgAction       gCtgAction[CTG_ACT_MAX] = {
+    {CTG_ACT_UPDATE_VG, "update vgInfo", ctgActUpdateVg},   {CTG_ACT_UPDATE_TBL, "update tbMeta", ctgActUpdateTbl},
+    {CTG_ACT_REMOVE_DB, "remove DB", ctgActRemoveDB},       {CTG_ACT_REMOVE_STB, "remove stbMeta", ctgActRemoveStb},
+    {CTG_ACT_REMOVE_TBL, "remove tbMeta", ctgActRemoveTbl}, {CTG_ACT_UPDATE_USER, "update user", ctgActUpdateUser}};
 
 void ctgFreeMetaRent(SCtgRentMgmt *mgmt) {
   if (NULL == mgmt->slots) {
@@ -76,11 +49,10 @@ void ctgFreeMetaRent(SCtgRentMgmt *mgmt) {
   taosMemoryFreeClear(mgmt->slots);
 }
 
-
 void ctgFreeTableMetaCache(SCtgTbMetaCache *cache) {
   CTG_LOCK(CTG_WRITE, &cache->stbLock);
   if (cache->stbCache) {
-    int32_t stblNum = taosHashGetSize(cache->stbCache);  
+    int32_t stblNum = taosHashGetSize(cache->stbCache);
     taosHashCleanup(cache->stbCache);
     cache->stbCache = NULL;
     CTG_CACHE_STAT_SUB(stblNum, stblNum);
@@ -106,7 +78,7 @@ void ctgFreeVgInfo(SDBVgInfo *vgInfo) {
     taosHashCleanup(vgInfo->vgHash);
     vgInfo->vgHash = NULL;
   }
-  
+
   taosMemoryFreeClear(vgInfo);
 }
 
@@ -116,7 +88,7 @@ void ctgFreeDbCache(SCtgDBCache *dbCache) {
   }
 
   CTG_LOCK(CTG_WRITE, &dbCache->vgLock);
-  ctgFreeVgInfo (dbCache->vgInfo);
+  ctgFreeVgInfo(dbCache->vgInfo);
   CTG_UNLOCK(CTG_WRITE, &dbCache->vgLock);
 
   ctgFreeTableMetaCache(&dbCache->tbCache);
@@ -128,13 +100,13 @@ void ctgFreeSCtgUserAuth(SCtgUserAuth *userCache) {
   taosHashCleanup(userCache->writeDbs);
 }
 
-void ctgFreeHandle(SCatalog* pCtg) {
+void ctgFreeHandle(SCatalog *pCtg) {
   ctgFreeMetaRent(&pCtg->dbRent);
   ctgFreeMetaRent(&pCtg->stbRent);
-  
+
   if (pCtg->dbCache) {
     int32_t dbNum = taosHashGetSize(pCtg->dbCache);
-    
+
     void *pIter = taosHashIterate(pCtg->dbCache, NULL);
     while (pIter) {
       SCtgDBCache *dbCache = pIter;
@@ -142,42 +114,40 @@ void ctgFreeHandle(SCatalog* pCtg) {
       atomic_store_8(&dbCache->deleted, 1);
 
       ctgFreeDbCache(dbCache);
-            
+
       pIter = taosHashIterate(pCtg->dbCache, pIter);
-    }  
+    }
 
     taosHashCleanup(pCtg->dbCache);
-    
+
     CTG_CACHE_STAT_SUB(dbNum, dbNum);
   }
 
   if (pCtg->userCache) {
     int32_t userNum = taosHashGetSize(pCtg->userCache);
-    
+
     void *pIter = taosHashIterate(pCtg->userCache, NULL);
     while (pIter) {
       SCtgUserAuth *userCache = pIter;
 
       ctgFreeSCtgUserAuth(userCache);
-            
+
       pIter = taosHashIterate(pCtg->userCache, pIter);
-    }  
+    }
 
     taosHashCleanup(pCtg->userCache);
-    
+
     CTG_CACHE_STAT_SUB(userNum, userNum);
   }
-    
+
   taosMemoryFree(pCtg);
 }
 
-
-
 void ctgWaitAction(SCtgMetaAction *action) {
   while (true) {
     tsem_wait(&gCtgMgmt.queue.rspSem);
-    
-    if (atomic_load_8((int8_t*)&gCtgMgmt.exit)) {
+
+    if (atomic_load_8((int8_t *)&gCtgMgmt.exit)) {
       tsem_post(&gCtgMgmt.queue.rspSem);
       break;
     }
@@ -193,19 +163,18 @@ void ctgWaitAction(SCtgMetaAction *action) {
 
 void ctgPopAction(SCtgMetaAction **action) {
   SCtgQNode *orig = gCtgMgmt.queue.head;
-  
+
   SCtgQNode *node = gCtgMgmt.queue.head->next;
   gCtgMgmt.queue.head = gCtgMgmt.queue.head->next;
 
   CTG_QUEUE_SUB();
-  
+
   taosMemoryFreeClear(orig);
 
   *action = &node->action;
 }
 
-
-int32_t ctgPushAction(SCatalog* pCtg, SCtgMetaAction *action) {
+int32_t ctgPushAction(SCatalog *pCtg, SCtgMetaAction *action) {
   SCtgQNode *node = taosMemoryCalloc(1, sizeof(SCtgQNode));
   if (NULL == node) {
     qError("calloc %d failed", (int32_t)sizeof(SCtgQNode));
@@ -213,7 +182,7 @@ int32_t ctgPushAction(SCatalog* pCtg, SCtgMetaAction *action) {
   }
 
   action->seqId = atomic_add_fetch_64(&gCtgMgmt.queue.seqId, 1);
-  
+
   node->action = *action;
 
   CTG_LOCK(CTG_WRITE, &gCtgMgmt.queue.qlock);
@@ -235,10 +204,9 @@ int32_t ctgPushAction(SCatalog* pCtg, SCtgMetaAction *action) {
   return TSDB_CODE_SUCCESS;
 }
 
-
-int32_t ctgPushRmDBMsgInQueue(SCatalog* pCtg, const char *dbFName, int64_t dbId) {
-  int32_t code = 0;
-  SCtgMetaAction action= {.act = CTG_ACT_REMOVE_DB};
+int32_t ctgPushRmDBMsgInQueue(SCatalog *pCtg, const char *dbFName, int64_t dbId) {
+  int32_t          code = 0;
+  SCtgMetaAction   action = {.act = CTG_ACT_REMOVE_DB};
   SCtgRemoveDBMsg *msg = taosMemoryMalloc(sizeof(SCtgRemoveDBMsg));
   if (NULL == msg) {
     ctgError("malloc %d failed", (int32_t)sizeof(SCtgRemoveDBMsg));
@@ -266,10 +234,10 @@ _return:
   CTG_RET(code);
 }
 
-
-int32_t ctgPushRmStbMsgInQueue(SCatalog* pCtg, const char *dbFName, int64_t dbId, const char *stbName, uint64_t suid, bool syncReq) {
-  int32_t code = 0;
-  SCtgMetaAction action= {.act = CTG_ACT_REMOVE_STB, .syncReq = syncReq};
+int32_t ctgPushRmStbMsgInQueue(SCatalog *pCtg, const char *dbFName, int64_t dbId, const char *stbName, uint64_t suid,
+                               bool syncReq) {
+  int32_t           code = 0;
+  SCtgMetaAction    action = {.act = CTG_ACT_REMOVE_STB, .syncReq = syncReq};
   SCtgRemoveStbMsg *msg = taosMemoryMalloc(sizeof(SCtgRemoveStbMsg));
   if (NULL == msg) {
     ctgError("malloc %d failed", (int32_t)sizeof(SCtgRemoveStbMsg));
@@ -294,11 +262,9 @@ _return:
   CTG_RET(code);
 }
 
-
-
-int32_t ctgPushRmTblMsgInQueue(SCatalog* pCtg, const char *dbFName, int64_t dbId, const char *tbName, bool syncReq) {
-  int32_t code = 0;
-  SCtgMetaAction action= {.act = CTG_ACT_REMOVE_TBL, .syncReq = syncReq};
+int32_t ctgPushRmTblMsgInQueue(SCatalog *pCtg, const char *dbFName, int64_t dbId, const char *tbName, bool syncReq) {
+  int32_t           code = 0;
+  SCtgMetaAction    action = {.act = CTG_ACT_REMOVE_TBL, .syncReq = syncReq};
   SCtgRemoveTblMsg *msg = taosMemoryMalloc(sizeof(SCtgRemoveTblMsg));
   if (NULL == msg) {
     ctgError("malloc %d failed", (int32_t)sizeof(SCtgRemoveTblMsg));
@@ -322,9 +288,9 @@ _return:
   CTG_RET(code);
 }
 
-int32_t ctgPushUpdateVgMsgInQueue(SCatalog* pCtg, const char *dbFName, int64_t dbId, SDBVgInfo* dbInfo, bool syncReq) {
-  int32_t code = 0;
-  SCtgMetaAction action= {.act = CTG_ACT_UPDATE_VG, .syncReq = syncReq};
+int32_t ctgPushUpdateVgMsgInQueue(SCatalog *pCtg, const char *dbFName, int64_t dbId, SDBVgInfo *dbInfo, bool syncReq) {
+  int32_t          code = 0;
+  SCtgMetaAction   action = {.act = CTG_ACT_UPDATE_VG, .syncReq = syncReq};
   SCtgUpdateVgMsg *msg = taosMemoryMalloc(sizeof(SCtgUpdateVgMsg));
   if (NULL == msg) {
     ctgError("malloc %d failed", (int32_t)sizeof(SCtgUpdateVgMsg));
@@ -355,9 +321,9 @@ _return:
   CTG_RET(code);
 }
 
-int32_t ctgPushUpdateTblMsgInQueue(SCatalog* pCtg, STableMetaOutput *output, bool syncReq) {
-  int32_t code = 0;
-  SCtgMetaAction action= {.act = CTG_ACT_UPDATE_TBL, .syncReq = syncReq};
+int32_t ctgPushUpdateTblMsgInQueue(SCatalog *pCtg, STableMetaOutput *output, bool syncReq) {
+  int32_t           code = 0;
+  SCtgMetaAction    action = {.act = CTG_ACT_UPDATE_TBL, .syncReq = syncReq};
   SCtgUpdateTblMsg *msg = taosMemoryMalloc(sizeof(SCtgUpdateTblMsg));
   if (NULL == msg) {
     ctgError("malloc %d failed", (int32_t)sizeof(SCtgUpdateTblMsg));
@@ -377,17 +343,17 @@ int32_t ctgPushUpdateTblMsgInQueue(SCatalog* pCtg, STableMetaOutput *output, boo
   CTG_ERR_JRET(ctgPushAction(pCtg, &action));
 
   return TSDB_CODE_SUCCESS;
-  
+
 _return:
 
   taosMemoryFreeClear(msg);
-  
+
   CTG_RET(code);
 }
 
-int32_t ctgPushUpdateUserMsgInQueue(SCatalog* pCtg, SGetUserAuthRsp *pAuth, bool syncReq) {
-  int32_t code = 0;
-  SCtgMetaAction action= {.act = CTG_ACT_UPDATE_USER, .syncReq = syncReq};
+int32_t ctgPushUpdateUserMsgInQueue(SCatalog *pCtg, SGetUserAuthRsp *pAuth, bool syncReq) {
+  int32_t            code = 0;
+  SCtgMetaAction     action = {.act = CTG_ACT_UPDATE_USER, .syncReq = syncReq};
   SCtgUpdateUserMsg *msg = taosMemoryMalloc(sizeof(SCtgUpdateUserMsg));
   if (NULL == msg) {
     ctgError("malloc %d failed", (int32_t)sizeof(SCtgUpdateUserMsg));
@@ -402,38 +368,37 @@ int32_t ctgPushUpdateUserMsgInQueue(SCatalog* pCtg, SGetUserAuthRsp *pAuth, bool
   CTG_ERR_JRET(ctgPushAction(pCtg, &action));
 
   return TSDB_CODE_SUCCESS;
-  
+
 _return:
 
   tFreeSGetUserAuthRsp(pAuth);
   taosMemoryFreeClear(msg);
-  
+
   CTG_RET(code);
 }
 
 int32_t ctgAcquireVgInfo(SCatalog *pCtg, SCtgDBCache *dbCache, bool *inCache) {
   CTG_LOCK(CTG_READ, &dbCache->vgLock);
-  
+
   if (dbCache->deleted) {
     CTG_UNLOCK(CTG_READ, &dbCache->vgLock);
 
-    ctgDebug("db is dropping, dbId:%"PRIx64, dbCache->dbId);
-    
+    ctgDebug("db is dropping, dbId:%" PRIx64, dbCache->dbId);
+
     *inCache = false;
     return TSDB_CODE_SUCCESS;
   }
 
-  
   if (NULL == dbCache->vgInfo) {
     CTG_UNLOCK(CTG_READ, &dbCache->vgLock);
 
     *inCache = false;
-    ctgDebug("db vgInfo is empty, dbId:%"PRIx64, dbCache->dbId);
+    ctgDebug("db vgInfo is empty, dbId:%" PRIx64, dbCache->dbId);
     return TSDB_CODE_SUCCESS;
   }
 
   *inCache = true;
-  
+
   return TSDB_CODE_SUCCESS;
 }
 
@@ -441,7 +406,7 @@ int32_t ctgWAcquireVgInfo(SCatalog *pCtg, SCtgDBCache *dbCache) {
   CTG_LOCK(CTG_WRITE, &dbCache->vgLock);
 
   if (dbCache->deleted) {
-    ctgDebug("db is dropping, dbId:%"PRIx64, dbCache->dbId);
+    ctgDebug("db is dropping, dbId:%" PRIx64, dbCache->dbId);
     CTG_UNLOCK(CTG_WRITE, &dbCache->vgLock);
     CTG_ERR_RET(TSDB_CODE_CTG_DB_DROPPED);
   }
@@ -449,20 +414,13 @@ int32_t ctgWAcquireVgInfo(SCatalog *pCtg, SCtgDBCache *dbCache) {
   return TSDB_CODE_SUCCESS;
 }
 
-void ctgReleaseDBCache(SCatalog *pCtg, SCtgDBCache *dbCache) {
-  taosHashRelease(pCtg->dbCache, dbCache);
-}
-
-void ctgReleaseVgInfo(SCtgDBCache *dbCache) {
-  CTG_UNLOCK(CTG_READ, &dbCache->vgLock);
-}
+void ctgReleaseDBCache(SCatalog *pCtg, SCtgDBCache *dbCache) { taosHashRelease(pCtg->dbCache, dbCache); }
 
-void ctgWReleaseVgInfo(SCtgDBCache *dbCache) {
-  CTG_UNLOCK(CTG_WRITE, &dbCache->vgLock);
-}
+void ctgReleaseVgInfo(SCtgDBCache *dbCache) { CTG_UNLOCK(CTG_READ, &dbCache->vgLock); }
 
+void ctgWReleaseVgInfo(SCtgDBCache *dbCache) { CTG_UNLOCK(CTG_WRITE, &dbCache->vgLock); }
 
-int32_t ctgAcquireDBCacheImpl(SCatalog* pCtg, const char *dbFName, SCtgDBCache **pCache, bool acquire) {
+int32_t ctgAcquireDBCacheImpl(SCatalog *pCtg, const char *dbFName, SCtgDBCache **pCache, bool acquire) {
   char *p = strchr(dbFName, '.');
   if (p && CTG_IS_SYS_DBNAME(p + 1)) {
     dbFName = p + 1;
@@ -474,7 +432,7 @@ int32_t ctgAcquireDBCacheImpl(SCatalog* pCtg, const char *dbFName, SCtgDBCache *
   } else {
     dbCache = (SCtgDBCache *)taosHashGet(pCtg->dbCache, dbFName, strlen(dbFName));
   }
-  
+
   if (NULL == dbCache) {
     *pCache = NULL;
     ctgDebug("db not in cache, dbFName:%s", dbFName);
@@ -484,28 +442,27 @@ int32_t ctgAcquireDBCacheImpl(SCatalog* pCtg, const char *dbFName, SCtgDBCache *
   if (dbCache->deleted) {
     if (acquire) {
       ctgReleaseDBCache(pCtg, dbCache);
-    }    
-    
+    }
+
     *pCache = NULL;
     ctgDebug("db is removing from cache, dbFName:%s", dbFName);
     return TSDB_CODE_SUCCESS;
   }
 
   *pCache = dbCache;
-    
+
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t ctgAcquireDBCache(SCatalog* pCtg, const char *dbFName, SCtgDBCache **pCache) {
+int32_t ctgAcquireDBCache(SCatalog *pCtg, const char *dbFName, SCtgDBCache **pCache) {
   CTG_RET(ctgAcquireDBCacheImpl(pCtg, dbFName, pCache, true));
 }
 
-int32_t ctgGetDBCache(SCatalog* pCtg, const char *dbFName, SCtgDBCache **pCache) {
+int32_t ctgGetDBCache(SCatalog *pCtg, const char *dbFName, SCtgDBCache **pCache) {
   CTG_RET(ctgAcquireDBCacheImpl(pCtg, dbFName, pCache, false));
 }
 
-
-int32_t ctgAcquireVgInfoFromCache(SCatalog* pCtg, const char *dbFName, SCtgDBCache **pCache, bool *inCache) {
+int32_t ctgAcquireVgInfoFromCache(SCatalog *pCtg, const char *dbFName, SCtgDBCache **pCache, bool *inCache) {
   SCtgDBCache *dbCache = NULL;
 
   if (NULL == pCtg->dbCache) {
@@ -514,11 +471,11 @@ int32_t ctgAcquireVgInfoFromCache(SCatalog* pCtg, const char *dbFName, SCtgDBCac
   }
 
   ctgAcquireDBCache(pCtg, dbFName, &dbCache);
-  if (NULL == dbCache) {  
+  if (NULL == dbCache) {
     ctgDebug("db %s not in cache", dbFName);
     goto _return;
   }
-  
+
   ctgAcquireVgInfo(pCtg, dbCache, inCache);
   if (!(*inCache)) {
     ctgDebug("vgInfo of db %s not in cache", dbFName);
@@ -531,7 +488,7 @@ int32_t ctgAcquireVgInfoFromCache(SCatalog* pCtg, const char *dbFName, SCtgDBCac
   CTG_CACHE_STAT_ADD(vgHitNum, 1);
 
   ctgDebug("Got db vgInfo from cache, dbFName:%s", dbFName);
-  
+
   return TSDB_CODE_SUCCESS;
 
 _return:
@@ -544,12 +501,12 @@ _return:
   *inCache = false;
 
   CTG_CACHE_STAT_ADD(vgMissNum, 1);
-  
+
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t ctgGetQnodeListFromMnode(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, SArray *out) {
-  char *msg = NULL;
+int32_t ctgGetQnodeListFromMnode(SCatalog *pCtg, void *pRpc, const SEpSet *pMgmtEps, SArray *out) {
+  char   *msg = NULL;
   int32_t msgLen = 0;
 
   ctgDebug("try to get qnode list from mnode, mgmtEpInUse:%d", pMgmtEps->inUse);
@@ -559,16 +516,16 @@ int32_t ctgGetQnodeListFromMnode(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmt
     ctgError("Build qnode list msg failed, error:%s", tstrerror(code));
     CTG_ERR_RET(code);
   }
-  
+
   SRpcMsg rpcMsg = {
       .msgType = TDMT_MND_QNODE_LIST,
-      .pCont   = msg,
+      .pCont = msg,
       .contLen = msgLen,
   };
 
   SRpcMsg rpcRsp = {0};
 
-  rpcSendRecv(pRpc, (SEpSet*)pMgmtEps, &rpcMsg, &rpcRsp);
+  rpcSendRecv(pRpc, (SEpSet *)pMgmtEps, &rpcMsg, &rpcRsp);
   if (TSDB_CODE_SUCCESS != rpcRsp.code) {
     ctgError("error rsp for qnode list, error:%s", tstrerror(rpcRsp.code));
     CTG_ERR_RET(rpcRsp.code);
@@ -585,9 +542,9 @@ int32_t ctgGetQnodeListFromMnode(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmt
   return TSDB_CODE_SUCCESS;
 }
 
-
-int32_t ctgGetDBVgInfoFromMnode(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, SBuildUseDBInput *input, SUseDbOutput *out) {
-  char *msg = NULL;
+int32_t ctgGetDBVgInfoFromMnode(SCatalog *pCtg, void *pRpc, const SEpSet *pMgmtEps, SBuildUseDBInput *input,
+                                SUseDbOutput *out) {
+  char   *msg = NULL;
   int32_t msgLen = 0;
 
   ctgDebug("try to get db vgInfo from mnode, dbFName:%s", input->db);
@@ -597,16 +554,16 @@ int32_t ctgGetDBVgInfoFromMnode(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtE
     ctgError("Build use db msg failed, code:%x, db:%s", code, input->db);
     CTG_ERR_RET(code);
   }
-  
+
   SRpcMsg rpcMsg = {
       .msgType = TDMT_MND_USE_DB,
-      .pCont   = msg,
+      .pCont = msg,
       .contLen = msgLen,
   };
 
   SRpcMsg rpcRsp = {0};
 
-  rpcSendRecv(pRpc, (SEpSet*)pMgmtEps, &rpcMsg, &rpcRsp);
+  rpcSendRecv(pRpc, (SEpSet *)pMgmtEps, &rpcMsg, &rpcRsp);
   if (TSDB_CODE_SUCCESS != rpcRsp.code) {
     ctgError("error rsp for use db, error:%s, db:%s", tstrerror(rpcRsp.code), input->db);
     CTG_ERR_RET(rpcRsp.code);
@@ -623,8 +580,8 @@ int32_t ctgGetDBVgInfoFromMnode(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtE
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t ctgGetDBCfgFromMnode(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const char *dbFName, SDbCfgInfo *out) {
-  char *msg = NULL;
+int32_t ctgGetDBCfgFromMnode(SCatalog *pCtg, void *pRpc, const SEpSet *pMgmtEps, const char *dbFName, SDbCfgInfo *out) {
+  char   *msg = NULL;
   int32_t msgLen = 0;
 
   ctgDebug("try to get db cfg from mnode, dbFName:%s", dbFName);
@@ -634,16 +591,16 @@ int32_t ctgGetDBCfgFromMnode(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps,
     ctgError("Build get db cfg msg failed, code:%x, db:%s", code, dbFName);
     CTG_ERR_RET(code);
   }
-  
+
   SRpcMsg rpcMsg = {
       .msgType = TDMT_MND_GET_DB_CFG,
-      .pCont   = msg,
+      .pCont = msg,
       .contLen = msgLen,
   };
 
   SRpcMsg rpcRsp = {0};
 
-  rpcSendRecv(pRpc, (SEpSet*)pMgmtEps, &rpcMsg, &rpcRsp);
+  rpcSendRecv(pRpc, (SEpSet *)pMgmtEps, &rpcMsg, &rpcRsp);
   if (TSDB_CODE_SUCCESS != rpcRsp.code) {
     ctgError("error rsp for get db cfg, error:%s, db:%s", tstrerror(rpcRsp.code), dbFName);
     CTG_ERR_RET(rpcRsp.code);
@@ -660,8 +617,9 @@ int32_t ctgGetDBCfgFromMnode(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps,
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t ctgGetIndexInfoFromMnode(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const char *indexName, SIndexInfo *out) {
-  char *msg = NULL;
+int32_t ctgGetIndexInfoFromMnode(SCatalog *pCtg, void *pRpc, const SEpSet *pMgmtEps, const char *indexName,
+                                 SIndexInfo *out) {
+  char   *msg = NULL;
   int32_t msgLen = 0;
 
   ctgDebug("try to get index from mnode, indexName:%s", indexName);
@@ -671,16 +629,16 @@ int32_t ctgGetIndexInfoFromMnode(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmt
     ctgError("Build get index msg failed, code:%x, db:%s", code, indexName);
     CTG_ERR_RET(code);
   }
-  
+
   SRpcMsg rpcMsg = {
       .msgType = TDMT_MND_GET_INDEX,
-      .pCont   = msg,
+      .pCont = msg,
       .contLen = msgLen,
   };
 
   SRpcMsg rpcRsp = {0};
 
-  rpcSendRecv(pRpc, (SEpSet*)pMgmtEps, &rpcMsg, &rpcRsp);
+  rpcSendRecv(pRpc, (SEpSet *)pMgmtEps, &rpcMsg, &rpcRsp);
   if (TSDB_CODE_SUCCESS != rpcRsp.code) {
     ctgError("error rsp for get index, error:%s, indexName:%s", tstrerror(rpcRsp.code), indexName);
     CTG_ERR_RET(rpcRsp.code);
@@ -697,8 +655,9 @@ int32_t ctgGetIndexInfoFromMnode(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmt
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t ctgGetUdfInfoFromMnode(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const char *funcName, SFuncInfo **out) {
-  char *msg = NULL;
+int32_t ctgGetUdfInfoFromMnode(SCatalog *pCtg, void *pRpc, const SEpSet *pMgmtEps, const char *funcName,
+                               SFuncInfo **out) {
+  char   *msg = NULL;
   int32_t msgLen = 0;
 
   ctgDebug("try to get udf info from mnode, funcName:%s", funcName);
@@ -708,23 +667,23 @@ int32_t ctgGetUdfInfoFromMnode(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEp
     ctgError("Build get udf msg failed, code:%x, db:%s", code, funcName);
     CTG_ERR_RET(code);
   }
-  
+
   SRpcMsg rpcMsg = {
       .msgType = TDMT_MND_RETRIEVE_FUNC,
-      .pCont   = msg,
+      .pCont = msg,
       .contLen = msgLen,
   };
 
   SRpcMsg rpcRsp = {0};
 
-  rpcSendRecv(pRpc, (SEpSet*)pMgmtEps, &rpcMsg, &rpcRsp);
+  rpcSendRecv(pRpc, (SEpSet *)pMgmtEps, &rpcMsg, &rpcRsp);
   if (TSDB_CODE_SUCCESS != rpcRsp.code) {
     if (TSDB_CODE_MND_FUNC_NOT_EXIST == rpcRsp.code) {
       ctgDebug("funcName %s not exist in mnode", funcName);
       taosMemoryFreeClear(*out);
       CTG_RET(TSDB_CODE_SUCCESS);
     }
-    
+
     ctgError("error rsp for get udf, error:%s, funcName:%s", tstrerror(rpcRsp.code), funcName);
     CTG_ERR_RET(rpcRsp.code);
   }
@@ -740,8 +699,9 @@ int32_t ctgGetUdfInfoFromMnode(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEp
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t ctgGetUserDbAuthFromMnode(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const char *user, SGetUserAuthRsp *authRsp) {
-  char *msg = NULL;
+int32_t ctgGetUserDbAuthFromMnode(SCatalog *pCtg, void *pRpc, const SEpSet *pMgmtEps, const char *user,
+                                  SGetUserAuthRsp *authRsp) {
+  char   *msg = NULL;
   int32_t msgLen = 0;
 
   ctgDebug("try to get user auth from mnode, user:%s", user);
@@ -751,16 +711,16 @@ int32_t ctgGetUserDbAuthFromMnode(SCatalog* pCtg, void *pRpc, const SEpSet* pMgm
     ctgError("Build get user auth msg failed, code:%x, db:%s", code, user);
     CTG_ERR_RET(code);
   }
-  
+
   SRpcMsg rpcMsg = {
       .msgType = TDMT_MND_GET_USER_AUTH,
-      .pCont   = msg,
+      .pCont = msg,
       .contLen = msgLen,
   };
 
   SRpcMsg rpcRsp = {0};
 
-  rpcSendRecv(pRpc, (SEpSet*)pMgmtEps, &rpcMsg, &rpcRsp);
+  rpcSendRecv(pRpc, (SEpSet *)pMgmtEps, &rpcMsg, &rpcRsp);
   if (TSDB_CODE_SUCCESS != rpcRsp.code) {
     ctgError("error rsp for get user auth, error:%s, user:%s", tstrerror(rpcRsp.code), user);
     CTG_ERR_RET(rpcRsp.code);
@@ -777,8 +737,7 @@ int32_t ctgGetUserDbAuthFromMnode(SCatalog* pCtg, void *pRpc, const SEpSet* pMgm
   return TSDB_CODE_SUCCESS;
 }
 
-
-int32_t ctgIsTableMetaExistInCache(SCatalog* pCtg, char *dbFName, char* tbName, int32_t *exist) {
+int32_t ctgIsTableMetaExistInCache(SCatalog *pCtg, char *dbFName, char *tbName, int32_t *exist) {
   if (NULL == pCtg->dbCache) {
     *exist = 0;
     ctgWarn("empty db cache, dbFName:%s, tbName:%s", dbFName, tbName);
@@ -793,13 +752,13 @@ int32_t ctgIsTableMetaExistInCache(SCatalog* pCtg, char *dbFName, char* tbName,
   }
 
   size_t sz = 0;
-  CTG_LOCK(CTG_READ, &dbCache->tbCache.metaLock);  
+  CTG_LOCK(CTG_READ, &dbCache->tbCache.metaLock);
   STableMeta *tbMeta = taosHashGet(dbCache->tbCache.metaCache, tbName, strlen(tbName));
   CTG_UNLOCK(CTG_READ, &dbCache->tbCache.metaLock);
-  
+
   if (NULL == tbMeta) {
     ctgReleaseDBCache(pCtg, dbCache);
-    
+
     *exist = 0;
     ctgDebug("tbmeta not in cache, dbFName:%s, tbName:%s", dbFName, tbName);
     return TSDB_CODE_SUCCESS;
@@ -808,14 +767,14 @@ int32_t ctgIsTableMetaExistInCache(SCatalog* pCtg, char *dbFName, char* tbName,
   *exist = 1;
 
   ctgReleaseDBCache(pCtg, dbCache);
-  
+
   ctgDebug("tbmeta is in cache, dbFName:%s, tbName:%s", dbFName, tbName);
-  
+
   return TSDB_CODE_SUCCESS;
 }
 
-
-int32_t ctgGetTableMetaFromCache(SCatalog* pCtg, const SName* pTableName, STableMeta** pTableMeta, bool *inCache, int32_t flag, uint64_t *dbId) {
+int32_t ctgGetTableMetaFromCache(SCatalog *pCtg, const SName *pTableName, STableMeta **pTableMeta, bool *inCache,
+                                 int32_t flag, uint64_t *dbId) {
   if (NULL == pCtg->dbCache) {
     ctgDebug("empty tbmeta cache, tbName:%s", pTableName->tname);
     goto _return;
@@ -836,10 +795,11 @@ int32_t ctgGetTableMetaFromCache(SCatalog* pCtg, const SName* pTableName, STable
     ctgDebug("db %s not in cache", pTableName->tname);
     goto _return;
   }
-  
+
   int32_t sz = 0;
   CTG_LOCK(CTG_READ, &dbCache->tbCache.metaLock);
-  int32_t code = taosHashGetDup_m(dbCache->tbCache.metaCache, pTableName->tname, strlen(pTableName->tname), (void **)pTableMeta, &sz);
+  int32_t code = taosHashGetDup_m(dbCache->tbCache.metaCache, pTableName->tname, strlen(pTableName->tname),
+                                  (void **)pTableMeta, &sz);
   CTG_UNLOCK(CTG_READ, &dbCache->tbCache.metaLock);
 
   if (NULL == *pTableMeta) {
@@ -852,7 +812,7 @@ int32_t ctgGetTableMetaFromCache(SCatalog* pCtg, const SName* pTableName, STable
     *dbId = dbCache->dbId;
   }
 
-  STableMeta* tbMeta = *pTableMeta;
+  STableMeta *tbMeta = *pTableMeta;
 
   if (tbMeta->tableType != TSDB_CHILD_TABLE) {
     ctgReleaseDBCache(pCtg, dbCache);
@@ -860,34 +820,36 @@ int32_t ctgGetTableMetaFromCache(SCatalog* pCtg, const SName* pTableName, STable
 
     *inCache = true;
     CTG_CACHE_STAT_ADD(tblHitNum, 1);
-    
+
     return TSDB_CODE_SUCCESS;
   }
 
-  ctgDebug("Got subtable meta from cache, type:%d, dbFName:%s, tbName:%s, suid:%" PRIx64, tbMeta->tableType, dbFName, pTableName->tname, tbMeta->suid);
-  
+  ctgDebug("Got subtable meta from cache, type:%d, dbFName:%s, tbName:%s, suid:%" PRIx64, tbMeta->tableType, dbFName,
+           pTableName->tname, tbMeta->suid);
+
   CTG_LOCK(CTG_READ, &dbCache->tbCache.stbLock);
-  
+
   STableMeta **stbMeta = taosHashGet(dbCache->tbCache.stbCache, &tbMeta->suid, sizeof(tbMeta->suid));
   if (NULL == stbMeta || NULL == *stbMeta) {
     CTG_UNLOCK(CTG_READ, &dbCache->tbCache.stbLock);
     ctgReleaseDBCache(pCtg, dbCache);
-    ctgError("stb not in stbCache, suid:%"PRIx64, tbMeta->suid);
+    ctgError("stb not in stbCache, suid:%" PRIx64, tbMeta->suid);
     taosMemoryFreeClear(*pTableMeta);
     goto _return;
   }
 
-  if ((*stbMeta)->suid != tbMeta->suid) {    
+  if ((*stbMeta)->suid != tbMeta->suid) {
     CTG_UNLOCK(CTG_READ, &dbCache->tbCache.stbLock);
     ctgReleaseDBCache(pCtg, dbCache);
     taosMemoryFreeClear(*pTableMeta);
-    ctgError("stable suid in stbCache mis-match, expected suid:%"PRIx64 ",actual suid:%"PRIx64, tbMeta->suid, (*stbMeta)->suid);
+    ctgError("stable suid in stbCache mis-match, expected suid:%" PRIx64 ",actual suid:%" PRIx64, tbMeta->suid,
+             (*stbMeta)->suid);
     CTG_ERR_RET(TSDB_CODE_CTG_INTERNAL_ERROR);
   }
 
   int32_t metaSize = CTG_META_SIZE(*stbMeta);
   *pTableMeta = taosMemoryRealloc(*pTableMeta, metaSize);
-  if (NULL == *pTableMeta) {    
+  if (NULL == *pTableMeta) {
     CTG_UNLOCK(CTG_READ, &dbCache->tbCache.stbLock);
     ctgReleaseDBCache(pCtg, dbCache);
     ctgError("realloc size[%d] failed", metaSize);
@@ -904,23 +866,23 @@ int32_t ctgGetTableMetaFromCache(SCatalog* pCtg, const SName* pTableName, STable
   CTG_CACHE_STAT_ADD(tblHitNum, 1);
 
   ctgDebug("Got tbmeta from cache, dbFName:%s, tbName:%s", dbFName, pTableName->tname);
-  
+
   return TSDB_CODE_SUCCESS;
 
 _return:
 
   *inCache = false;
   CTG_CACHE_STAT_ADD(tblMissNum, 1);
-  
+
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t ctgGetTableTypeFromCache(SCatalog* pCtg, const char* dbFName, const char *tableName, int32_t *tbType) {
+int32_t ctgGetTableTypeFromCache(SCatalog *pCtg, const char *dbFName, const char *tableName, int32_t *tbType) {
   if (NULL == pCtg->dbCache) {
-    ctgWarn("empty db cache, dbFName:%s, tbName:%s", dbFName, tableName);  
+    ctgWarn("empty db cache, dbFName:%s, tbName:%s", dbFName, tableName);
     return TSDB_CODE_SUCCESS;
   }
-  
+
   SCtgDBCache *dbCache = NULL;
   ctgAcquireDBCache(pCtg, dbFName, &dbCache);
   if (NULL == dbCache) {
@@ -932,9 +894,9 @@ int32_t ctgGetTableTypeFromCache(SCatalog* pCtg, const char* dbFName, const char
 
   if (NULL == pTableMeta) {
     CTG_UNLOCK(CTG_READ, &dbCache->tbCache.metaLock);
-    ctgWarn("tbl not in cache, dbFName:%s, tbName:%s", dbFName, tableName);  
+    ctgWarn("tbl not in cache, dbFName:%s, tbName:%s", dbFName, tableName);
     ctgReleaseDBCache(pCtg, dbCache);
-    
+
     return TSDB_CODE_SUCCESS;
   }
 
@@ -946,17 +908,18 @@ int32_t ctgGetTableTypeFromCache(SCatalog* pCtg, const char* dbFName, const char
 
   ctgReleaseDBCache(pCtg, dbCache);
 
-  ctgDebug("Got tbtype from cache, dbFName:%s, tbName:%s, type:%d", dbFName, tableName, *tbType);  
-  
+  ctgDebug("Got tbtype from cache, dbFName:%s, tbName:%s, type:%d", dbFName, tableName, *tbType);
+
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t ctgChkAuthFromCache(SCatalog* pCtg, const char* user, const char* dbFName, AUTH_TYPE type, bool *inCache, bool *pass) {
+int32_t ctgChkAuthFromCache(SCatalog *pCtg, const char *user, const char *dbFName, AUTH_TYPE type, bool *inCache,
+                            bool *pass) {
   if (NULL == pCtg->userCache) {
     ctgDebug("empty user auth cache, user:%s", user);
     goto _return;
   }
-  
+
   SCtgUserAuth *pUser = (SCtgUserAuth *)taosHashGet(pCtg->userCache, user, strlen(user));
   if (NULL == pUser) {
     ctgDebug("user not in cache, user:%s", user);
@@ -967,7 +930,7 @@ int32_t ctgChkAuthFromCache(SCatalog* pCtg, const char* user, const char* dbFNam
 
   ctgDebug("Got user from cache, user:%s", user);
   CTG_CACHE_STAT_ADD(userHitNum, 1);
-  
+
   if (pUser->superUser) {
     *pass = true;
     return TSDB_CODE_SUCCESS;
@@ -979,32 +942,33 @@ int32_t ctgChkAuthFromCache(SCatalog* pCtg, const char* user, const char* dbFNam
     CTG_UNLOCK(CTG_READ, &pUser->lock);
     return TSDB_CODE_SUCCESS;
   }
-  
+
   if (pUser->readDbs && taosHashGet(pUser->readDbs, dbFName, strlen(dbFName)) && type == AUTH_TYPE_READ) {
     *pass = true;
   }
-  
+
   if (pUser->writeDbs && taosHashGet(pUser->writeDbs, dbFName, strlen(dbFName)) && type == AUTH_TYPE_WRITE) {
     *pass = true;
   }
 
   CTG_UNLOCK(CTG_READ, &pUser->lock);
-  
+
   return TSDB_CODE_SUCCESS;
 
 _return:
 
   *inCache = false;
   CTG_CACHE_STAT_ADD(userMissNum, 1);
-  
+
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t ctgGetTableMetaFromMnodeImpl(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps, char *dbFName, char* tbName, STableMetaOutput* output) {
+int32_t ctgGetTableMetaFromMnodeImpl(SCatalog *pCtg, void *pTrans, const SEpSet *pMgmtEps, char *dbFName, char *tbName,
+                                     STableMetaOutput *output) {
   SBuildTableMetaInput bInput = {.vgId = 0, .dbFName = dbFName, .tbName = tbName};
-  char *msg = NULL;
-  SEpSet *pVnodeEpSet = NULL;
-  int32_t msgLen = 0;
+  char                *msg = NULL;
+  SEpSet              *pVnodeEpSet = NULL;
+  int32_t              msgLen = 0;
 
   ctgDebug("try to get table meta from mnode, dbFName:%s, tbName:%s", dbFName, tbName);
 
@@ -1016,22 +980,23 @@ int32_t ctgGetTableMetaFromMnodeImpl(SCatalog* pCtg, void *pTrans, const SEpSet*
 
   SRpcMsg rpcMsg = {
       .msgType = TDMT_MND_TABLE_META,
-      .pCont   = msg,
+      .pCont = msg,
       .contLen = msgLen,
   };
 
   SRpcMsg rpcRsp = {0};
 
-  rpcSendRecv(pTrans, (SEpSet*)pMgmtEps, &rpcMsg, &rpcRsp);
-  
+  rpcSendRecv(pTrans, (SEpSet *)pMgmtEps, &rpcMsg, &rpcRsp);
+
   if (TSDB_CODE_SUCCESS != rpcRsp.code) {
     if (CTG_TABLE_NOT_EXIST(rpcRsp.code)) {
       SET_META_TYPE_NULL(output->metaType);
       ctgDebug("stablemeta not exist in mnode, dbFName:%s, tbName:%s", dbFName, tbName);
       return TSDB_CODE_SUCCESS;
     }
-    
-    ctgError("error rsp for stablemeta from mnode, code:%s, dbFName:%s, tbName:%s", tstrerror(rpcRsp.code), dbFName, tbName);
+
+    ctgError("error rsp for stablemeta from mnode, code:%s, dbFName:%s, tbName:%s", tstrerror(rpcRsp.code), dbFName,
+             tbName);
     CTG_ERR_RET(rpcRsp.code);
   }
 
@@ -1046,15 +1011,18 @@ int32_t ctgGetTableMetaFromMnodeImpl(SCatalog* pCtg, void *pTrans, const SEpSet*
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t ctgGetTableMetaFromMnode(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps, const SName* pTableName, STableMetaOutput* output) {
+int32_t ctgGetTableMetaFromMnode(SCatalog *pCtg, void *pTrans, const SEpSet *pMgmtEps, const SName *pTableName,
+                                 STableMetaOutput *output) {
   char dbFName[TSDB_DB_FNAME_LEN];
   tNameGetFullDbName(pTableName, dbFName);
 
   return ctgGetTableMetaFromMnodeImpl(pCtg, pTrans, pMgmtEps, dbFName, (char *)pTableName->tname, output);
 }
 
-int32_t ctgGetTableMetaFromVnodeImpl(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps, const SName* pTableName, SVgroupInfo *vgroupInfo, STableMetaOutput* output) {
-  if (NULL == pCtg || NULL == pTrans || NULL == pMgmtEps || NULL == pTableName || NULL == vgroupInfo || NULL == output) {
+int32_t ctgGetTableMetaFromVnodeImpl(SCatalog *pCtg, void *pTrans, const SEpSet *pMgmtEps, const SName *pTableName,
+                                     SVgroupInfo *vgroupInfo, STableMetaOutput *output) {
+  if (NULL == pCtg || NULL == pTrans || NULL == pMgmtEps || NULL == pTableName || NULL == vgroupInfo ||
+      NULL == output) {
     CTG_ERR_RET(TSDB_CODE_CTG_INVALID_INPUT);
   }
 
@@ -1063,39 +1031,43 @@ int32_t ctgGetTableMetaFromVnodeImpl(SCatalog* pCtg, void *pTrans, const SEpSet*
 
   ctgDebug("try to get table meta from vnode, dbFName:%s, tbName:%s", dbFName, tNameGetTableName(pTableName));
 
-  SBuildTableMetaInput bInput = {.vgId = vgroupInfo->vgId, .dbFName = dbFName, .tbName = (char *)tNameGetTableName(pTableName)};
-  char *msg = NULL;
+  SBuildTableMetaInput bInput = {
+      .vgId = vgroupInfo->vgId, .dbFName = dbFName, .tbName = (char *)tNameGetTableName(pTableName)};
+  char   *msg = NULL;
   int32_t msgLen = 0;
 
   int32_t code = queryBuildMsg[TMSG_INDEX(TDMT_VND_TABLE_META)](&bInput, &msg, 0, &msgLen);
   if (code) {
-    ctgError("Build vnode tablemeta msg failed, code:%x, dbFName:%s, tbName:%s", code, dbFName, tNameGetTableName(pTableName));
+    ctgError("Build vnode tablemeta msg failed, code:%x, dbFName:%s, tbName:%s", code, dbFName,
+             tNameGetTableName(pTableName));
     CTG_ERR_RET(code);
   }
 
   SRpcMsg rpcMsg = {
       .msgType = TDMT_VND_TABLE_META,
-      .pCont   = msg,
+      .pCont = msg,
       .contLen = msgLen,
   };
 
   SRpcMsg rpcRsp = {0};
   rpcSendRecv(pTrans, &vgroupInfo->epSet, &rpcMsg, &rpcRsp);
-  
+
   if (TSDB_CODE_SUCCESS != rpcRsp.code) {
     if (CTG_TABLE_NOT_EXIST(rpcRsp.code)) {
       SET_META_TYPE_NULL(output->metaType);
       ctgDebug("tablemeta not exist in vnode, dbFName:%s, tbName:%s", dbFName, tNameGetTableName(pTableName));
       return TSDB_CODE_SUCCESS;
     }
-  
-    ctgError("error rsp for table meta from vnode, code:%s, dbFName:%s, tbName:%s", tstrerror(rpcRsp.code), dbFName, tNameGetTableName(pTableName));
+
+    ctgError("error rsp for table meta from vnode, code:%s, dbFName:%s, tbName:%s", tstrerror(rpcRsp.code), dbFName,
+             tNameGetTableName(pTableName));
     CTG_ERR_RET(rpcRsp.code);
   }
 
   code = queryProcessMsgRsp[TMSG_INDEX(TDMT_VND_TABLE_META)](output, rpcRsp.pCont, rpcRsp.contLen);
   if (code) {
-    ctgError("Process vnode tablemeta rsp failed, code:%s, dbFName:%s, tbName:%s", tstrerror(code), dbFName, tNameGetTableName(pTableName));
+    ctgError("Process vnode tablemeta rsp failed, code:%s, dbFName:%s, tbName:%s", tstrerror(code), dbFName,
+             tNameGetTableName(pTableName));
     CTG_ERR_RET(code);
   }
 
@@ -1103,17 +1075,18 @@ int32_t ctgGetTableMetaFromVnodeImpl(SCatalog* pCtg, void *pTrans, const SEpSet*
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t ctgGetTableMetaFromVnode(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps, const SName* pTableName, SVgroupInfo *vgroupInfo, STableMetaOutput* output) {
+int32_t ctgGetTableMetaFromVnode(SCatalog *pCtg, void *pTrans, const SEpSet *pMgmtEps, const SName *pTableName,
+                                 SVgroupInfo *vgroupInfo, STableMetaOutput *output) {
   int32_t code = 0;
   int32_t retryNum = 0;
-  
+
   while (retryNum < CTG_DEFAULT_MAX_RETRY_TIMES) {
     code = ctgGetTableMetaFromVnodeImpl(pCtg, pTrans, pMgmtEps, pTableName, vgroupInfo, output);
     if (code) {
       if (TSDB_CODE_VND_HASH_MISMATCH == code) {
         char dbFName[TSDB_DB_FNAME_LEN];
         tNameGetFullDbName(pTableName, dbFName);
-        
+
         code = catalogRefreshDBVgInfo(pCtg, pTrans, pMgmtEps, dbFName);
         if (code != TSDB_CODE_SUCCESS) {
           break;
@@ -1140,17 +1113,17 @@ int32_t ctgGetHashFunction(int8_t hashMethod, tableNameHashFp *fp) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t ctgGenerateVgList(SCatalog *pCtg, SHashObj *vgHash, SArray** pList) {
-  SHashObj *vgroupHash = NULL;
+int32_t ctgGenerateVgList(SCatalog *pCtg, SHashObj *vgHash, SArray **pList) {
+  SHashObj    *vgroupHash = NULL;
   SVgroupInfo *vgInfo = NULL;
-  SArray *vgList = NULL;
-  int32_t code = 0;
-  int32_t vgNum = taosHashGetSize(vgHash);
+  SArray      *vgList = NULL;
+  int32_t      code = 0;
+  int32_t      vgNum = taosHashGetSize(vgHash);
 
   vgList = taosArrayInit(vgNum, sizeof(SVgroupInfo));
   if (NULL == vgList) {
     ctgError("taosArrayInit failed, num:%d", vgNum);
-    CTG_ERR_RET(TSDB_CODE_CTG_MEM_ERROR);    
+    CTG_ERR_RET(TSDB_CODE_CTG_MEM_ERROR);
   }
 
   void *pIter = taosHashIterate(vgHash, NULL);
@@ -1159,10 +1132,10 @@ int32_t ctgGenerateVgList(SCatalog *pCtg, SHashObj *vgHash, SArray** pList) {
 
     if (NULL == taosArrayPush(vgList, vgInfo)) {
       ctgError("taosArrayPush failed, vgId:%d", vgInfo->vgId);
-      taosHashCancelIterate(vgHash, pIter);      
+      taosHashCancelIterate(vgHash, pIter);
       CTG_ERR_JRET(TSDB_CODE_CTG_MEM_ERROR);
     }
-    
+
     pIter = taosHashIterate(vgHash, pIter);
     vgInfo = NULL;
   }
@@ -1184,9 +1157,9 @@ _return:
 
 int32_t ctgGetVgInfoFromHashValue(SCatalog *pCtg, SDBVgInfo *dbInfo, const SName *pTableName, SVgroupInfo *pVgroup) {
   int32_t code = 0;
-  
+
   int32_t vgNum = taosHashGetSize(dbInfo->vgHash);
-  char db[TSDB_DB_FNAME_LEN] = {0};
+  char    db[TSDB_DB_FNAME_LEN] = {0};
   tNameGetFullDbName(pTableName, db);
 
   if (vgNum <= 0) {
@@ -1195,7 +1168,7 @@ int32_t ctgGetVgInfoFromHashValue(SCatalog *pCtg, SDBVgInfo *dbInfo, const SName
   }
 
   tableNameHashFp fp = NULL;
-  SVgroupInfo *vgInfo = NULL;
+  SVgroupInfo    *vgInfo = NULL;
 
   CTG_ERR_RET(ctgGetHashFunction(dbInfo->hashMethod, &fp));
 
@@ -1211,13 +1184,14 @@ int32_t ctgGetVgInfoFromHashValue(SCatalog *pCtg, SDBVgInfo *dbInfo, const SName
       taosHashCancelIterate(dbInfo->vgHash, pIter);
       break;
     }
-    
+
     pIter = taosHashIterate(dbInfo->vgHash, pIter);
     vgInfo = NULL;
   }
 
   if (NULL == vgInfo) {
-    ctgError("no hash range found for hash value [%u], db:%s, numOfVgId:%d", hashValue, db, taosHashGetSize(dbInfo->vgHash));
+    ctgError("no hash range found for hash value [%u], db:%s, numOfVgId:%d", hashValue, db,
+             taosHashGetSize(dbInfo->vgHash));
     CTG_ERR_RET(TSDB_CODE_CTG_INTERNAL_ERROR);
   }
 
@@ -1226,54 +1200,53 @@ int32_t ctgGetVgInfoFromHashValue(SCatalog *pCtg, SDBVgInfo *dbInfo, const SName
   CTG_RET(code);
 }
 
-int32_t ctgStbVersionSearchCompare(const void* key1, const void* key2) {
-  if (*(uint64_t *)key1 < ((SSTableMetaVersion*)key2)->suid) {
+int32_t ctgStbVersionSearchCompare(const void *key1, const void *key2) {
+  if (*(uint64_t *)key1 < ((SSTableMetaVersion *)key2)->suid) {
     return -1;
-  } else if (*(uint64_t *)key1 > ((SSTableMetaVersion*)key2)->suid) {
+  } else if (*(uint64_t *)key1 > ((SSTableMetaVersion *)key2)->suid) {
     return 1;
   } else {
     return 0;
   }
 }
 
-int32_t ctgDbVgVersionSearchCompare(const void* key1, const void* key2) {
-  if (*(int64_t *)key1 < ((SDbVgVersion*)key2)->dbId) {
+int32_t ctgDbVgVersionSearchCompare(const void *key1, const void *key2) {
+  if (*(int64_t *)key1 < ((SDbVgVersion *)key2)->dbId) {
     return -1;
-  } else if (*(int64_t *)key1 > ((SDbVgVersion*)key2)->dbId) {
+  } else if (*(int64_t *)key1 > ((SDbVgVersion *)key2)->dbId) {
     return 1;
   } else {
     return 0;
   }
 }
 
-int32_t ctgStbVersionSortCompare(const void* key1, const void* key2) {
-  if (((SSTableMetaVersion*)key1)->suid < ((SSTableMetaVersion*)key2)->suid) {
+int32_t ctgStbVersionSortCompare(const void *key1, const void *key2) {
+  if (((SSTableMetaVersion *)key1)->suid < ((SSTableMetaVersion *)key2)->suid) {
     return -1;
-  } else if (((SSTableMetaVersion*)key1)->suid > ((SSTableMetaVersion*)key2)->suid) {
+  } else if (((SSTableMetaVersion *)key1)->suid > ((SSTableMetaVersion *)key2)->suid) {
     return 1;
   } else {
     return 0;
   }
 }
 
-int32_t ctgDbVgVersionSortCompare(const void* key1, const void* key2) {
-  if (((SDbVgVersion*)key1)->dbId < ((SDbVgVersion*)key2)->dbId) {
+int32_t ctgDbVgVersionSortCompare(const void *key1, const void *key2) {
+  if (((SDbVgVersion *)key1)->dbId < ((SDbVgVersion *)key2)->dbId) {
     return -1;
-  } else if (((SDbVgVersion*)key1)->dbId > ((SDbVgVersion*)key2)->dbId) {
+  } else if (((SDbVgVersion *)key1)->dbId > ((SDbVgVersion *)key2)->dbId) {
     return 1;
   } else {
     return 0;
   }
 }
 
-
 int32_t ctgMetaRentInit(SCtgRentMgmt *mgmt, uint32_t rentSec, int8_t type) {
   mgmt->slotRIdx = 0;
   mgmt->slotNum = rentSec / CTG_RENT_SLOT_SECOND;
   mgmt->type = type;
 
   size_t msgSize = sizeof(SCtgRentSlot) * mgmt->slotNum;
-  
+
   mgmt->slots = taosMemoryCalloc(1, msgSize);
   if (NULL == mgmt->slots) {
     qError("calloc %d failed", (int32_t)msgSize);
@@ -1281,34 +1254,34 @@ int32_t ctgMetaRentInit(SCtgRentMgmt *mgmt, uint32_t rentSec, int8_t type) {
   }
 
   qDebug("meta rent initialized, type:%d, slotNum:%d", type, mgmt->slotNum);
-  
+
   return TSDB_CODE_SUCCESS;
 }
 
-
 int32_t ctgMetaRentAdd(SCtgRentMgmt *mgmt, void *meta, int64_t id, int32_t size) {
   int16_t widx = abs((int)(id % mgmt->slotNum));
 
   SCtgRentSlot *slot = &mgmt->slots[widx];
-  int32_t code = 0;
-  
+  int32_t       code = 0;
+
   CTG_LOCK(CTG_WRITE, &slot->lock);
   if (NULL == slot->meta) {
     slot->meta = taosArrayInit(CTG_DEFAULT_RENT_SLOT_SIZE, size);
     if (NULL == slot->meta) {
-      qError("taosArrayInit %d failed, id:%"PRIx64", slot idx:%d, type:%d", CTG_DEFAULT_RENT_SLOT_SIZE, id, widx, mgmt->type);
+      qError("taosArrayInit %d failed, id:%" PRIx64 ", slot idx:%d, type:%d", CTG_DEFAULT_RENT_SLOT_SIZE, id, widx,
+             mgmt->type);
       CTG_ERR_JRET(TSDB_CODE_CTG_MEM_ERROR);
     }
   }
 
   if (NULL == taosArrayPush(slot->meta, meta)) {
-    qError("taosArrayPush meta to rent failed, id:%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type);
+    qError("taosArrayPush meta to rent failed, id:%" PRIx64 ", slot idx:%d, type:%d", id, widx, mgmt->type);
     CTG_ERR_JRET(TSDB_CODE_CTG_MEM_ERROR);
   }
 
   slot->needSort = true;
 
-  qDebug("add meta to rent, id:%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type);
+  qDebug("add meta to rent, id:%" PRIx64 ", slot idx:%d, type:%d", id, widx, mgmt->type);
 
 _return:
 
@@ -1316,20 +1289,22 @@ _return:
   CTG_RET(code);
 }
 
-int32_t ctgMetaRentUpdate(SCtgRentMgmt *mgmt, void *meta, int64_t id, int32_t size, __compar_fn_t sortCompare, __compar_fn_t searchCompare) {
+int32_t ctgMetaRentUpdate(SCtgRentMgmt *mgmt, void *meta, int64_t id, int32_t size, __compar_fn_t sortCompare,
+                          __compar_fn_t searchCompare) {
   int16_t widx = abs((int)(id % mgmt->slotNum));
 
   SCtgRentSlot *slot = &mgmt->slots[widx];
-  int32_t code = 0;
+  int32_t       code = 0;
 
   CTG_LOCK(CTG_WRITE, &slot->lock);
   if (NULL == slot->meta) {
-    qError("empty meta slot, id:%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type);
+    qError("empty meta slot, id:%" PRIx64 ", slot idx:%d, type:%d", id, widx, mgmt->type);
     CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR);
   }
 
   if (slot->needSort) {
-    qDebug("meta slot before sorte, slot idx:%d, type:%d, size:%d", widx, mgmt->type, (int32_t)taosArrayGetSize(slot->meta));
+    qDebug("meta slot before sorte, slot idx:%d, type:%d, size:%d", widx, mgmt->type,
+           (int32_t)taosArrayGetSize(slot->meta));
     taosArraySort(slot->meta, sortCompare);
     slot->needSort = false;
     qDebug("meta slot sorted, slot idx:%d, type:%d, size:%d", widx, mgmt->type, (int32_t)taosArrayGetSize(slot->meta));
@@ -1337,20 +1312,22 @@ int32_t ctgMetaRentUpdate(SCtgRentMgmt *mgmt, void *meta, int64_t id, int32_t si
 
   void *orig = taosArraySearch(slot->meta, &id, searchCompare, TD_EQ);
   if (NULL == orig) {
-    qError("meta not found in slot, id:%"PRIx64", slot idx:%d, type:%d, size:%d", id, widx, mgmt->type, (int32_t)taosArrayGetSize(slot->meta));
+    qError("meta not found in slot, id:%" PRIx64 ", slot idx:%d, type:%d, size:%d", id, widx, mgmt->type,
+           (int32_t)taosArrayGetSize(slot->meta));
     CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR);
   }
 
   memcpy(orig, meta, size);
 
-  qDebug("meta in rent updated, id:%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type);
+  qDebug("meta in rent updated, id:%" PRIx64 ", slot idx:%d, type:%d", id, widx, mgmt->type);
 
 _return:
 
   CTG_UNLOCK(CTG_WRITE, &slot->lock);
 
   if (code) {
-    qWarn("meta in rent update failed, will try to add it, code:%x, id:%"PRIx64", slot idx:%d, type:%d", code, id, widx, mgmt->type);
+    qWarn("meta in rent update failed, will try to add it, code:%x, id:%" PRIx64 ", slot idx:%d, type:%d", code, id,
+          widx, mgmt->type);
     CTG_RET(ctgMetaRentAdd(mgmt, meta, id, size));
   }
 
@@ -1361,11 +1338,11 @@ int32_t ctgMetaRentRemove(SCtgRentMgmt *mgmt, int64_t id, __compar_fn_t sortComp
   int16_t widx = abs((int)(id % mgmt->slotNum));
 
   SCtgRentSlot *slot = &mgmt->slots[widx];
-  int32_t code = 0;
-  
+  int32_t       code = 0;
+
   CTG_LOCK(CTG_WRITE, &slot->lock);
   if (NULL == slot->meta) {
-    qError("empty meta slot, id:%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type);
+    qError("empty meta slot, id:%" PRIx64 ", slot idx:%d, type:%d", id, widx, mgmt->type);
     CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR);
   }
 
@@ -1377,13 +1354,13 @@ int32_t ctgMetaRentRemove(SCtgRentMgmt *mgmt, int64_t id, __compar_fn_t sortComp
 
   int32_t idx = taosArraySearchIdx(slot->meta, &id, searchCompare, TD_EQ);
   if (idx < 0) {
-    qError("meta not found in slot, id:%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type);
+    qError("meta not found in slot, id:%" PRIx64 ", slot idx:%d, type:%d", id, widx, mgmt->type);
     CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR);
   }
 
   taosArrayRemove(slot->meta, idx);
 
-  qDebug("meta in rent removed, id:%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type);
+  qDebug("meta in rent removed, id:%" PRIx64 ", slot idx:%d, type:%d", id, widx, mgmt->type);
 
 _return:
 
@@ -1392,7 +1369,6 @@ _return:
   CTG_RET(code);
 }
 
-
 int32_t ctgMetaRentGetImpl(SCtgRentMgmt *mgmt, void **res, uint32_t *num, int32_t size) {
   int16_t ridx = atomic_add_fetch_16(&mgmt->slotRIdx, 1);
   if (ridx >= mgmt->slotNum) {
@@ -1401,8 +1377,8 @@ int32_t ctgMetaRentGetImpl(SCtgRentMgmt *mgmt, void **res, uint32_t *num, int32_
   }
 
   SCtgRentSlot *slot = &mgmt->slots[ridx];
-  int32_t code = 0;
-  
+  int32_t       code = 0;
+
   CTG_LOCK(CTG_READ, &slot->lock);
   if (NULL == slot->meta) {
     qDebug("empty meta in slot:%d, type:%d", ridx, mgmt->type);
@@ -1468,13 +1444,15 @@ int32_t ctgAddNewDBCache(SCatalog *pCtg, const char *dbFName, uint64_t dbId) {
   SCtgDBCache newDBCache = {0};
   newDBCache.dbId = dbId;
 
-  newDBCache.tbCache.metaCache = taosHashInit(gCtgMgmt.cfg.maxTblCacheNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
+  newDBCache.tbCache.metaCache = taosHashInit(gCtgMgmt.cfg.maxTblCacheNum,
+                                              taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
   if (NULL == newDBCache.tbCache.metaCache) {
     ctgError("taosHashInit %d metaCache failed", gCtgMgmt.cfg.maxTblCacheNum);
     CTG_ERR_RET(TSDB_CODE_CTG_MEM_ERROR);
   }
 
-  newDBCache.tbCache.stbCache = taosHashInit(gCtgMgmt.cfg.maxTblCacheNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), true, HASH_ENTRY_LOCK);
+  newDBCache.tbCache.stbCache = taosHashInit(gCtgMgmt.cfg.maxTblCacheNum,
+                                             taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), true, HASH_ENTRY_LOCK);
   if (NULL == newDBCache.tbCache.stbCache) {
     ctgError("taosHashInit %d stbCache failed", gCtgMgmt.cfg.maxTblCacheNum);
     CTG_ERR_JRET(TSDB_CODE_CTG_MEM_ERROR);
@@ -1486,21 +1464,21 @@ int32_t ctgAddNewDBCache(SCatalog *pCtg, const char *dbFName, uint64_t dbId) {
       ctgDebug("db already in cache, dbFName:%s", dbFName);
       goto _return;
     }
-    
+
     ctgError("taosHashPut db to cache failed, dbFName:%s", dbFName);
     CTG_ERR_JRET(TSDB_CODE_CTG_MEM_ERROR);
   }
 
   CTG_CACHE_STAT_ADD(dbNum, 1);
- 
+
   SDbVgVersion vgVersion = {.dbId = newDBCache.dbId, .vgVersion = -1};
   strncpy(vgVersion.dbFName, dbFName, sizeof(vgVersion.dbFName));
 
-  ctgDebug("db added to cache, dbFName:%s, dbId:%"PRIx64, dbFName, dbId);
+  ctgDebug("db added to cache, dbFName:%s, dbId:%" PRIx64, dbFName, dbId);
 
   CTG_ERR_RET(ctgMetaRentAdd(&pCtg->dbRent, &vgVersion, dbId, sizeof(SDbVgVersion)));
 
-  ctgDebug("db added to rent, dbFName:%s, vgVersion:%d, dbId:%"PRIx64, dbFName, vgVersion.vgVersion, dbId);
+  ctgDebug("db added to rent, dbFName:%s, vgVersion:%d, dbId:%" PRIx64, dbFName, vgVersion.vgVersion, dbId);
 
   return TSDB_CODE_SUCCESS;
 
@@ -1511,8 +1489,7 @@ _return:
   CTG_RET(code);
 }
 
-
-void ctgRemoveStbRent(SCatalog* pCtg, SCtgTbMetaCache *cache) {
+void ctgRemoveStbRent(SCatalog *pCtg, SCtgTbMetaCache *cache) {
   CTG_LOCK(CTG_WRITE, &cache->stbLock);
   if (cache->stbCache) {
     void *pIter = taosHashIterate(cache->stbCache, NULL);
@@ -1520,21 +1497,21 @@ void ctgRemoveStbRent(SCatalog* pCtg, SCtgTbMetaCache *cache) {
       uint64_t *suid = NULL;
       suid = taosHashGetKey(pIter, NULL);
 
-      if (TSDB_CODE_SUCCESS == ctgMetaRentRemove(&pCtg->stbRent, *suid, ctgStbVersionSortCompare, ctgStbVersionSearchCompare)) {
-        ctgDebug("stb removed from rent, suid:%"PRIx64, *suid);
+      if (TSDB_CODE_SUCCESS ==
+          ctgMetaRentRemove(&pCtg->stbRent, *suid, ctgStbVersionSortCompare, ctgStbVersionSearchCompare)) {
+        ctgDebug("stb removed from rent, suid:%" PRIx64, *suid);
       }
-          
+
       pIter = taosHashIterate(cache->stbCache, pIter);
     }
   }
   CTG_UNLOCK(CTG_WRITE, &cache->stbLock);
 }
 
-
-int32_t ctgRemoveDB(SCatalog* pCtg, SCtgDBCache *dbCache, const char* dbFName) {
+int32_t ctgRemoveDB(SCatalog *pCtg, SCtgDBCache *dbCache, const char *dbFName) {
   uint64_t dbId = dbCache->dbId;
-  
-  ctgInfo("start to remove db from cache, dbFName:%s, dbId:%"PRIx64, dbFName, dbCache->dbId);
+
+  ctgInfo("start to remove db from cache, dbFName:%s, dbId:%" PRIx64, dbFName, dbCache->dbId);
 
   atomic_store_8(&dbCache->deleted, 1);
 
@@ -1543,8 +1520,8 @@ int32_t ctgRemoveDB(SCatalog* pCtg, SCtgDBCache *dbCache, const char* dbFName) {
   ctgFreeDbCache(dbCache);
 
   CTG_ERR_RET(ctgMetaRentRemove(&pCtg->dbRent, dbCache->dbId, ctgDbVgVersionSortCompare, ctgDbVgVersionSearchCompare));
-  
-  ctgDebug("db removed from rent, dbFName:%s, dbId:%"PRIx64, dbFName, dbCache->dbId);
+
+  ctgDebug("db removed from rent, dbFName:%s, dbId:%" PRIx64, dbFName, dbCache->dbId);
 
   if (taosHashRemove(pCtg->dbCache, dbFName, strlen(dbFName))) {
     ctgInfo("taosHashRemove from dbCache failed, may be removed, dbFName:%s", dbFName);
@@ -1553,19 +1530,18 @@ int32_t ctgRemoveDB(SCatalog* pCtg, SCtgDBCache *dbCache, const char* dbFName) {
 
   CTG_CACHE_STAT_SUB(dbNum, 1);
 
-  ctgInfo("db removed from cache, dbFName:%s, dbId:%"PRIx64, dbFName, dbId);
-  
+  ctgInfo("db removed from cache, dbFName:%s, dbId:%" PRIx64, dbFName, dbId);
+
   return TSDB_CODE_SUCCESS;
 }
 
-
-int32_t ctgGetAddDBCache(SCatalog* pCtg, const char *dbFName, uint64_t dbId, SCtgDBCache **pCache) {
-  int32_t code = 0;
+int32_t ctgGetAddDBCache(SCatalog *pCtg, const char *dbFName, uint64_t dbId, SCtgDBCache **pCache) {
+  int32_t      code = 0;
   SCtgDBCache *dbCache = NULL;
   ctgGetDBCache(pCtg, dbFName, &dbCache);
-  
+
   if (dbCache) {
-  // TODO OPEN IT
+    // TODO OPEN IT
 #if 0    
     if (dbCache->dbId == dbId) {
       *pCache = dbCache;
@@ -1582,7 +1558,7 @@ int32_t ctgGetAddDBCache(SCatalog* pCtg, const char *dbFName, uint64_t dbId, SCt
       *pCache = dbCache;
       return TSDB_CODE_SUCCESS;
     }
-    
+
     if (dbCache->dbId == dbId) {
       *pCache = dbCache;
       return TSDB_CODE_SUCCESS;
@@ -1590,7 +1566,7 @@ int32_t ctgGetAddDBCache(SCatalog* pCtg, const char *dbFName, uint64_t dbId, SCt
 #endif
     CTG_ERR_RET(ctgRemoveDB(pCtg, dbCache, dbFName));
   }
-  
+
   CTG_ERR_RET(ctgAddNewDBCache(pCtg, dbFName, dbId));
 
   ctgGetDBCache(pCtg, dbFName, &dbCache);
@@ -1600,46 +1576,47 @@ int32_t ctgGetAddDBCache(SCatalog* pCtg, const char *dbFName, uint64_t dbId, SCt
   return TSDB_CODE_SUCCESS;
 }
 
-
-int32_t ctgUpdateDBVgInfo(SCatalog* pCtg, const char* dbFName, uint64_t dbId, SDBVgInfo** pDbInfo) {
-  int32_t code = 0;
-  SDBVgInfo* dbInfo = *pDbInfo;
+int32_t ctgUpdateDBVgInfo(SCatalog *pCtg, const char *dbFName, uint64_t dbId, SDBVgInfo **pDbInfo) {
+  int32_t    code = 0;
+  SDBVgInfo *dbInfo = *pDbInfo;
 
   if (NULL == dbInfo->vgHash) {
     return TSDB_CODE_SUCCESS;
   }
-  
+
   if (dbInfo->vgVersion < 0 || taosHashGetSize(dbInfo->vgHash) <= 0) {
-    ctgError("invalid db vgInfo, dbFName:%s, vgHash:%p, vgVersion:%d, vgHashSize:%d", 
-      dbFName, dbInfo->vgHash, dbInfo->vgVersion, taosHashGetSize(dbInfo->vgHash));
+    ctgError("invalid db vgInfo, dbFName:%s, vgHash:%p, vgVersion:%d, vgHashSize:%d", dbFName, dbInfo->vgHash,
+             dbInfo->vgVersion, taosHashGetSize(dbInfo->vgHash));
     CTG_ERR_RET(TSDB_CODE_CTG_MEM_ERROR);
   }
 
-  bool newAdded = false;
+  bool         newAdded = false;
   SDbVgVersion vgVersion = {.dbId = dbId, .vgVersion = dbInfo->vgVersion, .numOfTable = dbInfo->numOfTable};
 
   SCtgDBCache *dbCache = NULL;
   CTG_ERR_RET(ctgGetAddDBCache(pCtg, dbFName, dbId, &dbCache));
   if (NULL == dbCache) {
-    ctgInfo("conflict db update, ignore this update, dbFName:%s, dbId:%"PRIx64, dbFName, dbId);
+    ctgInfo("conflict db update, ignore this update, dbFName:%s, dbId:%" PRIx64, dbFName, dbId);
     CTG_ERR_RET(TSDB_CODE_CTG_INTERNAL_ERROR);
   }
 
   SDBVgInfo *vgInfo = NULL;
   CTG_ERR_RET(ctgWAcquireVgInfo(pCtg, dbCache));
-  
+
   if (dbCache->vgInfo) {
     if (dbInfo->vgVersion < dbCache->vgInfo->vgVersion) {
-      ctgDebug("db vgVersion is old, dbFName:%s, vgVersion:%d, currentVersion:%d", dbFName, dbInfo->vgVersion, dbCache->vgInfo->vgVersion);
+      ctgDebug("db vgVersion is old, dbFName:%s, vgVersion:%d, currentVersion:%d", dbFName, dbInfo->vgVersion,
+               dbCache->vgInfo->vgVersion);
       ctgWReleaseVgInfo(dbCache);
-      
+
       return TSDB_CODE_SUCCESS;
     }
 
     if (dbInfo->vgVersion == dbCache->vgInfo->vgVersion && dbInfo->numOfTable == dbCache->vgInfo->numOfTable) {
-      ctgDebug("no new db vgVersion or numOfTable, dbFName:%s, vgVersion:%d, numOfTable:%d", dbFName, dbInfo->vgVersion, dbInfo->numOfTable);
+      ctgDebug("no new db vgVersion or numOfTable, dbFName:%s, vgVersion:%d, numOfTable:%d", dbFName, dbInfo->vgVersion,
+               dbInfo->numOfTable);
       ctgWReleaseVgInfo(dbCache);
-      
+
       return TSDB_CODE_SUCCESS;
     }
 
@@ -1650,53 +1627,55 @@ int32_t ctgUpdateDBVgInfo(SCatalog* pCtg, const char* dbFName, uint64_t dbId, SD
 
   *pDbInfo = NULL;
 
-  ctgDebug("db vgInfo updated, dbFName:%s, vgVersion:%d, dbId:%"PRIx64, dbFName, vgVersion.vgVersion, vgVersion.dbId);
+  ctgDebug("db vgInfo updated, dbFName:%s, vgVersion:%d, dbId:%" PRIx64, dbFName, vgVersion.vgVersion, vgVersion.dbId);
 
   ctgWReleaseVgInfo(dbCache);
 
   dbCache = NULL;
 
   strncpy(vgVersion.dbFName, dbFName, sizeof(vgVersion.dbFName));
-  CTG_ERR_RET(ctgMetaRentUpdate(&pCtg->dbRent, &vgVersion, vgVersion.dbId, sizeof(SDbVgVersion), ctgDbVgVersionSortCompare, ctgDbVgVersionSearchCompare));
-  
+  CTG_ERR_RET(ctgMetaRentUpdate(&pCtg->dbRent, &vgVersion, vgVersion.dbId, sizeof(SDbVgVersion),
+                                ctgDbVgVersionSortCompare, ctgDbVgVersionSearchCompare));
+
   CTG_RET(code);
 }
 
-
-int32_t ctgUpdateTblMeta(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFName, uint64_t dbId, char *tbName, STableMeta *meta, int32_t metaSize) {
+int32_t ctgUpdateTblMeta(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFName, uint64_t dbId, char *tbName,
+                         STableMeta *meta, int32_t metaSize) {
   SCtgTbMetaCache *tbCache = &dbCache->tbCache;
 
   CTG_LOCK(CTG_READ, &tbCache->metaLock);
   if (dbCache->deleted || NULL == tbCache->metaCache || NULL == tbCache->stbCache) {
-    CTG_UNLOCK(CTG_READ, &tbCache->metaLock);    
-    ctgError("db is dropping, dbId:%"PRIx64, dbCache->dbId);
+    CTG_UNLOCK(CTG_READ, &tbCache->metaLock);
+    ctgError("db is dropping, dbId:%" PRIx64, dbCache->dbId);
     CTG_ERR_RET(TSDB_CODE_CTG_DB_DROPPED);
   }
 
-  int8_t origType = 0;
-  uint64_t origSuid = 0;
-  bool isStb = meta->tableType == TSDB_SUPER_TABLE;
+  int8_t      origType = 0;
+  uint64_t    origSuid = 0;
+  bool        isStb = meta->tableType == TSDB_SUPER_TABLE;
   STableMeta *orig = taosHashGet(tbCache->metaCache, tbName, strlen(tbName));
   if (orig) {
     origType = orig->tableType;
 
-    if (origType == meta->tableType && orig->uid == meta->uid && orig->sversion >= meta->sversion && orig->tversion >= meta->tversion) {
-      CTG_UNLOCK(CTG_READ, &tbCache->metaLock);  
+    if (origType == meta->tableType && orig->uid == meta->uid && orig->sversion >= meta->sversion &&
+        orig->tversion >= meta->tversion) {
+      CTG_UNLOCK(CTG_READ, &tbCache->metaLock);
       return TSDB_CODE_SUCCESS;
     }
-    
+
     if (origType == TSDB_SUPER_TABLE) {
       if ((!isStb) || orig->suid != meta->suid) {
         CTG_LOCK(CTG_WRITE, &tbCache->stbLock);
         if (taosHashRemove(tbCache->stbCache, &orig->suid, sizeof(orig->suid))) {
-          ctgError("stb not exist in stbCache, dbFName:%s, stb:%s, suid:%"PRIx64, dbFName, tbName, orig->suid);
+          ctgError("stb not exist in stbCache, dbFName:%s, stb:%s, suid:%" PRIx64, dbFName, tbName, orig->suid);
         } else {
           CTG_CACHE_STAT_SUB(stblNum, 1);
         }
         CTG_UNLOCK(CTG_WRITE, &tbCache->stbLock);
 
-        ctgDebug("stb removed from stbCache, dbFName:%s, stb:%s, suid:%"PRIx64, dbFName, tbName, orig->suid);
-        
+        ctgDebug("stb removed from stbCache, dbFName:%s, stb:%s, suid:%" PRIx64, dbFName, tbName, orig->suid);
+
         ctgMetaRentRemove(&pCtg->stbRent, orig->suid, ctgStbVersionSortCompare, ctgStbVersionSearchCompare);
       }
 
@@ -1707,13 +1686,13 @@ int32_t ctgUpdateTblMeta(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFName, ui
   if (isStb) {
     CTG_LOCK(CTG_WRITE, &tbCache->stbLock);
   }
-  
+
   if (taosHashPut(tbCache->metaCache, tbName, strlen(tbName), meta, metaSize) != 0) {
     if (isStb) {
       CTG_UNLOCK(CTG_WRITE, &tbCache->stbLock);
     }
-    
-    CTG_UNLOCK(CTG_READ, &tbCache->metaLock);  
+
+    CTG_UNLOCK(CTG_READ, &tbCache->metaLock);
     ctgError("taosHashPut tbmeta to cache failed, dbFName:%s, tbName:%s, tbType:%d", dbFName, tbName, meta->tableType);
     CTG_ERR_RET(TSDB_CODE_CTG_MEM_ERROR);
   }
@@ -1722,35 +1701,38 @@ int32_t ctgUpdateTblMeta(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFName, ui
     CTG_CACHE_STAT_ADD(tblNum, 1);
   }
 
-  ctgDebug("tbmeta updated to cache, dbFName:%s, tbName:%s, tbType:%d, suid:%" PRIx64, dbFName, tbName, meta->tableType, meta->suid);
+  ctgDebug("tbmeta updated to cache, dbFName:%s, tbName:%s, tbType:%d, suid:%" PRIx64, dbFName, tbName, meta->tableType,
+           meta->suid);
   ctgdShowTableMeta(pCtg, tbName, meta);
 
   if (!isStb) {
-    CTG_UNLOCK(CTG_READ, &tbCache->metaLock);  
+    CTG_UNLOCK(CTG_READ, &tbCache->metaLock);
     return TSDB_CODE_SUCCESS;
   }
 
   STableMeta *tbMeta = taosHashGet(tbCache->metaCache, tbName, strlen(tbName));
   if (taosHashPut(tbCache->stbCache, &meta->suid, sizeof(meta->suid), &tbMeta, POINTER_BYTES) != 0) {
     CTG_UNLOCK(CTG_WRITE, &tbCache->stbLock);
-    CTG_UNLOCK(CTG_READ, &tbCache->metaLock);    
-    ctgError("taosHashPut stable to stable cache failed, suid:%"PRIx64, meta->suid);
+    CTG_UNLOCK(CTG_READ, &tbCache->metaLock);
+    ctgError("taosHashPut stable to stable cache failed, suid:%" PRIx64, meta->suid);
     CTG_ERR_RET(TSDB_CODE_CTG_MEM_ERROR);
   }
 
   CTG_CACHE_STAT_ADD(stblNum, 1);
-  
+
   CTG_UNLOCK(CTG_WRITE, &tbCache->stbLock);
 
   CTG_UNLOCK(CTG_READ, &tbCache->metaLock);
 
-  ctgDebug("stb updated to stbCache, dbFName:%s, tbName:%s, tbType:%d, suid:%" PRIx64 ",ma:%p", dbFName, tbName, meta->tableType, meta->suid, tbMeta);
+  ctgDebug("stb updated to stbCache, dbFName:%s, tbName:%s, tbType:%d, suid:%" PRIx64 ",ma:%p", dbFName, tbName,
+           meta->tableType, meta->suid, tbMeta);
 
-  SSTableMetaVersion metaRent = {.dbId = dbId, .suid = meta->suid, .sversion = meta->sversion, .tversion = meta->tversion};
+  SSTableMetaVersion metaRent = {
+      .dbId = dbId, .suid = meta->suid, .sversion = meta->sversion, .tversion = meta->tversion};
   strcpy(metaRent.dbFName, dbFName);
   strcpy(metaRent.stbName, tbName);
   CTG_ERR_RET(ctgMetaRentAdd(&pCtg->stbRent, &metaRent, metaRent.suid, sizeof(SSTableMetaVersion)));
-  
+
   return TSDB_CODE_SUCCESS;
 }
 
@@ -1772,7 +1754,7 @@ int32_t ctgCloneVgInfo(SDBVgInfo *src, SDBVgInfo **dst) {
   }
 
   int32_t *vgId = NULL;
-  void *pIter = taosHashIterate(src->vgHash, NULL);
+  void    *pIter = taosHashIterate(src->vgHash, NULL);
   while (pIter) {
     vgId = taosHashGetKey(pIter, NULL);
 
@@ -1783,18 +1765,16 @@ int32_t ctgCloneVgInfo(SDBVgInfo *src, SDBVgInfo **dst) {
       taosMemoryFreeClear(*dst);
       CTG_ERR_RET(TSDB_CODE_CTG_MEM_ERROR);
     }
-    
+
     pIter = taosHashIterate(src->vgHash, pIter);
   }
 
-
   return TSDB_CODE_SUCCESS;
 }
 
-
-
-int32_t ctgGetDBVgInfo(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const char* dbFName, SCtgDBCache** dbCache, SDBVgInfo **pInfo) {
-  bool inCache = false;
+int32_t ctgGetDBVgInfo(SCatalog *pCtg, void *pRpc, const SEpSet *pMgmtEps, const char *dbFName, SCtgDBCache **dbCache,
+                       SDBVgInfo **pInfo) {
+  bool    inCache = false;
   int32_t code = 0;
 
   CTG_ERR_RET(ctgAcquireVgInfoFromCache(pCtg, dbFName, dbCache, &inCache));
@@ -1803,7 +1783,7 @@ int32_t ctgGetDBVgInfo(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const
     return TSDB_CODE_SUCCESS;
   }
 
-  SUseDbOutput DbOut = {0};
+  SUseDbOutput     DbOut = {0};
   SBuildUseDBInput input = {0};
 
   tstrncpy(input.db, dbFName, tListLen(input.db));
@@ -1829,18 +1809,18 @@ _return:
 
   taosMemoryFreeClear(*pInfo);
   *pInfo = DbOut.dbVgroup;
-  
+
   CTG_RET(code);
 }
 
-int32_t ctgRefreshDBVgInfo(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const char* dbFName) {
-  bool inCache = false;
-  int32_t code = 0;
-  SCtgDBCache* dbCache = NULL;
+int32_t ctgRefreshDBVgInfo(SCatalog *pCtg, void *pRpc, const SEpSet *pMgmtEps, const char *dbFName) {
+  bool         inCache = false;
+  int32_t      code = 0;
+  SCtgDBCache *dbCache = NULL;
 
   CTG_ERR_RET(ctgAcquireVgInfoFromCache(pCtg, dbFName, &dbCache, &inCache));
 
-  SUseDbOutput DbOut = {0};
+  SUseDbOutput     DbOut = {0};
   SBuildUseDBInput input = {0};
   tstrncpy(input.db, dbFName, tListLen(input.db));
 
@@ -1850,7 +1830,7 @@ int32_t ctgRefreshDBVgInfo(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, c
     ctgReleaseVgInfo(dbCache);
     ctgReleaseDBCache(pCtg, dbCache);
   }
-  
+
   input.vgVersion = CTG_DEFAULT_INVALID_VERSION;
   input.numOfTable = 0;
 
@@ -1869,8 +1849,6 @@ int32_t ctgRefreshDBVgInfo(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, c
   return TSDB_CODE_SUCCESS;
 }
 
-
-
 int32_t ctgCloneMetaOutput(STableMetaOutput *output, STableMetaOutput **pOutput) {
   *pOutput = taosMemoryMalloc(sizeof(STableMetaOutput));
   if (NULL == *pOutput) {
@@ -1895,15 +1873,14 @@ int32_t ctgCloneMetaOutput(STableMetaOutput *output, STableMetaOutput **pOutput)
   return TSDB_CODE_SUCCESS;
 }
 
-
-
-int32_t ctgRefreshTblMeta(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps, const SName* pTableName, int32_t flag, STableMetaOutput **pOutput, bool syncReq) {
+int32_t ctgRefreshTblMeta(SCatalog *pCtg, void *pTrans, const SEpSet *pMgmtEps, const SName *pTableName, int32_t flag,
+                          STableMetaOutput **pOutput, bool syncReq) {
   if (NULL == pCtg || NULL == pTrans || NULL == pMgmtEps || NULL == pTableName) {
     CTG_ERR_RET(TSDB_CODE_CTG_INVALID_INPUT);
   }
 
   SVgroupInfo vgroupInfo = {0};
-  int32_t code = 0;
+  int32_t     code = 0;
 
   if (!CTG_FLAG_IS_SYS_DB(flag)) {
     CTG_ERR_RET(catalogGetTableHashVgroup(pCtg, pTrans, pMgmtEps, pTableName, &vgroupInfo));
@@ -1919,7 +1896,8 @@ int32_t ctgRefreshTblMeta(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps,
   if (CTG_FLAG_IS_SYS_DB(flag)) {
     ctgDebug("will refresh tbmeta, supposed in information_schema, tbName:%s", tNameGetTableName(pTableName));
 
-    CTG_ERR_JRET(ctgGetTableMetaFromMnodeImpl(pCtg, pTrans, pMgmtEps, (char *)pTableName->dbname, (char *)pTableName->tname, output));
+    CTG_ERR_JRET(ctgGetTableMetaFromMnodeImpl(pCtg, pTrans, pMgmtEps, (char *)pTableName->dbname,
+                                              (char *)pTableName->tname, output));
   } else if (CTG_FLAG_IS_STB(flag)) {
     ctgDebug("will refresh tbmeta, supposed to be stb, tbName:%s", tNameGetTableName(pTableName));
 
@@ -1939,7 +1917,7 @@ int32_t ctgRefreshTblMeta(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps,
       ctgDebug("will continue to refresh tbmeta since got stb, tbName:%s", tNameGetTableName(pTableName));
 
       taosMemoryFreeClear(output->tbMeta);
-      
+
       CTG_ERR_JRET(ctgGetTableMetaFromMnodeImpl(pCtg, pTrans, pMgmtEps, output->dbFName, output->tbName, output));
     } else if (CTG_IS_META_BOTH(output->metaType)) {
       int32_t exist = 0;
@@ -1953,14 +1931,14 @@ int32_t ctgRefreshTblMeta(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps,
         if (CTG_IS_META_NULL(moutput.metaType)) {
           SET_META_TYPE_NULL(output->metaType);
         }
-        
+
         taosMemoryFreeClear(output->tbMeta);
         output->tbMeta = moutput.tbMeta;
         moutput.tbMeta = NULL;
       } else {
         taosMemoryFreeClear(output->tbMeta);
-        
-        SET_META_TYPE_CTABLE(output->metaType); 
+
+        SET_META_TYPE_CTABLE(output->metaType);
       }
     }
   }
@@ -1972,9 +1950,11 @@ int32_t ctgRefreshTblMeta(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps,
   }
 
   if (CTG_IS_META_TABLE(output->metaType)) {
-    ctgDebug("tbmeta got, dbFName:%s, tbName:%s, tbType:%d", output->dbFName, output->tbName, output->tbMeta->tableType);
+    ctgDebug("tbmeta got, dbFName:%s, tbName:%s, tbType:%d", output->dbFName, output->tbName,
+             output->tbMeta->tableType);
   } else {
-    ctgDebug("tbmeta got, dbFName:%s, tbName:%s, tbType:%d, stbMetaGot:%d", output->dbFName, output->ctbName, output->ctbMeta.tableType, CTG_IS_META_BOTH(output->metaType));
+    ctgDebug("tbmeta got, dbFName:%s, tbName:%s, tbType:%d, stbMetaGot:%d", output->dbFName, output->ctbName,
+             output->ctbMeta.tableType, CTG_IS_META_BOTH(output->metaType));
   }
 
   if (pOutput) {
@@ -1989,19 +1969,20 @@ _return:
 
   taosMemoryFreeClear(output->tbMeta);
   taosMemoryFreeClear(output);
-  
+
   CTG_RET(code);
 }
 
-int32_t ctgGetTableMeta(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const SName* pTableName, STableMeta** pTableMeta, int32_t flag) {
+int32_t ctgGetTableMeta(SCatalog *pCtg, void *pRpc, const SEpSet *pMgmtEps, const SName *pTableName,
+                        STableMeta **pTableMeta, int32_t flag) {
   if (NULL == pCtg || NULL == pRpc || NULL == pMgmtEps || NULL == pTableName || NULL == pTableMeta) {
     CTG_ERR_RET(TSDB_CODE_CTG_INVALID_INPUT);
   }
 
-  bool inCache = false;
-  int32_t code = 0;
-  uint64_t dbId = 0;
-  uint64_t suid = 0;
+  bool              inCache = false;
+  int32_t           code = 0;
+  uint64_t          dbId = 0;
+  uint64_t          suid = 0;
   STableMetaOutput *output = NULL;
 
   if (CTG_IS_SYS_DBNAME(pTableName->dbname)) {
@@ -2013,7 +1994,8 @@ int32_t ctgGetTableMeta(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, cons
   int32_t tbType = 0;
 
   if (inCache) {
-    if (CTG_FLAG_MATCH_STB(flag, (*pTableMeta)->tableType) && ((!CTG_FLAG_IS_FORCE_UPDATE(flag)) || (CTG_FLAG_IS_SYS_DB(flag)))) {
+    if (CTG_FLAG_MATCH_STB(flag, (*pTableMeta)->tableType) &&
+        ((!CTG_FLAG_IS_FORCE_UPDATE(flag)) || (CTG_FLAG_IS_SYS_DB(flag)))) {
       goto _return;
     }
 
@@ -2027,7 +2009,6 @@ int32_t ctgGetTableMeta(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, cons
     CTG_FLAG_SET_STB(flag, tbType);
   }
 
-
   while (true) {
     CTG_ERR_JRET(ctgRefreshTblMeta(pCtg, pRpc, pMgmtEps, pTableName, flag, &output, false));
 
@@ -2038,7 +2019,7 @@ int32_t ctgGetTableMeta(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, cons
 
     if (CTG_IS_META_BOTH(output->metaType)) {
       memcpy(output->tbMeta, &output->ctbMeta, sizeof(output->ctbMeta));
-      
+
       *pTableMeta = output->tbMeta;
       goto _return;
     }
@@ -2055,11 +2036,11 @@ int32_t ctgGetTableMeta(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, cons
     strcpy(stbName.tname, output->tbName);
 
     taosMemoryFreeClear(output->tbMeta);
-    
+
     CTG_ERR_JRET(ctgGetTableMetaFromCache(pCtg, &stbName, pTableMeta, &inCache, flag, NULL));
     if (!inCache) {
       ctgDebug("stb no longer exist, dbFName:%s, tbName:%s", output->dbFName, pTableName->tname);
-      
+
       continue;
     }
 
@@ -2095,12 +2076,13 @@ _return:
   CTG_RET(code);
 }
 
-int32_t ctgChkAuth(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const char* user, const char* dbFName, AUTH_TYPE type, bool *pass) {
-  bool inCache = false;
+int32_t ctgChkAuth(SCatalog *pCtg, void *pRpc, const SEpSet *pMgmtEps, const char *user, const char *dbFName,
+                   AUTH_TYPE type, bool *pass) {
+  bool    inCache = false;
   int32_t code = 0;
-  
+
   *pass = false;
-  
+
   CTG_ERR_RET(ctgChkAuthFromCache(pCtg, user, dbFName, type, &inCache, pass));
 
   if (inCache) {
@@ -2109,7 +2091,7 @@ int32_t ctgChkAuth(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const cha
 
   SGetUserAuthRsp authRsp = {0};
   CTG_ERR_RET(ctgGetUserDbAuthFromMnode(pCtg, pRpc, pMgmtEps, user, &authRsp));
-  
+
   if (authRsp.superAuth) {
     *pass = true;
     goto _return;
@@ -2135,53 +2117,52 @@ _return:
   return TSDB_CODE_SUCCESS;
 }
 
-
 int32_t ctgActUpdateVg(SCtgMetaAction *action) {
-  int32_t code = 0;
+  int32_t          code = 0;
   SCtgUpdateVgMsg *msg = action->data;
-  
+
   CTG_ERR_JRET(ctgUpdateDBVgInfo(msg->pCtg, msg->dbFName, msg->dbId, &msg->dbInfo));
 
 _return:
 
   ctgFreeVgInfo(msg->dbInfo);
   taosMemoryFreeClear(msg);
-  
+
   CTG_RET(code);
 }
 
 int32_t ctgActRemoveDB(SCtgMetaAction *action) {
-  int32_t code = 0;
+  int32_t          code = 0;
   SCtgRemoveDBMsg *msg = action->data;
-  SCatalog* pCtg = msg->pCtg;
+  SCatalog        *pCtg = msg->pCtg;
 
   SCtgDBCache *dbCache = NULL;
   ctgGetDBCache(msg->pCtg, msg->dbFName, &dbCache);
   if (NULL == dbCache) {
     goto _return;
   }
-  
+
   if (dbCache->dbId != msg->dbId) {
-    ctgInfo("dbId already updated, dbFName:%s, dbId:%"PRIx64 ", targetId:%"PRIx64, msg->dbFName, dbCache->dbId, msg->dbId);
+    ctgInfo("dbId already updated, dbFName:%s, dbId:%" PRIx64 ", targetId:%" PRIx64, msg->dbFName, dbCache->dbId,
+            msg->dbId);
     goto _return;
   }
-  
+
   CTG_ERR_JRET(ctgRemoveDB(pCtg, dbCache, msg->dbFName));
 
 _return:
 
   taosMemoryFreeClear(msg);
-  
+
   CTG_RET(code);
 }
 
-
 int32_t ctgActUpdateTbl(SCtgMetaAction *action) {
-  int32_t code = 0;
+  int32_t           code = 0;
   SCtgUpdateTblMsg *msg = action->data;
-  SCatalog* pCtg = msg->pCtg;
-  STableMetaOutput* output = msg->output;
-  SCtgDBCache *dbCache = NULL;
+  SCatalog         *pCtg = msg->pCtg;
+  STableMetaOutput *output = msg->output;
+  SCtgDBCache      *dbCache = NULL;
 
   if ((!CTG_IS_META_CTABLE(output->metaType)) && NULL == output->tbMeta) {
     ctgError("no valid tbmeta got from meta rsp, dbFName:%s, tbName:%s", output->dbFName, output->tbName);
@@ -2191,22 +2172,24 @@ int32_t ctgActUpdateTbl(SCtgMetaAction *action) {
   if (CTG_IS_META_BOTH(output->metaType) && TSDB_SUPER_TABLE != output->tbMeta->tableType) {
     ctgError("table type error, expected:%d, actual:%d", TSDB_SUPER_TABLE, output->tbMeta->tableType);
     CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR);
-  }    
-  
+  }
+
   CTG_ERR_JRET(ctgGetAddDBCache(pCtg, output->dbFName, output->dbId, &dbCache));
   if (NULL == dbCache) {
-    ctgInfo("conflict db update, ignore this update, dbFName:%s, dbId:%"PRIx64, output->dbFName, output->dbId);
+    ctgInfo("conflict db update, ignore this update, dbFName:%s, dbId:%" PRIx64, output->dbFName, output->dbId);
     CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR);
   }
 
   if (CTG_IS_META_TABLE(output->metaType) || CTG_IS_META_BOTH(output->metaType)) {
     int32_t metaSize = CTG_META_SIZE(output->tbMeta);
-    
-    CTG_ERR_JRET(ctgUpdateTblMeta(pCtg, dbCache, output->dbFName, output->dbId, output->tbName, output->tbMeta, metaSize));
+
+    CTG_ERR_JRET(
+        ctgUpdateTblMeta(pCtg, dbCache, output->dbFName, output->dbId, output->tbName, output->tbMeta, metaSize));
   }
 
   if (CTG_IS_META_CTABLE(output->metaType) || CTG_IS_META_BOTH(output->metaType)) {
-    CTG_ERR_JRET(ctgUpdateTblMeta(pCtg, dbCache, output->dbFName, output->dbId, output->ctbName, (STableMeta *)&output->ctbMeta, sizeof(output->ctbMeta)));
+    CTG_ERR_JRET(ctgUpdateTblMeta(pCtg, dbCache, output->dbFName, output->dbId, output->ctbName,
+                                  (STableMeta *)&output->ctbMeta, sizeof(output->ctbMeta)));
   }
 
 _return:
@@ -2215,17 +2198,16 @@ _return:
     taosMemoryFreeClear(output->tbMeta);
     taosMemoryFreeClear(output);
   }
-  
+
   taosMemoryFreeClear(msg);
-  
+
   CTG_RET(code);
 }
 
-
 int32_t ctgActRemoveStb(SCtgMetaAction *action) {
-  int32_t code = 0;
+  int32_t           code = 0;
   SCtgRemoveStbMsg *msg = action->data;
-  SCatalog* pCtg = msg->pCtg;
+  SCatalog         *pCtg = msg->pCtg;
 
   SCtgDBCache *dbCache = NULL;
   ctgGetDBCache(pCtg, msg->dbFName, &dbCache);
@@ -2234,44 +2216,46 @@ int32_t ctgActRemoveStb(SCtgMetaAction *action) {
   }
 
   if (msg->dbId && (dbCache->dbId != msg->dbId)) {
-    ctgDebug("dbId already modified, dbFName:%s, current:%"PRIx64", dbId:%"PRIx64", stb:%s, suid:%"PRIx64, msg->dbFName, dbCache->dbId, msg->dbId, msg->stbName, msg->suid);
+    ctgDebug("dbId already modified, dbFName:%s, current:%" PRIx64 ", dbId:%" PRIx64 ", stb:%s, suid:%" PRIx64,
+             msg->dbFName, dbCache->dbId, msg->dbId, msg->stbName, msg->suid);
     return TSDB_CODE_SUCCESS;
   }
-  
+
   CTG_LOCK(CTG_WRITE, &dbCache->tbCache.stbLock);
   if (taosHashRemove(dbCache->tbCache.stbCache, &msg->suid, sizeof(msg->suid))) {
-    ctgDebug("stb not exist in stbCache, may be removed, dbFName:%s, stb:%s, suid:%"PRIx64, msg->dbFName, msg->stbName, msg->suid);
+    ctgDebug("stb not exist in stbCache, may be removed, dbFName:%s, stb:%s, suid:%" PRIx64, msg->dbFName, msg->stbName,
+             msg->suid);
   } else {
     CTG_CACHE_STAT_SUB(stblNum, 1);
   }
 
   CTG_LOCK(CTG_READ, &dbCache->tbCache.metaLock);
-  if (taosHashRemove(dbCache->tbCache.metaCache, msg->stbName, strlen(msg->stbName))) {  
-    ctgError("stb not exist in cache, dbFName:%s, stb:%s, suid:%"PRIx64, msg->dbFName, msg->stbName, msg->suid);
+  if (taosHashRemove(dbCache->tbCache.metaCache, msg->stbName, strlen(msg->stbName))) {
+    ctgError("stb not exist in cache, dbFName:%s, stb:%s, suid:%" PRIx64, msg->dbFName, msg->stbName, msg->suid);
   } else {
     CTG_CACHE_STAT_SUB(tblNum, 1);
   }
   CTG_UNLOCK(CTG_READ, &dbCache->tbCache.metaLock);
-  
+
   CTG_UNLOCK(CTG_WRITE, &dbCache->tbCache.stbLock);
-  
-  ctgInfo("stb removed from cache, dbFName:%s, stbName:%s, suid:%"PRIx64, msg->dbFName, msg->stbName, msg->suid);
+
+  ctgInfo("stb removed from cache, dbFName:%s, stbName:%s, suid:%" PRIx64, msg->dbFName, msg->stbName, msg->suid);
 
   CTG_ERR_JRET(ctgMetaRentRemove(&msg->pCtg->stbRent, msg->suid, ctgStbVersionSortCompare, ctgStbVersionSearchCompare));
-  
-  ctgDebug("stb removed from rent, dbFName:%s, stbName:%s, suid:%"PRIx64, msg->dbFName, msg->stbName, msg->suid);
-  
+
+  ctgDebug("stb removed from rent, dbFName:%s, stbName:%s, suid:%" PRIx64, msg->dbFName, msg->stbName, msg->suid);
+
 _return:
 
   taosMemoryFreeClear(msg);
-  
+
   CTG_RET(code);
 }
 
 int32_t ctgActRemoveTbl(SCtgMetaAction *action) {
-  int32_t code = 0;
+  int32_t           code = 0;
   SCtgRemoveTblMsg *msg = action->data;
-  SCatalog* pCtg = msg->pCtg;
+  SCatalog         *pCtg = msg->pCtg;
 
   SCtgDBCache *dbCache = NULL;
   ctgGetDBCache(pCtg, msg->dbFName, &dbCache);
@@ -2280,7 +2264,8 @@ int32_t ctgActRemoveTbl(SCtgMetaAction *action) {
   }
 
   if (dbCache->dbId != msg->dbId) {
-    ctgDebug("dbId already modified, dbFName:%s, current:%"PRIx64", dbId:%"PRIx64", tbName:%s", msg->dbFName, dbCache->dbId, msg->dbId, msg->tbName);
+    ctgDebug("dbId already modified, dbFName:%s, current:%" PRIx64 ", dbId:%" PRIx64 ", tbName:%s", msg->dbFName,
+             dbCache->dbId, msg->dbId, msg->tbName);
     return TSDB_CODE_SUCCESS;
   }
 
@@ -2304,18 +2289,19 @@ _return:
 }
 
 int32_t ctgActUpdateUser(SCtgMetaAction *action) {
-  int32_t code = 0;
+  int32_t            code = 0;
   SCtgUpdateUserMsg *msg = action->data;
-  SCatalog* pCtg = msg->pCtg;
+  SCatalog          *pCtg = msg->pCtg;
 
   if (NULL == pCtg->userCache) {
-    pCtg->userCache = taosHashInit(gCtgMgmt.cfg.maxUserCacheNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_ENTRY_LOCK);
+    pCtg->userCache = taosHashInit(gCtgMgmt.cfg.maxUserCacheNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY),
+                                   false, HASH_ENTRY_LOCK);
     if (NULL == pCtg->userCache) {
       ctgError("taosHashInit %d user cache failed", gCtgMgmt.cfg.maxUserCacheNum);
       CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY);
     }
   }
-  
+
   SCtgUserAuth *pUser = (SCtgUserAuth *)taosHashGet(pCtg->userCache, msg->userAuth.user, strlen(msg->userAuth.user));
   if (NULL == pUser) {
     SCtgUserAuth userAuth = {0};
@@ -2326,7 +2312,7 @@ int32_t ctgActUpdateUser(SCtgMetaAction *action) {
     userAuth.readDbs = msg->userAuth.readDbs;
     userAuth.writeDbs = msg->userAuth.writeDbs;
 
-    if (taosHashPut(pCtg->userCache, msg->userAuth.user, strlen(msg->userAuth.user), &userAuth, sizeof(userAuth))) {
+    if (taosHashPut(pCtg->userCache, msg->userAuth.user, sizeof(msg->userAuth.user), &userAuth, sizeof(userAuth))) {
       ctgError("taosHashPut user %s to cache failed", msg->userAuth.user);
       CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY);
     }
@@ -2356,30 +2342,28 @@ int32_t ctgActUpdateUser(SCtgMetaAction *action) {
 
 _return:
 
-
   taosHashCleanup(msg->userAuth.createdDbs);
   taosHashCleanup(msg->userAuth.readDbs);
   taosHashCleanup(msg->userAuth.writeDbs);
- 
+
   taosMemoryFreeClear(msg);
-  
+
   CTG_RET(code);
 }
 
-
-void* ctgUpdateThreadFunc(void* param) {
+void *ctgUpdateThreadFunc(void *param) {
   setThreadName("catalog");
 
   qInfo("catalog update thread started");
 
   CTG_LOCK(CTG_READ, &gCtgMgmt.lock);
-  
+
   while (true) {
     if (tsem_wait(&gCtgMgmt.queue.reqSem)) {
       qError("ctg tsem_wait failed, error:%s", tstrerror(TAOS_SYSTEM_ERROR(errno)));
     }
-    
-    if (atomic_load_8((int8_t*)&gCtgMgmt.exit)) {
+
+    if (atomic_load_8((int8_t *)&gCtgMgmt.exit)) {
       tsem_post(&gCtgMgmt.queue.rspSem);
       break;
     }
@@ -2389,7 +2373,7 @@ void* ctgUpdateThreadFunc(void* param) {
     SCatalog *pCtg = ((SCtgUpdateMsgHeader *)action->data)->pCtg;
 
     ctgDebug("process [%s] action", gCtgAction[action->act].name);
-    
+
     (*gCtgAction[action->act].func)(action);
 
     gCtgMgmt.queue.seqDone = action->seqId;
@@ -2398,7 +2382,7 @@ void* ctgUpdateThreadFunc(void* param) {
       tsem_post(&gCtgMgmt.queue.rspSem);
     }
 
-    CTG_RUNTIME_STAT_ADD(qDoneNum, 1); 
+    CTG_RUNTIME_STAT_ADD(qDoneNum, 1);
 
     ctgdShowClusterCache(pCtg);
   }
@@ -2406,11 +2390,10 @@ void* ctgUpdateThreadFunc(void* param) {
   CTG_UNLOCK(CTG_READ, &gCtgMgmt.lock);
 
   qInfo("catalog update thread stopped");
-  
+
   return NULL;
 }
 
-
 int32_t ctgStartUpdateThread() {
   TdThreadAttr thAttr;
   taosThreadAttrInit(&thAttr);
@@ -2420,27 +2403,28 @@ int32_t ctgStartUpdateThread() {
     terrno = TAOS_SYSTEM_ERROR(errno);
     CTG_ERR_RET(terrno);
   }
-  
+
   taosThreadAttrDestroy(&thAttr);
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t ctgGetTableDistVgInfo(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const SName* pTableName, SArray** pVgList) {
-  STableMeta *tbMeta = NULL;
-  int32_t code = 0;
-  SVgroupInfo vgroupInfo = {0};
-  SCtgDBCache* dbCache = NULL;
-  SArray *vgList = NULL;
-  SDBVgInfo *vgInfo = NULL;
+int32_t ctgGetTableDistVgInfo(SCatalog *pCtg, void *pRpc, const SEpSet *pMgmtEps, const SName *pTableName,
+                              SArray **pVgList) {
+  STableMeta  *tbMeta = NULL;
+  int32_t      code = 0;
+  SVgroupInfo  vgroupInfo = {0};
+  SCtgDBCache *dbCache = NULL;
+  SArray      *vgList = NULL;
+  SDBVgInfo   *vgInfo = NULL;
 
   *pVgList = NULL;
-  
+
   CTG_ERR_JRET(ctgGetTableMeta(pCtg, pRpc, pMgmtEps, pTableName, &tbMeta, CTG_FLAG_UNKNOWN_STB));
 
   char db[TSDB_DB_FNAME_LEN] = {0};
   tNameGetFullDbName(pTableName, db);
 
-  SHashObj *vgHash = NULL;  
+  SHashObj *vgHash = NULL;
   CTG_ERR_JRET(ctgGetDBVgInfo(pCtg, pRpc, pMgmtEps, db, &dbCache, &vgInfo));
 
   if (dbCache) {
@@ -2455,7 +2439,7 @@ int32_t ctgGetTableDistVgInfo(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps
     // USE HASH METHOD INSTEAD OF VGID IN TBMETA
     ctgError("invalid method to get none stb vgInfo, tbType:%d", tbMeta->tableType);
     CTG_ERR_JRET(TSDB_CODE_CTG_INVALID_INPUT);
-    
+
 #if 0  
     int32_t vgId = tbMeta->vgId;
     if (taosHashGetDup(vgHash, &vgId, sizeof(vgId), &vgroupInfo) != 0) {
@@ -2476,7 +2460,7 @@ int32_t ctgGetTableDistVgInfo(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps
 
     *pVgList = vgList;
     vgList = NULL;
-#endif    
+#endif
   }
 
 _return:
@@ -2507,7 +2491,7 @@ int32_t catalogInit(SCatalogCfg *cfg) {
     CTG_ERR_RET(TSDB_CODE_CTG_INVALID_INPUT);
   }
 
-  atomic_store_8((int8_t*)&gCtgMgmt.exit, false);
+  atomic_store_8((int8_t *)&gCtgMgmt.exit, false);
 
   if (cfg) {
     memcpy(&gCtgMgmt.cfg, cfg, sizeof(*cfg));
@@ -2534,7 +2518,8 @@ int32_t catalogInit(SCatalogCfg *cfg) {
     gCtgMgmt.cfg.stbRentSec = CTG_DEFAULT_RENT_SECOND;
   }
 
-  gCtgMgmt.pCluster = taosHashInit(CTG_DEFAULT_CACHE_CLUSTER_NUMBER, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK);
+  gCtgMgmt.pCluster = taosHashInit(CTG_DEFAULT_CACHE_CLUSTER_NUMBER, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT),
+                                   false, HASH_ENTRY_LOCK);
   if (NULL == gCtgMgmt.pCluster) {
     qError("taosHashInit %d cluster cache failed", CTG_DEFAULT_CACHE_CLUSTER_NUMBER);
     CTG_ERR_RET(TSDB_CODE_CTG_INTERNAL_ERROR);
@@ -2544,7 +2529,7 @@ int32_t catalogInit(SCatalogCfg *cfg) {
     qError("tsem_init failed, error:%s", tstrerror(TAOS_SYSTEM_ERROR(errno)));
     CTG_ERR_RET(TSDB_CODE_CTG_SYS_ERROR);
   }
-  
+
   if (tsem_init(&gCtgMgmt.queue.rspSem, 0, 0)) {
     qError("tsem_init failed, error:%s", tstrerror(TAOS_SYSTEM_ERROR(errno)));
     CTG_ERR_RET(TSDB_CODE_CTG_SYS_ERROR);
@@ -2559,30 +2544,31 @@ int32_t catalogInit(SCatalogCfg *cfg) {
 
   CTG_ERR_RET(ctgStartUpdateThread());
 
-  qDebug("catalog initialized, maxDb:%u, maxTbl:%u, dbRentSec:%u, stbRentSec:%u", gCtgMgmt.cfg.maxDBCacheNum, gCtgMgmt.cfg.maxTblCacheNum, gCtgMgmt.cfg.dbRentSec, gCtgMgmt.cfg.stbRentSec);
+  qDebug("catalog initialized, maxDb:%u, maxTbl:%u, dbRentSec:%u, stbRentSec:%u", gCtgMgmt.cfg.maxDBCacheNum,
+         gCtgMgmt.cfg.maxTblCacheNum, gCtgMgmt.cfg.dbRentSec, gCtgMgmt.cfg.stbRentSec);
 
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t catalogGetHandle(uint64_t clusterId, SCatalog** catalogHandle) {
+int32_t catalogGetHandle(uint64_t clusterId, SCatalog **catalogHandle) {
   if (NULL == catalogHandle) {
     CTG_ERR_RET(TSDB_CODE_CTG_INVALID_INPUT);
   }
 
   if (NULL == gCtgMgmt.pCluster) {
-    qError("catalog cluster cache are not ready, clusterId:%"PRIx64, clusterId);
+    qError("catalog cluster cache are not ready, clusterId:%" PRIx64, clusterId);
     CTG_ERR_RET(TSDB_CODE_CTG_NOT_READY);
   }
 
-  int32_t code = 0;
+  int32_t   code = 0;
   SCatalog *clusterCtg = NULL;
 
   while (true) {
-    SCatalog **ctg = (SCatalog **)taosHashGet(gCtgMgmt.pCluster, (char*)&clusterId, sizeof(clusterId));
+    SCatalog **ctg = (SCatalog **)taosHashGet(gCtgMgmt.pCluster, (char *)&clusterId, sizeof(clusterId));
 
     if (ctg && (*ctg)) {
       *catalogHandle = *ctg;
-      qDebug("got catalog handle from cache, clusterId:%"PRIx64", CTG:%p", clusterId, *ctg);
+      qDebug("got catalog handle from cache, clusterId:%" PRIx64 ", CTG:%p", clusterId, *ctg);
       return TSDB_CODE_SUCCESS;
     }
 
@@ -2597,7 +2583,8 @@ int32_t catalogGetHandle(uint64_t clusterId, SCatalog** catalogHandle) {
     CTG_ERR_JRET(ctgMetaRentInit(&clusterCtg->dbRent, gCtgMgmt.cfg.dbRentSec, CTG_RENT_DB));
     CTG_ERR_JRET(ctgMetaRentInit(&clusterCtg->stbRent, gCtgMgmt.cfg.stbRentSec, CTG_RENT_STABLE));
 
-    clusterCtg->dbCache = taosHashInit(gCtgMgmt.cfg.maxDBCacheNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_ENTRY_LOCK);
+    clusterCtg->dbCache = taosHashInit(gCtgMgmt.cfg.maxDBCacheNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY),
+                                       false, HASH_ENTRY_LOCK);
     if (NULL == clusterCtg->dbCache) {
       qError("taosHashInit %d dbCache failed", CTG_DEFAULT_CACHE_DB_NUMBER);
       CTG_ERR_JRET(TSDB_CODE_CTG_MEM_ERROR);
@@ -2609,12 +2596,12 @@ int32_t catalogGetHandle(uint64_t clusterId, SCatalog** catalogHandle) {
         ctgFreeHandle(clusterCtg);
         continue;
       }
-      
-      qError("taosHashPut CTG to cache failed, clusterId:%"PRIx64, clusterId);
+
+      qError("taosHashPut CTG to cache failed, clusterId:%" PRIx64, clusterId);
       CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR);
     }
 
-    qDebug("add CTG to cache, clusterId:%"PRIx64", CTG:%p", clusterId, clusterCtg);
+    qDebug("add CTG to cache, clusterId:%" PRIx64 ", CTG:%p", clusterId, clusterCtg);
 
     break;
   }
@@ -2622,36 +2609,36 @@ int32_t catalogGetHandle(uint64_t clusterId, SCatalog** catalogHandle) {
   *catalogHandle = clusterCtg;
 
   CTG_CACHE_STAT_ADD(clusterNum, 1);
-  
+
   return TSDB_CODE_SUCCESS;
 
 _return:
 
   ctgFreeHandle(clusterCtg);
-  
+
   CTG_RET(code);
 }
 
-void catalogFreeHandle(SCatalog* pCtg) {
+void catalogFreeHandle(SCatalog *pCtg) {
   if (NULL == pCtg) {
     return;
   }
 
   if (taosHashRemove(gCtgMgmt.pCluster, &pCtg->clusterId, sizeof(pCtg->clusterId))) {
-    ctgWarn("taosHashRemove from cluster failed, may already be freed, clusterId:%"PRIx64, pCtg->clusterId);
+    ctgWarn("taosHashRemove from cluster failed, may already be freed, clusterId:%" PRIx64, pCtg->clusterId);
     return;
   }
 
   CTG_CACHE_STAT_SUB(clusterNum, 1);
 
   uint64_t clusterId = pCtg->clusterId;
-  
+
   ctgFreeHandle(pCtg);
-  
-  ctgInfo("handle freed, culsterId:%"PRIx64, clusterId);
+
+  ctgInfo("handle freed, culsterId:%" PRIx64, clusterId);
 }
 
-int32_t catalogGetDBVgVersion(SCatalog* pCtg, const char* dbFName, int32_t* version, int64_t* dbId, int32_t *tableNum) {
+int32_t catalogGetDBVgVersion(SCatalog *pCtg, const char *dbFName, int32_t *version, int64_t *dbId, int32_t *tableNum) {
   CTG_API_ENTER();
 
   if (NULL == pCtg || NULL == dbFName || NULL == version || NULL == dbId) {
@@ -2659,8 +2646,8 @@ int32_t catalogGetDBVgVersion(SCatalog* pCtg, const char* dbFName, int32_t* vers
   }
 
   SCtgDBCache *dbCache = NULL;
-  bool inCache = false;
-  int32_t code = 0;
+  bool         inCache = false;
+  int32_t      code = 0;
 
   CTG_ERR_JRET(ctgAcquireVgInfoFromCache(pCtg, dbFName, &dbCache, &inCache));
   if (!inCache) {
@@ -2684,18 +2671,19 @@ _return:
   CTG_API_LEAVE(code);
 }
 
-int32_t catalogGetDBVgInfo(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const char* dbFName, SArray** vgroupList) {
+int32_t catalogGetDBVgInfo(SCatalog *pCtg, void *pRpc, const SEpSet *pMgmtEps, const char *dbFName,
+                           SArray **vgroupList) {
   CTG_API_ENTER();
 
   if (NULL == pCtg || NULL == dbFName || NULL == pRpc || NULL == pMgmtEps || NULL == vgroupList) {
     CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
   }
 
-  SCtgDBCache* dbCache = NULL;
-  int32_t code = 0;
-  SArray *vgList = NULL;
-  SHashObj *vgHash = NULL;
-  SDBVgInfo *vgInfo = NULL;
+  SCtgDBCache *dbCache = NULL;
+  int32_t      code = 0;
+  SArray      *vgList = NULL;
+  SHashObj    *vgHash = NULL;
+  SDBVgInfo   *vgInfo = NULL;
   CTG_ERR_JRET(ctgGetDBVgInfo(pCtg, pRpc, pMgmtEps, dbFName, &dbCache, &vgInfo));
   if (dbCache) {
     vgHash = dbCache->vgInfo->vgHash;
@@ -2720,15 +2708,14 @@ _return:
     taosMemoryFreeClear(vgInfo);
   }
 
-  CTG_API_LEAVE(code);  
+  CTG_API_LEAVE(code);
 }
 
-
-int32_t catalogUpdateDBVgInfo(SCatalog* pCtg, const char* dbFName, uint64_t dbId, SDBVgInfo* dbInfo) {
+int32_t catalogUpdateDBVgInfo(SCatalog *pCtg, const char *dbFName, uint64_t dbId, SDBVgInfo *dbInfo) {
   CTG_API_ENTER();
 
   int32_t code = 0;
-  
+
   if (NULL == pCtg || NULL == dbFName || NULL == dbInfo) {
     ctgFreeVgInfo(dbInfo);
     CTG_ERR_JRET(TSDB_CODE_CTG_INVALID_INPUT);
@@ -2741,12 +2728,11 @@ _return:
   CTG_API_LEAVE(code);
 }
 
-
-int32_t catalogRemoveDB(SCatalog* pCtg, const char* dbFName, uint64_t dbId) {
+int32_t catalogRemoveDB(SCatalog *pCtg, const char *dbFName, uint64_t dbId) {
   CTG_API_ENTER();
 
   int32_t code = 0;
-  
+
   if (NULL == pCtg || NULL == dbFName) {
     CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
   }
@@ -2758,21 +2744,19 @@ int32_t catalogRemoveDB(SCatalog* pCtg, const char* dbFName, uint64_t dbId) {
   CTG_ERR_JRET(ctgPushRmDBMsgInQueue(pCtg, dbFName, dbId));
 
   CTG_API_LEAVE(TSDB_CODE_SUCCESS);
-  
+
 _return:
 
   CTG_API_LEAVE(code);
 }
 
-int32_t catalogUpdateVgEpSet(SCatalog* pCtg, const char* dbFName, int32_t vgId, SEpSet *epSet) {
-  return 0;
-}
+int32_t catalogUpdateVgEpSet(SCatalog *pCtg, const char *dbFName, int32_t vgId, SEpSet *epSet) { return 0; }
 
-int32_t catalogRemoveTableMeta(SCatalog* pCtg, const SName* pTableName) {
+int32_t catalogRemoveTableMeta(SCatalog *pCtg, const SName *pTableName) {
   CTG_API_ENTER();
 
   int32_t code = 0;
-  
+
   if (NULL == pCtg || NULL == pTableName) {
     CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
   }
@@ -2782,8 +2766,8 @@ int32_t catalogRemoveTableMeta(SCatalog* pCtg, const SName* pTableName) {
   }
 
   STableMeta *tblMeta = NULL;
-  bool inCache = false;
-  uint64_t dbId = 0;
+  bool        inCache = false;
+  uint64_t    dbId = 0;
   CTG_ERR_JRET(ctgGetTableMetaFromCache(pCtg, pTableName, &tblMeta, &inCache, 0, &dbId));
 
   if (!inCache) {
@@ -2793,14 +2777,13 @@ int32_t catalogRemoveTableMeta(SCatalog* pCtg, const SName* pTableName) {
 
   char dbFName[TSDB_DB_FNAME_LEN];
   tNameGetFullDbName(pTableName, dbFName);
-  
+
   if (TSDB_SUPER_TABLE == tblMeta->tableType) {
     CTG_ERR_JRET(ctgPushRmStbMsgInQueue(pCtg, dbFName, dbId, pTableName->tname, tblMeta->suid, true));
   } else {
     CTG_ERR_JRET(ctgPushRmTblMsgInQueue(pCtg, dbFName, dbId, pTableName->tname, true));
   }
 
- 
 _return:
 
   taosMemoryFreeClear(tblMeta);
@@ -2808,12 +2791,11 @@ _return:
   CTG_API_LEAVE(code);
 }
 
-
-int32_t catalogRemoveStbMeta(SCatalog* pCtg, const char* dbFName, uint64_t dbId, const char* stbName, uint64_t suid) {
+int32_t catalogRemoveStbMeta(SCatalog *pCtg, const char *dbFName, uint64_t dbId, const char *stbName, uint64_t suid) {
   CTG_API_ENTER();
 
   int32_t code = 0;
-  
+
   if (NULL == pCtg || NULL == dbFName || NULL == stbName) {
     CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
   }
@@ -2825,29 +2807,32 @@ int32_t catalogRemoveStbMeta(SCatalog* pCtg, const char* dbFName, uint64_t dbId,
   CTG_ERR_JRET(ctgPushRmStbMsgInQueue(pCtg, dbFName, dbId, stbName, suid, true));
 
   CTG_API_LEAVE(TSDB_CODE_SUCCESS);
-  
+
 _return:
 
   CTG_API_LEAVE(code);
 }
 
-int32_t catalogGetIndexMeta(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps, const SName* pTableName, const char *pIndexName, SIndexMeta** pIndexMeta) {
+int32_t catalogGetIndexMeta(SCatalog *pCtg, void *pTrans, const SEpSet *pMgmtEps, const SName *pTableName,
+                            const char *pIndexName, SIndexMeta **pIndexMeta) {
   return 0;
 }
 
-int32_t catalogGetTableMeta(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps, const SName* pTableName, STableMeta** pTableMeta) {
+int32_t catalogGetTableMeta(SCatalog *pCtg, void *pTrans, const SEpSet *pMgmtEps, const SName *pTableName,
+                            STableMeta **pTableMeta) {
   CTG_API_ENTER();
 
   CTG_API_LEAVE(ctgGetTableMeta(pCtg, pTrans, pMgmtEps, pTableName, pTableMeta, CTG_FLAG_UNKNOWN_STB));
 }
 
-int32_t catalogGetSTableMeta(SCatalog* pCtg, void * pTrans, const SEpSet* pMgmtEps, const SName* pTableName, STableMeta** pTableMeta) {
+int32_t catalogGetSTableMeta(SCatalog *pCtg, void *pTrans, const SEpSet *pMgmtEps, const SName *pTableName,
+                             STableMeta **pTableMeta) {
   CTG_API_ENTER();
 
   CTG_API_LEAVE(ctgGetTableMeta(pCtg, pTrans, pMgmtEps, pTableName, pTableMeta, CTG_FLAG_STB));
 }
 
-int32_t catalogUpdateSTableMeta(SCatalog* pCtg, STableMetaRsp *rspMsg) {
+int32_t catalogUpdateSTableMeta(SCatalog *pCtg, STableMetaRsp *rspMsg) {
   CTG_API_ENTER();
 
   if (NULL == pCtg || NULL == rspMsg) {
@@ -2859,42 +2844,41 @@ int32_t catalogUpdateSTableMeta(SCatalog* pCtg, STableMetaRsp *rspMsg) {
     ctgError("malloc %d failed", (int32_t)sizeof(STableMetaOutput));
     CTG_API_LEAVE(TSDB_CODE_CTG_MEM_ERROR);
   }
-  
+
   int32_t code = 0;
 
   strcpy(output->dbFName, rspMsg->dbFName);
   strcpy(output->tbName, rspMsg->tbName);
 
   output->dbId = rspMsg->dbId;
-  
+
   SET_META_TYPE_TABLE(output->metaType);
-  
+
   CTG_ERR_JRET(queryCreateTableMetaFromMsg(rspMsg, true, &output->tbMeta));
 
   CTG_ERR_JRET(ctgPushUpdateTblMsgInQueue(pCtg, output, false));
 
   CTG_API_LEAVE(code);
-  
+
 _return:
 
   taosMemoryFreeClear(output->tbMeta);
   taosMemoryFreeClear(output);
-  
+
   CTG_API_LEAVE(code);
 }
 
-
-
-int32_t ctgGetTbSverFromCache(SCatalog* pCtg, const SName* pTableName, int32_t* sver, int32_t *tbType, uint64_t *suid, char* stbName) {
+int32_t ctgGetTbSverFromCache(SCatalog *pCtg, const SName *pTableName, int32_t *sver, int32_t *tbType, uint64_t *suid,
+                              char *stbName) {
   *sver = -1;
-  
+
   if (NULL == pCtg->dbCache) {
     ctgDebug("empty tbmeta cache, tbName:%s", pTableName->tname);
     return TSDB_CODE_SUCCESS;
   }
 
   SCtgDBCache *dbCache = NULL;
-  char dbFName[TSDB_DB_FNAME_LEN] = {0};
+  char         dbFName[TSDB_DB_FNAME_LEN] = {0};
   tNameGetFullDbName(pTableName, dbFName);
 
   ctgAcquireDBCache(pCtg, dbFName, &dbCache);
@@ -2902,9 +2886,9 @@ int32_t ctgGetTbSverFromCache(SCatalog* pCtg, const SName* pTableName, int32_t*
     ctgDebug("db %s not in cache", pTableName->tname);
     return TSDB_CODE_SUCCESS;
   }
-  
+
   CTG_LOCK(CTG_READ, &dbCache->tbCache.metaLock);
-  STableMeta* tbMeta = taosHashGet(dbCache->tbCache.metaCache, pTableName->tname, strlen(pTableName->tname));
+  STableMeta *tbMeta = taosHashGet(dbCache->tbCache.metaCache, pTableName->tname, strlen(pTableName->tname));
   if (tbMeta) {
     *tbType = tbMeta->tableType;
     *suid = tbMeta->suid;
@@ -2922,32 +2906,33 @@ int32_t ctgGetTbSverFromCache(SCatalog* pCtg, const SName* pTableName, int32_t*
   if (*tbType != TSDB_CHILD_TABLE) {
     ctgReleaseDBCache(pCtg, dbCache);
     ctgDebug("Got sver %d from cache, type:%d, dbFName:%s, tbName:%s", *sver, *tbType, dbFName, pTableName->tname);
-    
+
     return TSDB_CODE_SUCCESS;
   }
 
   ctgDebug("Got subtable meta from cache, dbFName:%s, tbName:%s, suid:%" PRIx64, dbFName, pTableName->tname, *suid);
-  
+
   CTG_LOCK(CTG_READ, &dbCache->tbCache.stbLock);
-  
+
   STableMeta **stbMeta = taosHashGet(dbCache->tbCache.stbCache, suid, sizeof(*suid));
   if (NULL == stbMeta || NULL == *stbMeta) {
     CTG_UNLOCK(CTG_READ, &dbCache->tbCache.stbLock);
     ctgReleaseDBCache(pCtg, dbCache);
-    ctgDebug("stb not in stbCache, suid:%"PRIx64, *suid);
+    ctgDebug("stb not in stbCache, suid:%" PRIx64, *suid);
     return TSDB_CODE_SUCCESS;
   }
 
   if ((*stbMeta)->suid != *suid) {
     CTG_UNLOCK(CTG_READ, &dbCache->tbCache.stbLock);
     ctgReleaseDBCache(pCtg, dbCache);
-    ctgError("stable suid in stbCache mis-match, expected suid:%"PRIx64 ",actual suid:%"PRIx64, *suid, (*stbMeta)->suid);
+    ctgError("stable suid in stbCache mis-match, expected suid:%" PRIx64 ",actual suid:%" PRIx64, *suid,
+             (*stbMeta)->suid);
     CTG_ERR_RET(TSDB_CODE_CTG_INTERNAL_ERROR);
   }
 
   size_t nameLen = 0;
-  char* name = taosHashGetKey(*stbMeta, &nameLen);
-  
+  char  *name = taosHashGetKey(*stbMeta, &nameLen);
+
   strncpy(stbName, name, nameLen);
   stbName[nameLen] = 0;
 
@@ -2958,38 +2943,38 @@ int32_t ctgGetTbSverFromCache(SCatalog* pCtg, const SName* pTableName, int32_t*
   ctgReleaseDBCache(pCtg, dbCache);
 
   ctgDebug("Got sver %d from cache, type:%d, dbFName:%s, tbName:%s", *sver, *tbType, dbFName, pTableName->tname);
-  
+
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t catalogChkTbMetaVersion(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps, SArray* pTables) {
+int32_t catalogChkTbMetaVersion(SCatalog *pCtg, void *pTrans, const SEpSet *pMgmtEps, SArray *pTables) {
   CTG_API_ENTER();
 
   if (NULL == pCtg || NULL == pTrans || NULL == pMgmtEps || NULL == pTables) {
     CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
   }
 
-  SName name;
+  SName   name;
   int32_t sver = 0;
   int32_t tbNum = taosArrayGetSize(pTables);
   for (int32_t i = 0; i < tbNum; ++i) {
-    STbSVersion* pTb = (STbSVersion*)taosArrayGet(pTables, i);
+    STbSVersion *pTb = (STbSVersion *)taosArrayGet(pTables, i);
     tNameFromString(&name, pTb->tbFName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
-    
+
     if (CTG_IS_SYS_DBNAME(name.dbname)) {
       continue;
     }
 
-    int32_t tbType = 0;
+    int32_t  tbType = 0;
     uint64_t suid = 0;
-    char stbName[TSDB_TABLE_FNAME_LEN];
+    char     stbName[TSDB_TABLE_FNAME_LEN];
     ctgGetTbSverFromCache(pCtg, &name, &sver, &tbType, &suid, stbName);
     if (sver >= 0 && sver < pTb->sver) {
       switch (tbType) {
         case TSDB_CHILD_TABLE: {
           SName stb = name;
           strcpy(stb.tname, stbName);
-          catalogRemoveTableMeta(pCtg, &stb);        
+          catalogRemoveTableMeta(pCtg, &stb);
           break;
         }
         case TSDB_SUPER_TABLE:
@@ -3006,8 +2991,7 @@ int32_t catalogChkTbMetaVersion(SCatalog* pCtg, void *pTrans, const SEpSet* pMgm
   CTG_API_LEAVE(TSDB_CODE_SUCCESS);
 }
 
-
-int32_t catalogRefreshDBVgInfo(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps, const char* dbFName) {
+int32_t catalogRefreshDBVgInfo(SCatalog *pCtg, void *pTrans, const SEpSet *pMgmtEps, const char *dbFName) {
   CTG_API_ENTER();
 
   if (NULL == pCtg || NULL == pTrans || NULL == pMgmtEps || NULL == dbFName) {
@@ -3017,23 +3001,28 @@ int32_t catalogRefreshDBVgInfo(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmt
   CTG_API_LEAVE(ctgRefreshDBVgInfo(pCtg, pTrans, pMgmtEps, dbFName));
 }
 
-int32_t catalogRefreshTableMeta(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps, const SName* pTableName, int32_t isSTable) {
+int32_t catalogRefreshTableMeta(SCatalog *pCtg, void *pTrans, const SEpSet *pMgmtEps, const SName *pTableName,
+                                int32_t isSTable) {
   CTG_API_ENTER();
 
   if (NULL == pCtg || NULL == pTrans || NULL == pMgmtEps || NULL == pTableName) {
     CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
   }
 
-  CTG_API_LEAVE(ctgRefreshTblMeta(pCtg, pTrans, pMgmtEps, pTableName, CTG_FLAG_FORCE_UPDATE | CTG_FLAG_MAKE_STB(isSTable), NULL, true));
+  CTG_API_LEAVE(ctgRefreshTblMeta(pCtg, pTrans, pMgmtEps, pTableName,
+                                  CTG_FLAG_FORCE_UPDATE | CTG_FLAG_MAKE_STB(isSTable), NULL, true));
 }
 
-int32_t catalogRefreshGetTableMeta(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps, const SName* pTableName, STableMeta** pTableMeta, int32_t isSTable) {
+int32_t catalogRefreshGetTableMeta(SCatalog *pCtg, void *pTrans, const SEpSet *pMgmtEps, const SName *pTableName,
+                                   STableMeta **pTableMeta, int32_t isSTable) {
   CTG_API_ENTER();
 
-  CTG_API_LEAVE(ctgGetTableMeta(pCtg, pTrans, pMgmtEps, pTableName, pTableMeta, CTG_FLAG_FORCE_UPDATE | CTG_FLAG_MAKE_STB(isSTable)));
+  CTG_API_LEAVE(ctgGetTableMeta(pCtg, pTrans, pMgmtEps, pTableName, pTableMeta,
+                                CTG_FLAG_FORCE_UPDATE | CTG_FLAG_MAKE_STB(isSTable)));
 }
 
-int32_t catalogGetTableDistVgInfo(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const SName* pTableName, SArray** pVgList) {
+int32_t catalogGetTableDistVgInfo(SCatalog *pCtg, void *pRpc, const SEpSet *pMgmtEps, const SName *pTableName,
+                                  SArray **pVgList) {
   CTG_API_ENTER();
 
   if (NULL == pCtg || NULL == pRpc || NULL == pMgmtEps || NULL == pTableName || NULL == pVgList) {
@@ -3051,12 +3040,13 @@ int32_t catalogGetTableDistVgInfo(SCatalog* pCtg, void *pRpc, const SEpSet* pMgm
     code = ctgGetTableDistVgInfo(pCtg, pRpc, pMgmtEps, pTableName, pVgList);
     if (code) {
       if (TSDB_CODE_CTG_VG_META_MISMATCH == code) {
-        CTG_ERR_JRET(ctgRefreshTblMeta(pCtg, pRpc, pMgmtEps, pTableName, CTG_FLAG_FORCE_UPDATE | CTG_FLAG_MAKE_STB(CTG_FLAG_UNKNOWN_STB), NULL, true));
+        CTG_ERR_JRET(ctgRefreshTblMeta(pCtg, pRpc, pMgmtEps, pTableName,
+                                       CTG_FLAG_FORCE_UPDATE | CTG_FLAG_MAKE_STB(CTG_FLAG_UNKNOWN_STB), NULL, true));
 
         char dbFName[TSDB_DB_FNAME_LEN] = {0};
-        tNameGetFullDbName(pTableName, dbFName);        
+        tNameGetFullDbName(pTableName, dbFName);
         CTG_ERR_JRET(ctgRefreshDBVgInfo(pCtg, pRpc, pMgmtEps, dbFName));
-        
+
         continue;
       }
     }
@@ -3069,8 +3059,8 @@ _return:
   CTG_API_LEAVE(code);
 }
 
-
-int32_t catalogGetTableHashVgroup(SCatalog *pCtg, void *pTrans, const SEpSet *pMgmtEps, const SName *pTableName, SVgroupInfo *pVgroup) {
+int32_t catalogGetTableHashVgroup(SCatalog *pCtg, void *pTrans, const SEpSet *pMgmtEps, const SName *pTableName,
+                                  SVgroupInfo *pVgroup) {
   CTG_API_ENTER();
 
   if (CTG_IS_SYS_DBNAME(pTableName->dbname)) {
@@ -3078,9 +3068,9 @@ int32_t catalogGetTableHashVgroup(SCatalog *pCtg, void *pTrans, const SEpSet *pM
     CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
   }
 
-  SCtgDBCache* dbCache = NULL;
-  int32_t code = 0;
-  char db[TSDB_DB_FNAME_LEN] = {0};
+  SCtgDBCache *dbCache = NULL;
+  int32_t      code = 0;
+  char         db[TSDB_DB_FNAME_LEN] = {0};
   tNameGetFullDbName(pTableName, db);
 
   SDBVgInfo *vgInfo = NULL;
@@ -3103,8 +3093,8 @@ _return:
   CTG_API_LEAVE(code);
 }
 
-
-int32_t catalogGetAllMeta(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps, const SCatalogReq* pReq, SMetaData* pRsp) {
+int32_t catalogGetAllMeta(SCatalog *pCtg, void *pTrans, const SEpSet *pMgmtEps, const SCatalogReq *pReq,
+                          SMetaData *pRsp) {
   CTG_API_ENTER();
 
   if (NULL == pCtg || NULL == pTrans || NULL == pMgmtEps || NULL == pReq || NULL == pRsp) {
@@ -3126,11 +3116,11 @@ int32_t catalogGetAllMeta(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps,
       ctgError("taosArrayInit %d failed", tbNum);
       CTG_ERR_JRET(TSDB_CODE_CTG_MEM_ERROR);
     }
-    
+
     for (int32_t i = 0; i < tbNum; ++i) {
-      SName *name = taosArrayGet(pReq->pTableName, i);
+      SName      *name = taosArrayGet(pReq->pTableName, i);
       STableMeta *pTableMeta = NULL;
-      
+
       CTG_ERR_JRET(ctgGetTableMeta(pCtg, pTrans, pMgmtEps, name, &pTableMeta, CTG_FLAG_UNKNOWN_STB));
 
       if (NULL == taosArrayPush(pRsp->pTableMeta, &pTableMeta)) {
@@ -3148,7 +3138,7 @@ int32_t catalogGetAllMeta(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps,
 
   CTG_API_LEAVE(TSDB_CODE_SUCCESS);
 
-_return:  
+_return:
 
   if (pRsp->pTableMeta) {
     int32_t aSize = taosArrayGetSize(pRsp->pTableMeta);
@@ -3156,19 +3146,19 @@ _return:
       STableMeta *pMeta = taosArrayGetP(pRsp->pTableMeta, i);
       taosMemoryFreeClear(pMeta);
     }
-    
+
     taosArrayDestroy(pRsp->pTableMeta);
     pRsp->pTableMeta = NULL;
   }
-  
+
   CTG_API_LEAVE(code);
 }
 
-int32_t catalogGetQnodeList(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, SArray* pQnodeList) {
+int32_t catalogGetQnodeList(SCatalog *pCtg, void *pRpc, const SEpSet *pMgmtEps, SArray *pQnodeList) {
   CTG_API_ENTER();
-  
+
   int32_t code = 0;
-  if (NULL == pCtg || NULL == pRpc  || NULL == pMgmtEps || NULL == pQnodeList) {
+  if (NULL == pCtg || NULL == pRpc || NULL == pMgmtEps || NULL == pQnodeList) {
     CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
   }
 
@@ -3179,7 +3169,7 @@ _return:
   CTG_API_LEAVE(TSDB_CODE_SUCCESS);
 }
 
-int32_t catalogGetExpiredSTables(SCatalog* pCtg, SSTableMetaVersion **stables, uint32_t *num) {
+int32_t catalogGetExpiredSTables(SCatalog *pCtg, SSTableMetaVersion **stables, uint32_t *num) {
   CTG_API_ENTER();
 
   if (NULL == pCtg || NULL == stables || NULL == num) {
@@ -3189,9 +3179,9 @@ int32_t catalogGetExpiredSTables(SCatalog* pCtg, SSTableMetaVersion **stables, u
   CTG_API_LEAVE(ctgMetaRentGet(&pCtg->stbRent, (void **)stables, num, sizeof(SSTableMetaVersion)));
 }
 
-int32_t catalogGetExpiredDBs(SCatalog* pCtg, SDbVgVersion **dbs, uint32_t *num) {
+int32_t catalogGetExpiredDBs(SCatalog *pCtg, SDbVgVersion **dbs, uint32_t *num) {
   CTG_API_ENTER();
-  
+
   if (NULL == pCtg || NULL == dbs || NULL == num) {
     CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
   }
@@ -3199,9 +3189,9 @@ int32_t catalogGetExpiredDBs(SCatalog* pCtg, SDbVgVersion **dbs, uint32_t *num)
   CTG_API_LEAVE(ctgMetaRentGet(&pCtg->dbRent, (void **)dbs, num, sizeof(SDbVgVersion)));
 }
 
-int32_t catalogGetExpiredUsers(SCatalog* pCtg, SUserAuthVersion **users, uint32_t *num) {
+int32_t catalogGetExpiredUsers(SCatalog *pCtg, SUserAuthVersion **users, uint32_t *num) {
   CTG_API_ENTER();
-  
+
   if (NULL == pCtg || NULL == users || NULL == num) {
     CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
   }
@@ -3215,7 +3205,7 @@ int32_t catalogGetExpiredUsers(SCatalog* pCtg, SUserAuthVersion **users, uint32_
     }
   }
 
-  uint32_t i = 0;
+  uint32_t      i = 0;
   SCtgUserAuth *pAuth = taosHashIterate(pCtg->userCache, NULL);
   while (pAuth != NULL) {
     void *key = taosHashGetKey(pAuth, NULL);
@@ -3227,10 +3217,9 @@ int32_t catalogGetExpiredUsers(SCatalog* pCtg, SUserAuthVersion **users, uint32_
   CTG_API_LEAVE(TSDB_CODE_SUCCESS);
 }
 
-
-int32_t catalogGetDBCfg(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const char* dbFName, SDbCfgInfo* pDbCfg) {
+int32_t catalogGetDBCfg(SCatalog *pCtg, void *pRpc, const SEpSet *pMgmtEps, const char *dbFName, SDbCfgInfo *pDbCfg) {
   CTG_API_ENTER();
-  
+
   if (NULL == pCtg || NULL == pRpc || NULL == pMgmtEps || NULL == dbFName || NULL == pDbCfg) {
     CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
   }
@@ -3238,9 +3227,10 @@ int32_t catalogGetDBCfg(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, cons
   CTG_API_LEAVE(ctgGetDBCfgFromMnode(pCtg, pRpc, pMgmtEps, dbFName, pDbCfg));
 }
 
-int32_t catalogGetIndexInfo(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const char* indexName, SIndexInfo* pInfo) {
+int32_t catalogGetIndexInfo(SCatalog *pCtg, void *pRpc, const SEpSet *pMgmtEps, const char *indexName,
+                            SIndexInfo *pInfo) {
   CTG_API_ENTER();
-  
+
   if (NULL == pCtg || NULL == pRpc || NULL == pMgmtEps || NULL == indexName || NULL == pInfo) {
     CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
   }
@@ -3248,9 +3238,9 @@ int32_t catalogGetIndexInfo(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps,
   CTG_API_LEAVE(ctgGetIndexInfoFromMnode(pCtg, pRpc, pMgmtEps, indexName, pInfo));
 }
 
-int32_t catalogGetUdfInfo(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const char* funcName, SFuncInfo** pInfo) {
+int32_t catalogGetUdfInfo(SCatalog *pCtg, void *pRpc, const SEpSet *pMgmtEps, const char *funcName, SFuncInfo **pInfo) {
   CTG_API_ENTER();
-  
+
   if (NULL == pCtg || NULL == pRpc || NULL == pMgmtEps || NULL == funcName || NULL == pInfo) {
     CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
   }
@@ -3262,32 +3252,33 @@ int32_t catalogGetUdfInfo(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, co
   }
 
   CTG_ERR_JRET(ctgGetUdfInfoFromMnode(pCtg, pRpc, pMgmtEps, funcName, pInfo));
-  
+
 _return:
 
   if (code) {
-    taosMemoryFreeClear(*pInfo);    
+    taosMemoryFreeClear(*pInfo);
   }
-  
+
   CTG_API_LEAVE(code);
 }
 
-int32_t catalogChkAuth(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const char* user, const char* dbFName, AUTH_TYPE type, bool *pass) {
+int32_t catalogChkAuth(SCatalog *pCtg, void *pRpc, const SEpSet *pMgmtEps, const char *user, const char *dbFName,
+                       AUTH_TYPE type, bool *pass) {
   CTG_API_ENTER();
-  
+
   if (NULL == pCtg || NULL == pRpc || NULL == pMgmtEps || NULL == user || NULL == dbFName || NULL == pass) {
     CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
   }
 
   int32_t code = 0;
   CTG_ERR_JRET(ctgChkAuth(pCtg, pRpc, pMgmtEps, user, dbFName, type, pass));
-  
+
 _return:
 
   CTG_API_LEAVE(code);
 }
 
-int32_t catalogUpdateUserAuthInfo(SCatalog* pCtg, SGetUserAuthRsp* pAuth) {
+int32_t catalogUpdateUserAuthInfo(SCatalog *pCtg, SGetUserAuthRsp *pAuth) {
   CTG_API_ENTER();
 
   if (NULL == pCtg || NULL == pAuth) {
@@ -3297,20 +3288,19 @@ int32_t catalogUpdateUserAuthInfo(SCatalog* pCtg, SGetUserAuthRsp* pAuth) {
   CTG_API_LEAVE(ctgPushUpdateUserMsgInQueue(pCtg, pAuth, false));
 }
 
-
 void catalogDestroy(void) {
   qInfo("start to destroy catalog");
-  
-  if (NULL == gCtgMgmt.pCluster || atomic_load_8((int8_t*)&gCtgMgmt.exit)) {
+
+  if (NULL == gCtgMgmt.pCluster || atomic_load_8((int8_t *)&gCtgMgmt.exit)) {
     return;
   }
 
-  atomic_store_8((int8_t*)&gCtgMgmt.exit, true);
+  atomic_store_8((int8_t *)&gCtgMgmt.exit, true);
 
   if (tsem_post(&gCtgMgmt.queue.reqSem)) {
     qError("tsem_post failed, error:%s", tstrerror(TAOS_SYSTEM_ERROR(errno)));
   }
-  
+
   if (tsem_post(&gCtgMgmt.queue.rspSem)) {
     qError("tsem_post failed, error:%s", tstrerror(TAOS_SYSTEM_ERROR(errno)));
   }
@@ -3318,21 +3308,21 @@ void catalogDestroy(void) {
   while (CTG_IS_LOCKED(&gCtgMgmt.lock)) {
     taosUsleep(1);
   }
-  
+
   CTG_LOCK(CTG_WRITE, &gCtgMgmt.lock);
 
   SCatalog *pCtg = NULL;
-  void *pIter = taosHashIterate(gCtgMgmt.pCluster, NULL);
+  void     *pIter = taosHashIterate(gCtgMgmt.pCluster, NULL);
   while (pIter) {
     pCtg = *(SCatalog **)pIter;
 
     if (pCtg) {
       catalogFreeHandle(pCtg);
     }
-    
+
     pIter = taosHashIterate(gCtgMgmt.pCluster, pIter);
   }
-  
+
   taosHashCleanup(gCtgMgmt.pCluster);
   gCtgMgmt.pCluster = NULL;
 
@@ -3341,5 +3331,3 @@ void catalogDestroy(void) {
   qInfo("catalog destroyed");
 }
 
-
-

source/util/src/thash.c

@@ -15,8 +15,8 @@
 
 #define _DEFAULT_SOURCE
 #include "thash.h"
-#include "taoserror.h"
 #include "os.h"
+#include "taoserror.h"
 #include "tlog.h"
 
 // the add ref count operation may trigger the warning if the reference count is greater than the MAX_WARNING_REF_COUNT
@@ -27,36 +27,36 @@
 
 #define HASH_NEED_RESIZE(_h) ((_h)->size >= (_h)->capacity * HASH_DEFAULT_LOAD_FACTOR)
 
-#define GET_HASH_NODE_KEY(_n)  ((char*)(_n) + sizeof(SHashNode) + (_n)->dataLen)
-#define GET_HASH_NODE_DATA(_n) ((char*)(_n) + sizeof(SHashNode))
-#define GET_HASH_PNODE(_n)     ((SHashNode *)((char*)(_n) - sizeof(SHashNode)))
+#define GET_HASH_NODE_KEY(_n)  ((char *)(_n) + sizeof(SHashNode) + (_n)->dataLen)
+#define GET_HASH_NODE_DATA(_n) ((char *)(_n) + sizeof(SHashNode))
+#define GET_HASH_PNODE(_n)     ((SHashNode *)((char *)(_n) - sizeof(SHashNode)))
 
 #define FREE_HASH_NODE(_fp, _n) \
   do {                          \
-/*    if (_fp != NULL) {          \
-      (_fp)(_n);                \
-    }*/                           \
+    /*    if (_fp != NULL) {    \
+          (_fp)(_n);            \
+        }*/                     \
     taosMemoryFreeClear(_n);    \
   } while (0);
 
 struct SHashNode {
-  SHashNode        *next;
-  uint32_t          hashVal;  // the hash value of key
-  uint32_t          dataLen;  // length of data
-  uint32_t          keyLen;   // length of the key
-  uint16_t          refCount; // reference count
-  int8_t            removed;  // flag to indicate removed
-  char              data[];
+  SHashNode *next;
+  uint32_t   hashVal;   // the hash value of key
+  uint32_t   dataLen;   // length of data
+  uint32_t   keyLen;    // length of the key
+  uint16_t   refCount;  // reference count
+  int8_t     removed;   // flag to indicate removed
+  char       data[];
 };
 
 typedef struct SHashEntry {
-  int32_t           num;      // number of elements in current entry
-  SRWLatch          latch;    // entry latch
-  SHashNode        *next;
+  int32_t    num;    // number of elements in current entry
+  SRWLatch   latch;  // entry latch
+  SHashNode *next;
 } SHashEntry;
 
 struct SHashObj {
-  SHashEntry **     hashList;
+  SHashEntry      **hashList;
   size_t            capacity;      // number of slots
   int64_t           size;          // number of elements in hash table
   _hash_fn_t        hashFp;        // hash function
@@ -65,7 +65,7 @@ struct SHashObj {
   SRWLatch          lock;          // read-write spin lock
   SHashLockTypeE    type;          // lock type
   bool              enableUpdate;  // enable update
-  SArray *          pMemBlock;     // memory block allocated for SHashEntry
+  SArray           *pMemBlock;     // memory block allocated for SHashEntry
   _hash_before_fn_t callbackFp;    // function invoked before return the value to caller
 };
 
@@ -103,14 +103,14 @@ static FORCE_INLINE void taosHashRUnlock(SHashObj *pHashObj) {
   taosRUnLockLatch(&pHashObj->lock);
 }
 
-static FORCE_INLINE void taosHashEntryWLock(const SHashObj *pHashObj, SHashEntry* pe) {
+static FORCE_INLINE void taosHashEntryWLock(const SHashObj *pHashObj, SHashEntry *pe) {
   if (pHashObj->type == HASH_NO_LOCK) {
     return;
   }
   taosWLockLatch(&pe->latch);
 }
 
-static FORCE_INLINE void taosHashEntryWUnlock(const SHashObj *pHashObj, SHashEntry* pe) {
+static FORCE_INLINE void taosHashEntryWUnlock(const SHashObj *pHashObj, SHashEntry *pe) {
   if (pHashObj->type == HASH_NO_LOCK) {
     return;
   }
@@ -118,7 +118,7 @@ static FORCE_INLINE void taosHashEntryWUnlock(const SHashObj *pHashObj, SHashEnt
   taosWUnLockLatch(&pe->latch);
 }
 
-static FORCE_INLINE void taosHashEntryRLock(const SHashObj *pHashObj, SHashEntry* pe) {
+static FORCE_INLINE void taosHashEntryRLock(const SHashObj *pHashObj, SHashEntry *pe) {
   if (pHashObj->type == HASH_NO_LOCK) {
     return;
   }
@@ -126,7 +126,7 @@ static FORCE_INLINE void taosHashEntryRLock(const SHashObj *pHashObj, SHashEntry
   taosRLockLatch(&pe->latch);
 }
 
-static FORCE_INLINE void taosHashEntryRUnlock(const SHashObj *pHashObj, SHashEntry* pe) {
+static FORCE_INLINE void taosHashEntryRUnlock(const SHashObj *pHashObj, SHashEntry *pe) {
   if (pHashObj->type == HASH_NO_LOCK) {
     return;
   }
@@ -142,12 +142,11 @@ static FORCE_INLINE int32_t taosHashCapacity(int32_t length) {
   return i;
 }
 
-static FORCE_INLINE SHashNode *
-doSearchInEntryList(SHashObj *pHashObj, SHashEntry *pe, const void *key, size_t keyLen, uint32_t hashVal) {
+static FORCE_INLINE SHashNode *doSearchInEntryList(SHashObj *pHashObj, SHashEntry *pe, const void *key, size_t keyLen,
+                                                   uint32_t hashVal) {
   SHashNode *pNode = pe->next;
   while (pNode) {
-    if ((pNode->keyLen == keyLen) &&
-        ((*(pHashObj->equalFp))(GET_HASH_NODE_KEY(pNode), key, keyLen) == 0) &&
+    if ((pNode->keyLen == keyLen) && ((*(pHashObj->equalFp))(GET_HASH_NODE_KEY(pNode), key, keyLen) == 0) &&
         pNode->removed == 0) {
       assert(pNode->hashVal == hashVal);
       break;
@@ -186,7 +185,8 @@ static SHashNode *doCreateHashNode(const void *key, size_t keyLen, const void *p
  * @param pNode      the old node with requested key
  * @param pNewNode   the new node with requested key
  */
-static FORCE_INLINE void doUpdateHashNode(SHashObj *pHashObj, SHashEntry* pe, SHashNode* prev, SHashNode *pNode, SHashNode *pNewNode) {
+static FORCE_INLINE void doUpdateHashNode(SHashObj *pHashObj, SHashEntry *pe, SHashNode *prev, SHashNode *pNode,
+                                          SHashNode *pNewNode) {
   assert(pNode->keyLen == pNewNode->keyLen);
 
   atomic_sub_fetch_16(&pNode->refCount, 1);
@@ -227,9 +227,7 @@ static FORCE_INLINE bool taosHashTableEmpty(const SHashObj *pHashObj);
  * @param pHashObj
  * @return
  */
-static FORCE_INLINE bool taosHashTableEmpty(const SHashObj *pHashObj) {
-  return taosHashGetSize(pHashObj) == 0;
-}
+static FORCE_INLINE bool taosHashTableEmpty(const SHashObj *pHashObj) { return taosHashGetSize(pHashObj) == 0; }
 
 SHashObj *taosHashInit(size_t capacity, _hash_fn_t fn, bool update, SHashLockTypeE type) {
   if (fn == NULL) {
@@ -251,7 +249,7 @@ SHashObj *taosHashInit(size_t capacity, _hash_fn_t fn, bool update, SHashLockTyp
   pHashObj->capacity = taosHashCapacity((int32_t)capacity);
 
   pHashObj->equalFp = memcmp;
-  pHashObj->hashFp  = fn;
+  pHashObj->hashFp = fn;
   pHashObj->type = type;
   pHashObj->enableUpdate = update;
 
@@ -305,7 +303,7 @@ int32_t taosHashGetSize(const SHashObj *pHashObj) {
   if (pHashObj == NULL) {
     return 0;
   }
-  return (int32_t)atomic_load_64((int64_t*)&pHashObj->size);
+  return (int32_t)atomic_load_64((int64_t *)&pHashObj->size);
 }
 
 int32_t taosHashPut(SHashObj *pHashObj, const void *key, size_t keyLen, const void *data, size_t size) {
@@ -340,10 +338,9 @@ int32_t taosHashPut(SHashObj *pHashObj, const void *key, size_t keyLen, const vo
   }
 #endif
 
-  SHashNode* prev = NULL;
+  SHashNode *prev = NULL;
   while (pNode) {
-    if ((pNode->keyLen == keyLen) &&
-        (*(pHashObj->equalFp))(GET_HASH_NODE_KEY(pNode), key, keyLen) == 0 &&
+    if ((pNode->keyLen == keyLen) && (*(pHashObj->equalFp))(GET_HASH_NODE_KEY(pNode), key, keyLen) == 0 &&
         pNode->removed == 0) {
       assert(pNode->hashVal == hashVal);
       break;
@@ -391,27 +388,27 @@ int32_t taosHashPut(SHashObj *pHashObj, const void *key, size_t keyLen, const vo
   }
 }
 
-static void* taosHashGetImpl(SHashObj *pHashObj, const void *key, size_t keyLen, void** d, int32_t* size, bool addRef);
+static void *taosHashGetImpl(SHashObj *pHashObj, const void *key, size_t keyLen, void **d, int32_t *size, bool addRef);
 
 void *taosHashGet(SHashObj *pHashObj, const void *key, size_t keyLen) {
-  void* p = NULL;
+  void *p = NULL;
   return taosHashGetImpl(pHashObj, key, keyLen, &p, 0, false);
 }
 
 int32_t taosHashGetDup(SHashObj *pHashObj, const void *key, size_t keyLen, void *destBuf) {
   terrno = 0;
-  /*char* p = */taosHashGetImpl(pHashObj, key, keyLen, &destBuf, 0, false);
+  /*char* p = */ taosHashGetImpl(pHashObj, key, keyLen, &destBuf, 0, false);
   return terrno;
 }
 
-int32_t taosHashGetDup_m(SHashObj *pHashObj, const void *key, size_t keyLen, void **destBuf, int32_t* size) {
+int32_t taosHashGetDup_m(SHashObj *pHashObj, const void *key, size_t keyLen, void **destBuf, int32_t *size) {
   terrno = 0;
 
-  /*char* p = */taosHashGetImpl(pHashObj, key, keyLen, destBuf, size, false);
+  /*char* p = */ taosHashGetImpl(pHashObj, key, keyLen, destBuf, size, false);
   return terrno;
 }
 
-void* taosHashGetImpl(SHashObj *pHashObj, const void *key, size_t keyLen, void** d, int32_t* size, bool addRef) {
+void *taosHashGetImpl(SHashObj *pHashObj, const void *key, size_t keyLen, void **d, int32_t *size, bool addRef) {
   if (pHashObj == NULL || taosHashTableEmpty(pHashObj) || keyLen == 0 || key == NULL) {
     return NULL;
   }
@@ -449,15 +446,15 @@ void* taosHashGetImpl(SHashObj *pHashObj, const void *key, size_t keyLen, void**
 
     if (size != NULL) {
       if (*d == NULL) {
-        *size =  pNode->dataLen;
+        *size = pNode->dataLen;
         *d = taosMemoryCalloc(1, *size);
         if (*d == NULL) {
           terrno = TSDB_CODE_OUT_OF_MEMORY;
           return NULL;
         }
       } else if (*size < pNode->dataLen) {
-        *size =  pNode->dataLen;
-        char* tmp = taosMemoryRealloc(*d, *size);
+        *size = pNode->dataLen;
+        char *tmp = taosMemoryRealloc(*d, *size);
         if (tmp == NULL) {
           terrno = TSDB_CODE_OUT_OF_MEMORY;
           return NULL;
@@ -508,13 +505,12 @@ int32_t taosHashRemove(SHashObj *pHashObj, const void *key, size_t keyLen) {
     return -1;
   }
 
-  int code = -1;
+  int        code = -1;
   SHashNode *pNode = pe->next;
   SHashNode *prevNode = NULL;
 
   while (pNode) {
-    if ((pNode->keyLen == keyLen) &&
-        ((*(pHashObj->equalFp))(GET_HASH_NODE_KEY(pNode), key, keyLen) == 0) &&
+    if ((pNode->keyLen == keyLen) && ((*(pHashObj->equalFp))(GET_HASH_NODE_KEY(pNode), key, keyLen) == 0) &&
         pNode->removed == 0) {
       code = 0;  // it is found
 
@@ -598,14 +594,14 @@ void taosHashCleanup(SHashObj *pHashObj) {
 }
 
 // for profile only
-int32_t taosHashGetMaxOverflowLinkLength(const SHashObj *pHashObj){
+int32_t taosHashGetMaxOverflowLinkLength(const SHashObj *pHashObj) {
   if (pHashObj == NULL || taosHashTableEmpty(pHashObj)) {
     return 0;
   }
 
   int32_t num = 0;
 
-  taosHashRLock((SHashObj*) pHashObj);
+  taosHashRLock((SHashObj *)pHashObj);
   for (int32_t i = 0; i < pHashObj->size; ++i) {
     SHashEntry *pEntry = pHashObj->hashList[i];
 
@@ -616,7 +612,7 @@ int32_t taosHashGetMaxOverflowLinkLength(const SHashObj *pHashObj){
     }
   }
 
-  taosHashRUnlock((SHashObj*) pHashObj);
+  taosHashRUnlock((SHashObj *)pHashObj);
   return num;
 }
 
@@ -627,22 +623,22 @@ void taosHashTableResize(SHashObj *pHashObj) {
 
   int32_t newCapacity = (int32_t)(pHashObj->capacity << 1u);
   if (newCapacity > HASH_MAX_CAPACITY) {
-//    uDebug("current capacity:%zu, maximum capacity:%d, no resize applied due to limitation is reached",
-//           pHashObj->capacity, HASH_MAX_CAPACITY);
+    //    uDebug("current capacity:%zu, maximum capacity:%d, no resize applied due to limitation is reached",
+    //           pHashObj->capacity, HASH_MAX_CAPACITY);
     return;
   }
 
   int64_t st = taosGetTimestampUs();
-  void *pNewEntryList = taosMemoryRealloc(pHashObj->hashList, sizeof(void *) * newCapacity);
+  void   *pNewEntryList = taosMemoryRealloc(pHashObj->hashList, sizeof(void *) * newCapacity);
   if (pNewEntryList == NULL) {
-//    uDebug("cache resize failed due to out of memory, capacity remain:%zu", pHashObj->capacity);
+    //    uDebug("cache resize failed due to out of memory, capacity remain:%zu", pHashObj->capacity);
     return;
   }
 
   pHashObj->hashList = pNewEntryList;
 
   size_t inc = newCapacity - pHashObj->capacity;
-  void * p = taosMemoryCalloc(inc, sizeof(SHashEntry));
+  void  *p = taosMemoryCalloc(inc, sizeof(SHashEntry));
 
   for (int32_t i = 0; i < inc; ++i) {
     pHashObj->hashList[i + pHashObj->capacity] = (void *)((char *)p + i * sizeof(SHashEntry));
@@ -653,9 +649,9 @@ void taosHashTableResize(SHashObj *pHashObj) {
   pHashObj->capacity = newCapacity;
   for (int32_t idx = 0; idx < pHashObj->capacity; ++idx) {
     SHashEntry *pe = pHashObj->hashList[idx];
-    SHashNode *pNode;
-    SHashNode *pNext;
-    SHashNode *pPrev = NULL;
+    SHashNode  *pNode;
+    SHashNode  *pNext;
+    SHashNode  *pPrev = NULL;
 
     if (pe->num == 0) {
       assert(pe->next == NULL);
@@ -688,24 +684,25 @@ void taosHashTableResize(SHashObj *pHashObj) {
 
   int64_t et = taosGetTimestampUs();
 
-//  uDebug("hash table resize completed, new capacity:%d, load factor:%f, elapsed time:%fms", (int32_t)pHashObj->capacity,
-//         ((double)pHashObj->size) / pHashObj->capacity, (et - st) / 1000.0);
+  //  uDebug("hash table resize completed, new capacity:%d, load factor:%f, elapsed time:%fms",
+  //  (int32_t)pHashObj->capacity,
+  //         ((double)pHashObj->size) / pHashObj->capacity, (et - st) / 1000.0);
 }
 
 SHashNode *doCreateHashNode(const void *key, size_t keyLen, const void *pData, size_t dsize, uint32_t hashVal) {
-  SHashNode *pNewNode = taosMemoryMalloc(sizeof(SHashNode) + keyLen + dsize);
+  SHashNode *pNewNode = taosMemoryMalloc(sizeof(SHashNode) + keyLen + dsize + 1);
 
   if (pNewNode == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
   }
 
-  pNewNode->keyLen  = (uint32_t)keyLen;
+  pNewNode->keyLen = (uint32_t)keyLen;
   pNewNode->hashVal = hashVal;
   pNewNode->dataLen = (uint32_t)dsize;
-  pNewNode->refCount= 1;
+  pNewNode->refCount = 1;
   pNewNode->removed = 0;
-  pNewNode->next    = NULL;
+  pNewNode->next = NULL;
 
   memcpy(GET_HASH_NODE_DATA(pNewNode), pData, dsize);
   memcpy(GET_HASH_NODE_KEY(pNewNode), key, keyLen);
@@ -727,11 +724,12 @@ size_t taosHashGetMemSize(const SHashObj *pHashObj) {
     return 0;
   }
 
-  return (pHashObj->capacity * (sizeof(SHashEntry) + sizeof(void*))) + sizeof(SHashNode) * taosHashGetSize(pHashObj) + sizeof(SHashObj);
+  return (pHashObj->capacity * (sizeof(SHashEntry) + sizeof(void *))) + sizeof(SHashNode) * taosHashGetSize(pHashObj) +
+         sizeof(SHashObj);
 }
 
-void *taosHashGetKey(void *data, size_t* keyLen) {
-  SHashNode * node = GET_HASH_PNODE(data);
+void *taosHashGetKey(void *data, size_t *keyLen) {
+  SHashNode *node = GET_HASH_PNODE(data);
   if (keyLen != NULL) {
     *keyLen = node->keyLen;
   }
@@ -751,8 +749,7 @@ static void *taosHashReleaseNode(SHashObj *pHashObj, void *p, int *slot) {
 
   SHashNode *pNode = pe->next;
   while (pNode) {
-    if (pNode == pOld)
-      break;
+    if (pNode == pOld) break;
 
     prevNode = pNode;
     pNode = pNode->next;
@@ -766,7 +763,7 @@ static void *taosHashReleaseNode(SHashObj *pHashObj, void *p, int *slot) {
     }
 
     atomic_sub_fetch_16(&pOld->refCount, 1);
-    if (pOld->refCount <=0) {
+    if (pOld->refCount <= 0) {
       if (prevNode) {
         prevNode->next = pOld->next;
       } else {
@@ -778,7 +775,7 @@ static void *taosHashReleaseNode(SHashObj *pHashObj, void *p, int *slot) {
       FREE_HASH_NODE(pHashObj->freeFp, pOld);
     }
   } else {
-//    uError("pNode:%p data:%p is not there!!!", pNode, p);
+    //    uError("pNode:%p data:%p is not there!!!", pNode, p);
   }
 
   return pNode;
@@ -787,7 +784,7 @@ static void *taosHashReleaseNode(SHashObj *pHashObj, void *p, int *slot) {
 void *taosHashIterate(SHashObj *pHashObj, void *p) {
   if (pHashObj == NULL) return NULL;
 
-  int  slot = 0;
+  int   slot = 0;
   char *data = NULL;
 
   // only add the read lock to disable the resize process
@@ -865,9 +862,9 @@ void taosHashCancelIterate(SHashObj *pHashObj, void *p) {
   taosHashRUnlock(pHashObj);
 }
 
-//TODO remove it
+// TODO remove it
 void *taosHashAcquire(SHashObj *pHashObj, const void *key, size_t keyLen) {
-  void* p = NULL;
+  void *p = NULL;
   return taosHashGetImpl(pHashObj, key, keyLen, &p, 0, true);
 }