Merge pull request #16791 from taosdata/fix/ctgMemleak

fix(ctg): fix memleak

source/libs/catalog/src/ctgCache.c

@@ -13,72 +13,23 @@
  * 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"
 
-SCtgOperation gCtgCacheOperation[CTG_OP_MAX] = {
-  {
-    CTG_OP_UPDATE_VGROUP,
-    "update vgInfo",
-    ctgOpUpdateVgroup
-  },
-  {
-    CTG_OP_UPDATE_TB_META,
-    "update tbMeta",
-    ctgOpUpdateTbMeta
-  },
-  {
-    CTG_OP_DROP_DB_CACHE,
-    "drop DB",
-    ctgOpDropDbCache
-  },
-  {
-    CTG_OP_DROP_DB_VGROUP,
-    "drop DBVgroup",
-    ctgOpDropDbVgroup
-  },
-  {
-    CTG_OP_DROP_STB_META,
-    "drop stbMeta",
-    ctgOpDropStbMeta
-  },
-  {
-    CTG_OP_DROP_TB_META,
-    "drop tbMeta",
-    ctgOpDropTbMeta
-  },
-  {
-    CTG_OP_UPDATE_USER,
-    "update user",
-    ctgOpUpdateUser
-  },
-  {
-    CTG_OP_UPDATE_VG_EPSET,
-    "update epset",
-    ctgOpUpdateEpset
-  },
-  {
-    CTG_OP_UPDATE_TB_INDEX,
-    "update tbIndex",
-    ctgOpUpdateTbIndex
-  },
-  {
-    CTG_OP_DROP_TB_INDEX,
-    "drop tbIndex",
-    ctgOpDropTbIndex
-  },
-  {
-    CTG_OP_CLEAR_CACHE,
-    "clear cache",
-    ctgOpClearCache
-  }  
-};
-
-
-
+SCtgOperation gCtgCacheOperation[CTG_OP_MAX] = {{CTG_OP_UPDATE_VGROUP, "update vgInfo", ctgOpUpdateVgroup},
+                                                {CTG_OP_UPDATE_TB_META, "update tbMeta", ctgOpUpdateTbMeta},
+                                                {CTG_OP_DROP_DB_CACHE, "drop DB", ctgOpDropDbCache},
+                                                {CTG_OP_DROP_DB_VGROUP, "drop DBVgroup", ctgOpDropDbVgroup},
+                                                {CTG_OP_DROP_STB_META, "drop stbMeta", ctgOpDropStbMeta},
+                                                {CTG_OP_DROP_TB_META, "drop tbMeta", ctgOpDropTbMeta},
+                                                {CTG_OP_UPDATE_USER, "update user", ctgOpUpdateUser},
+                                                {CTG_OP_UPDATE_VG_EPSET, "update epset", ctgOpUpdateEpset},
+                                                {CTG_OP_UPDATE_TB_INDEX, "update tbIndex", ctgOpUpdateTbIndex},
+                                                {CTG_OP_DROP_TB_INDEX, "drop tbIndex", ctgOpDropTbIndex},
+                                                {CTG_OP_CLEAR_CACHE, "clear cache", ctgOpClearCache}};
 
 int32_t ctgRLockVgInfo(SCatalog *pCtg, SCtgDBCache *dbCache, bool *inCache) {
   CTG_LOCK(CTG_READ, &dbCache->vgCache.vgLock);
@@ -86,18 +37,17 @@ int32_t ctgRLockVgInfo(SCatalog *pCtg, SCtgDBCache *dbCache, bool *inCache) {
   if (dbCache->deleted) {
     CTG_UNLOCK(CTG_READ, &dbCache->vgCache.vgLock);
 
-    ctgDebug("db is dropping, dbId:0x%"PRIx64, dbCache->dbId);
+    ctgDebug("db is dropping, dbId:0x%" PRIx64, dbCache->dbId);
 
     *inCache = false;
     return TSDB_CODE_SUCCESS;
   }
 
-  
   if (NULL == dbCache->vgCache.vgInfo) {
     CTG_UNLOCK(CTG_READ, &dbCache->vgCache.vgLock);
 
     *inCache = false;
-    ctgDebug("db vgInfo is empty, dbId:0x%"PRIx64, dbCache->dbId);
+    ctgDebug("db vgInfo is empty, dbId:0x%" PRIx64, dbCache->dbId);
     return TSDB_CODE_SUCCESS;
   }
 
@@ -110,7 +60,7 @@ int32_t ctgWLockVgInfo(SCatalog *pCtg, SCtgDBCache *dbCache) {
   CTG_LOCK(CTG_WRITE, &dbCache->vgCache.vgLock);
 
   if (dbCache->deleted) {
-    ctgDebug("db is dropping, dbId:0x%"PRIx64, dbCache->dbId);
+    ctgDebug("db is dropping, dbId:0x%" PRIx64, dbCache->dbId);
     CTG_UNLOCK(CTG_WRITE, &dbCache->vgCache.vgLock);
     CTG_ERR_RET(TSDB_CODE_CTG_DB_DROPPED);
   }
@@ -118,19 +68,13 @@ int32_t ctgWLockVgInfo(SCatalog *pCtg, SCtgDBCache *dbCache) {
   return TSDB_CODE_SUCCESS;
 }
 
-void ctgRUnlockVgInfo(SCtgDBCache *dbCache) {
-  CTG_UNLOCK(CTG_READ, &dbCache->vgCache.vgLock);
-}
+void ctgRUnlockVgInfo(SCtgDBCache *dbCache) { CTG_UNLOCK(CTG_READ, &dbCache->vgCache.vgLock); }
 
-void ctgWUnlockVgInfo(SCtgDBCache *dbCache) {
-  CTG_UNLOCK(CTG_WRITE, &dbCache->vgCache.vgLock);
-}
+void ctgWUnlockVgInfo(SCtgDBCache *dbCache) { CTG_UNLOCK(CTG_WRITE, &dbCache->vgCache.vgLock); }
 
-void ctgReleaseDBCache(SCatalog *pCtg, SCtgDBCache *dbCache) {
-  CTG_UNLOCK(CTG_READ, &dbCache->dbLock);
-}
+void ctgReleaseDBCache(SCatalog *pCtg, SCtgDBCache *dbCache) { CTG_UNLOCK(CTG_READ, &dbCache->dbLock); }
 
-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 && IS_SYS_DBNAME(p + 1)) {
     dbFName = p + 1;
@@ -162,20 +106,20 @@ int32_t ctgAcquireDBCacheImpl(SCatalog* pCtg, const char *dbFName, SCtgDBCache *
   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));
 }
 
-void ctgReleaseVgInfoToCache(SCatalog* pCtg, SCtgDBCache *dbCache) {
+void ctgReleaseVgInfoToCache(SCatalog *pCtg, SCtgDBCache *dbCache) {
   ctgRUnlockVgInfo(dbCache);
   ctgReleaseDBCache(pCtg, dbCache);
 }
 
-void ctgReleaseTbMetaToCache(SCatalog* pCtg, SCtgDBCache *dbCache, SCtgTbCache* pCache) {
+void ctgReleaseTbMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, SCtgTbCache *pCache) {
   if (pCache) {
     CTG_UNLOCK(CTG_READ, &pCache->metaLock);
     taosHashRelease(dbCache->tbCache, pCache);
@@ -186,7 +130,7 @@ void ctgReleaseTbMetaToCache(SCatalog* pCtg, SCtgDBCache *dbCache, SCtgTbCache*
   }
 }
 
-void ctgReleaseTbIndexToCache(SCatalog* pCtg, SCtgDBCache *dbCache, SCtgTbCache* pCache) {
+void ctgReleaseTbIndexToCache(SCatalog *pCtg, SCtgDBCache *dbCache, SCtgTbCache *pCache) {
   if (pCache) {
     CTG_UNLOCK(CTG_READ, &pCache->indexLock);
     taosHashRelease(dbCache->tbCache, pCache);
@@ -197,7 +141,7 @@ void ctgReleaseTbIndexToCache(SCatalog* pCtg, SCtgDBCache *dbCache, SCtgTbCache*
   }
 }
 
-int32_t ctgAcquireVgInfoFromCache(SCatalog* pCtg, const char *dbFName, SCtgDBCache **pCache) {
+int32_t ctgAcquireVgInfoFromCache(SCatalog *pCtg, const char *dbFName, SCtgDBCache **pCache) {
   SCtgDBCache *dbCache = NULL;
   ctgAcquireDBCache(pCtg, dbFName, &dbCache);
   if (NULL == dbCache) {
@@ -233,9 +177,9 @@ _return:
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t ctgAcquireTbMetaFromCache(SCatalog* pCtg, char *dbFName, char* tbName, SCtgDBCache **pDb, SCtgTbCache** pTb) {
+int32_t ctgAcquireTbMetaFromCache(SCatalog *pCtg, char *dbFName, char *tbName, SCtgDBCache **pDb, SCtgTbCache **pTb) {
   SCtgDBCache *dbCache = NULL;
-  SCtgTbCache* pCache = NULL;
+  SCtgTbCache *pCache = NULL;
   ctgAcquireDBCache(pCtg, dbFName, &dbCache);
   if (NULL == dbCache) {
     ctgDebug("db %s not in cache", dbFName);
@@ -272,16 +216,16 @@ _return:
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t ctgAcquireStbMetaFromCache(SCatalog* pCtg, char *dbFName, uint64_t suid, SCtgDBCache **pDb, SCtgTbCache** pTb) {
-  SCtgDBCache* dbCache = NULL;
-  SCtgTbCache* pCache = NULL;
+int32_t ctgAcquireStbMetaFromCache(SCatalog *pCtg, char *dbFName, uint64_t suid, SCtgDBCache **pDb, SCtgTbCache **pTb) {
+  SCtgDBCache *dbCache = NULL;
+  SCtgTbCache *pCache = NULL;
   ctgAcquireDBCache(pCtg, dbFName, &dbCache);
   if (NULL == dbCache) {
     ctgDebug("db %s not in cache", dbFName);
     goto _return;
   }
 
-  char* stName = taosHashAcquire(dbCache->stbCache, &suid, sizeof(suid));
+  char *stName = taosHashAcquire(dbCache->stbCache, &suid, sizeof(suid));
   if (NULL == stName) {
     ctgDebug("stb 0x%" PRIx64 " not in cache, dbFName:%s", suid, dbFName);
     goto _return;
@@ -321,10 +265,9 @@ _return:
   return TSDB_CODE_SUCCESS;
 }
 
-
-int32_t ctgAcquireTbIndexFromCache(SCatalog* pCtg, char *dbFName, char* tbName, SCtgDBCache **pDb, SCtgTbCache** pTb) {
+int32_t ctgAcquireTbIndexFromCache(SCatalog *pCtg, char *dbFName, char *tbName, SCtgDBCache **pDb, SCtgTbCache **pTb) {
   SCtgDBCache *dbCache = NULL;
-  SCtgTbCache* pCache = NULL;
+  SCtgTbCache *pCache = NULL;
   ctgAcquireDBCache(pCtg, dbFName, &dbCache);
   if (NULL == dbCache) {
     ctgDebug("db %s not in cache", dbFName);
@@ -362,8 +305,7 @@ _return:
   return TSDB_CODE_SUCCESS;
 }
 
-
-int32_t ctgTbMetaExistInCache(SCatalog* pCtg, char *dbFName, char* tbName, int32_t *exist) {
+int32_t ctgTbMetaExistInCache(SCatalog *pCtg, char *dbFName, char *tbName, int32_t *exist) {
   SCtgDBCache *dbCache = NULL;
   SCtgTbCache *tbCache = NULL;
   ctgAcquireTbMetaFromCache(pCtg, dbFName, tbName, &dbCache, &tbCache);
@@ -380,7 +322,7 @@ int32_t ctgTbMetaExistInCache(SCatalog* pCtg, char *dbFName, char* tbName, int32
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t ctgReadTbMetaFromCache(SCatalog* pCtg, SCtgTbMetaCtx* ctx, STableMeta** pTableMeta) {
+int32_t ctgReadTbMetaFromCache(SCatalog *pCtg, SCtgTbMetaCtx *ctx, STableMeta **pTableMeta) {
   int32_t      code = 0;
   SCtgDBCache *dbCache = NULL;
   SCtgTbCache *tbCache = NULL;
@@ -399,7 +341,7 @@ int32_t ctgReadTbMetaFromCache(SCatalog* pCtg, SCtgTbMetaCtx* ctx, STableMeta**
     return TSDB_CODE_SUCCESS;
   }
 
-  STableMeta* tbMeta = tbCache->pMeta;
+  STableMeta *tbMeta = tbCache->pMeta;
   ctx->tbInfo.inCache = true;
   ctx->tbInfo.dbId = dbCache->dbId;
   ctx->tbInfo.suid = tbMeta->suid;
@@ -431,8 +373,8 @@ int32_t ctgReadTbMetaFromCache(SCatalog* pCtg, SCtgTbMetaCtx* ctx, STableMeta**
   memcpy(*pTableMeta, tbMeta, metaSize);
 
   ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache);
-  ctgDebug("Got ctb %s meta from cache, will continue to get its stb meta, type:%d, dbFName:%s", 
-           ctx->pName->tname, ctx->tbInfo.tbType, dbFName);
+  ctgDebug("Got ctb %s meta from cache, will continue to get its stb meta, type:%d, dbFName:%s", ctx->pName->tname,
+           ctx->tbInfo.tbType, dbFName);
 
   ctgAcquireStbMetaFromCache(pCtg, dbFName, ctx->tbInfo.suid, &dbCache, &tbCache);
   if (NULL == tbCache) {
@@ -442,10 +384,10 @@ int32_t ctgReadTbMetaFromCache(SCatalog* pCtg, SCtgTbMetaCtx* ctx, STableMeta**
     return TSDB_CODE_SUCCESS;
   }
 
-  STableMeta* stbMeta = tbCache->pMeta;
+  STableMeta *stbMeta = tbCache->pMeta;
   if (stbMeta->suid != ctx->tbInfo.suid) {
     ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache);
-    ctgError("stb suid 0x%" PRIx64 " in stbCache mis-match, expected suid 0x%"PRIx64 , stbMeta->suid, ctx->tbInfo.suid);
+    ctgError("stb suid 0x%" PRIx64 " in stbCache mis-match, expected suid 0x%" PRIx64, stbMeta->suid, ctx->tbInfo.suid);
     CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR);
   }
 
@@ -472,8 +414,8 @@ _return:
   CTG_RET(code);
 }
 
-int32_t ctgReadTbVerFromCache(SCatalog *pCtg, SName *pTableName, int32_t *sver, int32_t *tver, int32_t *tbType, uint64_t *suid,
-                              char *stbName) {
+int32_t ctgReadTbVerFromCache(SCatalog *pCtg, SName *pTableName, int32_t *sver, int32_t *tver, int32_t *tbType,
+                              uint64_t *suid, char *stbName) {
   *sver = -1;
   *tver = -1;
 
@@ -488,7 +430,7 @@ int32_t ctgReadTbVerFromCache(SCatalog *pCtg, SName *pTableName, int32_t *sver,
     return TSDB_CODE_SUCCESS;
   }
 
-  STableMeta* tbMeta = tbCache->pMeta;
+  STableMeta *tbMeta = tbCache->pMeta;
   *tbType = tbMeta->tableType;
   *suid = tbMeta->suid;
 
@@ -496,8 +438,8 @@ int32_t ctgReadTbVerFromCache(SCatalog *pCtg, SName *pTableName, int32_t *sver,
     *sver = tbMeta->sversion;
     *tver = tbMeta->tversion;
 
-    ctgDebug("Got tb %s ver from cache, dbFName:%s, tbType:%d, sver:%d, tver:%d, suid:0x%" PRIx64, 
-             pTableName->tname, dbFName, *tbType, *sver, *tver, *suid);
+    ctgDebug("Got tb %s ver from cache, dbFName:%s, tbType:%d, sver:%d, tver:%d, suid:0x%" PRIx64, pTableName->tname,
+             dbFName, *tbType, *sver, *tver, *suid);
 
     ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache);
     return TSDB_CODE_SUCCESS;
@@ -515,10 +457,10 @@ int32_t ctgReadTbVerFromCache(SCatalog *pCtg, SName *pTableName, int32_t *sver,
     return TSDB_CODE_SUCCESS;
   }
 
-  STableMeta* stbMeta = tbCache->pMeta;
+  STableMeta *stbMeta = tbCache->pMeta;
   if (stbMeta->suid != *suid) {
     ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache);
-    ctgError("stb suid 0x%" PRIx64 " in stbCache mis-match, expected suid:0x%" PRIx64 , stbMeta->suid, *suid);
+    ctgError("stb suid 0x%" PRIx64 " in stbCache mis-match, expected suid:0x%" PRIx64, stbMeta->suid, *suid);
     CTG_ERR_RET(TSDB_CODE_CTG_INTERNAL_ERROR);
   }
 
@@ -533,13 +475,13 @@ int32_t ctgReadTbVerFromCache(SCatalog *pCtg, SName *pTableName, int32_t *sver,
 
   ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache);
 
-  ctgDebug("Got tb %s sver %d tver %d from cache, type:%d, dbFName:%s", pTableName->tname, *sver, *tver, *tbType, dbFName);
+  ctgDebug("Got tb %s sver %d tver %d from cache, type:%d, dbFName:%s", pTableName->tname, *sver, *tver, *tbType,
+           dbFName);
 
   return TSDB_CODE_SUCCESS;
 }
 
-
-int32_t ctgReadTbTypeFromCache(SCatalog* pCtg, char* dbFName, char *tbName, int32_t *tbType) {
+int32_t ctgReadTbTypeFromCache(SCatalog *pCtg, char *dbFName, char *tbName, int32_t *tbType) {
   SCtgDBCache *dbCache = NULL;
   SCtgTbCache *tbCache = NULL;
   CTG_ERR_RET(ctgAcquireTbMetaFromCache(pCtg, dbFName, tbName, &dbCache, &tbCache));
@@ -556,7 +498,7 @@ int32_t ctgReadTbTypeFromCache(SCatalog* pCtg, char* dbFName, char *tbName, int3
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t ctgReadTbIndexFromCache(SCatalog* pCtg, SName* pTableName, SArray** pRes) {
+int32_t ctgReadTbIndexFromCache(SCatalog *pCtg, SName *pTableName, SArray **pRes) {
   int32_t      code = 0;
   SCtgDBCache *dbCache = NULL;
   SCtgTbCache *tbCache = NULL;
@@ -580,7 +522,7 @@ _return:
   CTG_RET(code);
 }
 
-int32_t ctgChkAuthFromCache(SCatalog* pCtg, char* user, char* dbFName, AUTH_TYPE type, bool *inCache, bool *pass) {
+int32_t ctgChkAuthFromCache(SCatalog *pCtg, char *user, char *dbFName, AUTH_TYPE type, bool *inCache, bool *pass) {
   char *p = strchr(dbFName, '.');
   if (p) {
     ++p;
@@ -651,8 +593,7 @@ void ctgDequeue(SCtgCacheOperation **op) {
   *op = node->op;
 }
 
-
-int32_t ctgEnqueue(SCatalog* pCtg, SCtgCacheOperation *operation) {
+int32_t ctgEnqueue(SCatalog *pCtg, SCtgCacheOperation *operation) {
   SCtgQNode *node = taosMemoryCalloc(1, sizeof(SCtgQNode));
   if (NULL == node) {
     qError("calloc %d failed", (int32_t)sizeof(SCtgQNode));
@@ -660,7 +601,7 @@ int32_t ctgEnqueue(SCatalog* pCtg, SCtgCacheOperation *operation) {
   }
 
   bool  syncOp = operation->syncOp;
-  char* opName = gCtgCacheOperation[operation->opId].name;
+  char *opName = gCtgCacheOperation[operation->opId].name;
   if (operation->syncOp) {
     tsem_init(&operation->rspSem, 0, 0);
   }
@@ -699,8 +640,7 @@ int32_t ctgEnqueue(SCatalog* pCtg, SCtgCacheOperation *operation) {
   return TSDB_CODE_SUCCESS;
 }
 
-
-int32_t ctgDropDbCacheEnqueue(SCatalog* pCtg, const char *dbFName, int64_t dbId) {
+int32_t ctgDropDbCacheEnqueue(SCatalog *pCtg, const char *dbFName, int64_t dbId) {
   int32_t             code = 0;
   SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation));
   op->opId = CTG_OP_DROP_DB_CACHE;
@@ -732,7 +672,7 @@ _return:
   CTG_RET(code);
 }
 
-int32_t ctgDropDbVgroupEnqueue(SCatalog* pCtg, const char *dbFName, bool syncOp) {
+int32_t ctgDropDbVgroupEnqueue(SCatalog *pCtg, const char *dbFName, bool syncOp) {
   int32_t             code = 0;
   SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation));
   op->opId = CTG_OP_DROP_DB_VGROUP;
@@ -764,9 +704,8 @@ _return:
   CTG_RET(code);
 }
 
-
-
-int32_t ctgDropStbMetaEnqueue(SCatalog* pCtg, const char *dbFName, int64_t dbId, const char *stbName, uint64_t suid, bool syncOp) {
+int32_t ctgDropStbMetaEnqueue(SCatalog *pCtg, const char *dbFName, int64_t dbId, const char *stbName, uint64_t suid,
+                              bool syncOp) {
   int32_t             code = 0;
   SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation));
   op->opId = CTG_OP_DROP_STB_META;
@@ -796,9 +735,7 @@ _return:
   CTG_RET(code);
 }
 
-
-
-int32_t ctgDropTbMetaEnqueue(SCatalog* pCtg, const char *dbFName, int64_t dbId, const char *tbName, bool syncOp) {
+int32_t ctgDropTbMetaEnqueue(SCatalog *pCtg, const char *dbFName, int64_t dbId, const char *tbName, bool syncOp) {
   int32_t             code = 0;
   SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation));
   op->opId = CTG_OP_DROP_TB_META;
@@ -827,7 +764,7 @@ _return:
   CTG_RET(code);
 }
 
-int32_t ctgUpdateVgroupEnqueue(SCatalog* pCtg, const char *dbFName, int64_t dbId, SDBVgInfo* dbInfo, bool syncOp) {
+int32_t ctgUpdateVgroupEnqueue(SCatalog *pCtg, const char *dbFName, int64_t dbId, SDBVgInfo *dbInfo, bool syncOp) {
   int32_t             code = 0;
   SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation));
   op->opId = CTG_OP_UPDATE_VGROUP;
@@ -864,7 +801,7 @@ _return:
   CTG_RET(code);
 }
 
-int32_t ctgUpdateTbMetaEnqueue(SCatalog* pCtg, STableMetaOutput *output, bool syncOp) {
+int32_t ctgUpdateTbMetaEnqueue(SCatalog *pCtg, STableMetaOutput *output, bool syncOp) {
   int32_t             code = 0;
   SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation));
   op->opId = CTG_OP_UPDATE_TB_META;
@@ -902,7 +839,7 @@ _return:
   CTG_RET(code);
 }
 
-int32_t ctgUpdateVgEpsetEnqueue(SCatalog* pCtg, char *dbFName, int32_t vgId, SEpSet* pEpSet) {
+int32_t ctgUpdateVgEpsetEnqueue(SCatalog *pCtg, char *dbFName, int32_t vgId, SEpSet *pEpSet) {
   int32_t             code = 0;
   SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation));
   op->opId = CTG_OP_UPDATE_VG_EPSET;
@@ -931,9 +868,7 @@ _return:
   CTG_RET(code);
 }
 
-
-
-int32_t ctgUpdateUserEnqueue(SCatalog* pCtg, SGetUserAuthRsp *pAuth, bool syncOp) {
+int32_t ctgUpdateUserEnqueue(SCatalog *pCtg, SGetUserAuthRsp *pAuth, bool syncOp) {
   int32_t             code = 0;
   SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation));
   op->opId = CTG_OP_UPDATE_USER;
@@ -962,7 +897,7 @@ _return:
   CTG_RET(code);
 }
 
-int32_t ctgUpdateTbIndexEnqueue(SCatalog* pCtg, STableIndex **pIndex, bool syncOp) {
+int32_t ctgUpdateTbIndexEnqueue(SCatalog *pCtg, STableIndex **pIndex, bool syncOp) {
   int32_t             code = 0;
   SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation));
   op->opId = CTG_OP_UPDATE_TB_INDEX;
@@ -993,7 +928,7 @@ _return:
   CTG_RET(code);
 }
 
-int32_t ctgDropTbIndexEnqueue(SCatalog* pCtg, SName* pName, bool syncOp) {
+int32_t ctgDropTbIndexEnqueue(SCatalog *pCtg, SName *pName, bool syncOp) {
   int32_t             code = 0;
   SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation));
   op->opId = CTG_OP_DROP_TB_INDEX;
@@ -1022,8 +957,7 @@ _return:
   CTG_RET(code);
 }
 
-
-int32_t ctgClearCacheEnqueue(SCatalog* pCtg, bool freeCtg, bool stopQueue, bool syncOp) {
+int32_t ctgClearCacheEnqueue(SCatalog *pCtg, bool freeCtg, bool stopQueue, bool syncOp) {
   int32_t             code = 0;
   SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation));
   op->opId = CTG_OP_CLEAR_CACHE;
@@ -1052,7 +986,6 @@ _return:
   CTG_RET(code);
 }
 
-
 int32_t ctgMetaRentInit(SCtgRentMgmt *mgmt, uint32_t rentSec, int8_t type) {
   mgmt->slotRIdx = 0;
   mgmt->slotNum = rentSec / CTG_RENT_SLOT_SECOND;
@@ -1071,7 +1004,6 @@ int32_t ctgMetaRentInit(SCtgRentMgmt *mgmt, uint32_t rentSec, int8_t type) {
   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));
 
@@ -1082,19 +1014,20 @@ int32_t ctgMetaRentAdd(SCtgRentMgmt *mgmt, void *meta, int64_t id, int32_t size)
   if (NULL == slot->meta) {
     slot->meta = taosArrayInit(CTG_DEFAULT_RENT_SLOT_SIZE, size);
     if (NULL == slot->meta) {
-      qError("taosArrayInit %d failed, id:0x%"PRIx64", slot idx:%d, type:%d", CTG_DEFAULT_RENT_SLOT_SIZE, id, widx, mgmt->type);
+      qError("taosArrayInit %d failed, id:0x%" PRIx64 ", slot idx:%d, type:%d", CTG_DEFAULT_RENT_SLOT_SIZE, id, widx,
+             mgmt->type);
       CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY);
     }
   }
 
   if (NULL == taosArrayPush(slot->meta, meta)) {
-    qError("taosArrayPush meta to rent failed, id:0x%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type);
+    qError("taosArrayPush meta to rent failed, id:0x%" PRIx64 ", slot idx:%d, type:%d", id, widx, mgmt->type);
     CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY);
   }
 
   slot->needSort = true;
 
-  qDebug("add meta to rent, id:0x%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type);
+  qDebug("add meta to rent, id:0x%" PRIx64 ", slot idx:%d, type:%d", id, widx, mgmt->type);
 
 _return:
 
@@ -1102,7 +1035,8 @@ _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];
@@ -1110,12 +1044,13 @@ int32_t ctgMetaRentUpdate(SCtgRentMgmt *mgmt, void *meta, int64_t id, int32_t si
 
   CTG_LOCK(CTG_WRITE, &slot->lock);
   if (NULL == slot->meta) {
-    qDebug("empty meta slot, id:0x%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type);
+    qDebug("empty meta slot, id:0x%" 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));
@@ -1123,20 +1058,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) {
-    qDebug("meta not found in slot, id:0x%"PRIx64", slot idx:%d, type:%d, size:%d", id, widx, mgmt->type, (int32_t)taosArrayGetSize(slot->meta));
+    qDebug("meta not found in slot, id:0x%" 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:0x%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type);
+  qDebug("meta in rent updated, id:0x%" PRIx64 ", slot idx:%d, type:%d", id, widx, mgmt->type);
 
 _return:
 
   CTG_UNLOCK(CTG_WRITE, &slot->lock);
 
   if (code) {
-    qDebug("meta in rent update failed, will try to add it, code:%x, id:0x%"PRIx64", slot idx:%d, type:%d", code, id, widx, mgmt->type);
+    qDebug("meta in rent update failed, will try to add it, code:%x, id:0x%" PRIx64 ", slot idx:%d, type:%d", code, id,
+           widx, mgmt->type);
     CTG_RET(ctgMetaRentAdd(mgmt, meta, id, size));
   }
 
@@ -1151,7 +1088,7 @@ int32_t ctgMetaRentRemove(SCtgRentMgmt *mgmt, int64_t id, __compar_fn_t sortComp
 
   CTG_LOCK(CTG_WRITE, &slot->lock);
   if (NULL == slot->meta) {
-    qError("empty meta slot, id:0x%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type);
+    qError("empty meta slot, id:0x%" PRIx64 ", slot idx:%d, type:%d", id, widx, mgmt->type);
     CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR);
   }
 
@@ -1163,13 +1100,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:0x%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type);
+    qError("meta not found in slot, id:0x%" 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:0x%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type);
+  qDebug("meta in rent removed, id:0x%" PRIx64 ", slot idx:%d, type:%d", id, widx, mgmt->type);
 
 _return:
 
@@ -1178,7 +1115,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) {
@@ -1254,13 +1190,15 @@ int32_t ctgAddNewDBCache(SCatalog *pCtg, const char *dbFName, uint64_t dbId) {
   SCtgDBCache newDBCache = {0};
   newDBCache.dbId = dbId;
 
-  newDBCache.tbCache = taosHashInit(gCtgMgmt.cfg.maxTblCacheNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
+  newDBCache.tbCache = taosHashInit(gCtgMgmt.cfg.maxTblCacheNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY),
+                                    true, HASH_ENTRY_LOCK);
   if (NULL == newDBCache.tbCache) {
     ctgError("taosHashInit %d metaCache failed", gCtgMgmt.cfg.maxTblCacheNum);
     CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
   }
 
-  newDBCache.stbCache = taosHashInit(gCtgMgmt.cfg.maxTblCacheNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), true, HASH_ENTRY_LOCK);
+  newDBCache.stbCache = taosHashInit(gCtgMgmt.cfg.maxTblCacheNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT),
+                                     true, HASH_ENTRY_LOCK);
   if (NULL == newDBCache.stbCache) {
     ctgError("taosHashInit %d stbCache failed", gCtgMgmt.cfg.maxTblCacheNum);
     CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY);
@@ -1282,11 +1220,11 @@ int32_t ctgAddNewDBCache(SCatalog *pCtg, const char *dbFName, uint64_t dbId) {
   SDbVgVersion vgVersion = {.dbId = newDBCache.dbId, .vgVersion = -1};
   strncpy(vgVersion.dbFName, dbFName, sizeof(vgVersion.dbFName));
 
-  ctgDebug("db added to cache, dbFName:%s, dbId:0x%"PRIx64, dbFName, dbId);
+  ctgDebug("db added to cache, dbFName:%s, dbId:0x%" PRIx64, dbFName, dbId);
 
   CTG_ERR_RET(ctgMetaRentAdd(&pCtg->dbRent, &vgVersion, dbId, sizeof(SDbVgVersion)));
 
-  ctgDebug("db added to rent, dbFName:%s, vgVersion:%d, dbId:0x%"PRIx64, dbFName, vgVersion.vgVersion, dbId);
+  ctgDebug("db added to rent, dbFName:%s, vgVersion:%d, dbId:0x%" PRIx64, dbFName, vgVersion.vgVersion, dbId);
 
   return TSDB_CODE_SUCCESS;
 
@@ -1297,8 +1235,7 @@ _return:
   CTG_RET(code);
 }
 
-
-void ctgRemoveStbRent(SCatalog* pCtg, SCtgDBCache *dbCache) {
+void ctgRemoveStbRent(SCatalog *pCtg, SCtgDBCache *dbCache) {
   if (NULL == dbCache->stbCache) {
     return;
   }
@@ -1308,19 +1245,19 @@ void ctgRemoveStbRent(SCatalog* pCtg, SCtgDBCache *dbCache) {
     uint64_t *suid = NULL;
     suid = taosHashGetKey(pIter, NULL);
 
-    if (TSDB_CODE_SUCCESS == ctgMetaRentRemove(&pCtg->stbRent, *suid, ctgStbVersionSortCompare, ctgStbVersionSearchCompare)) {
-      ctgDebug("stb removed from rent, suid:0x%"PRIx64, *suid);
+    if (TSDB_CODE_SUCCESS ==
+        ctgMetaRentRemove(&pCtg->stbRent, *suid, ctgStbVersionSortCompare, ctgStbVersionSearchCompare)) {
+      ctgDebug("stb removed from rent, suid:0x%" PRIx64, *suid);
     }
 
     pIter = taosHashIterate(dbCache->stbCache, pIter);
   }
 }
 
-
-int32_t ctgRemoveDBFromCache(SCatalog* pCtg, SCtgDBCache *dbCache, const char* dbFName) {
+int32_t ctgRemoveDBFromCache(SCatalog *pCtg, SCtgDBCache *dbCache, const char *dbFName) {
   uint64_t dbId = dbCache->dbId;
 
-  ctgInfo("start to remove db from cache, dbFName:%s, dbId:0x%"PRIx64, dbFName, dbCache->dbId);
+  ctgInfo("start to remove db from cache, dbFName:%s, dbId:0x%" PRIx64, dbFName, dbCache->dbId);
 
   CTG_LOCK(CTG_WRITE, &dbCache->dbLock);
 
@@ -1331,7 +1268,7 @@ int32_t ctgRemoveDBFromCache(SCatalog* pCtg, SCtgDBCache *dbCache, const char* d
   CTG_UNLOCK(CTG_WRITE, &dbCache->dbLock);
 
   CTG_ERR_RET(ctgMetaRentRemove(&pCtg->dbRent, dbId, ctgDbVgVersionSortCompare, ctgDbVgVersionSearchCompare));
-  ctgDebug("db removed from rent, dbFName:%s, dbId:0x%"PRIx64, dbFName, dbId);
+  ctgDebug("db removed from rent, dbFName:%s, dbId:0x%" PRIx64, dbFName, dbId);
 
   if (taosHashRemove(pCtg->dbCache, dbFName, strlen(dbFName))) {
     ctgInfo("taosHashRemove from dbCache failed, may be removed, dbFName:%s", dbFName);
@@ -1339,13 +1276,12 @@ int32_t ctgRemoveDBFromCache(SCatalog* pCtg, SCtgDBCache *dbCache, const char* d
   }
 
   CTG_CACHE_STAT_DEC(numOfDb, 1);
-  ctgInfo("db removed from cache, dbFName:%s, dbId:0x%"PRIx64, dbFName, dbId);
+  ctgInfo("db removed from cache, dbFName:%s, dbId:0x%" PRIx64, dbFName, dbId);
 
   return TSDB_CODE_SUCCESS;
 }
 
-
-int32_t ctgGetAddDBCache(SCatalog* pCtg, const char *dbFName, uint64_t dbId, SCtgDBCache **pCache) {
+int32_t ctgGetAddDBCache(SCatalog *pCtg, const char *dbFName, uint64_t dbId, SCtgDBCache **pCache) {
   int32_t      code = 0;
   SCtgDBCache *dbCache = NULL;
   ctgGetDBCache(pCtg, dbFName, &dbCache);
@@ -1386,7 +1322,8 @@ int32_t ctgGetAddDBCache(SCatalog* pCtg, const char *dbFName, uint64_t dbId, SCt
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t ctgUpdateRentStbVersion(SCatalog *pCtg, char* dbFName, char* tbName, uint64_t dbId, uint64_t suid, SCtgTbCache* pCache) {
+int32_t ctgUpdateRentStbVersion(SCatalog *pCtg, char *dbFName, char *tbName, uint64_t dbId, uint64_t suid,
+                                SCtgTbCache *pCache) {
   SSTableVersion metaRent = {.dbId = dbId, .suid = suid};
   if (pCache->pMeta) {
     metaRent.sversion = pCache->pMeta->sversion;
@@ -1400,24 +1337,25 @@ int32_t ctgUpdateRentStbVersion(SCatalog *pCtg, char* dbFName, char* tbName, uin
   strcpy(metaRent.dbFName, dbFName);
   strcpy(metaRent.stbName, tbName);
 
-  CTG_ERR_RET(ctgMetaRentUpdate(&pCtg->stbRent, &metaRent, metaRent.suid, sizeof(SSTableVersion), ctgStbVersionSortCompare, ctgStbVersionSearchCompare));
+  CTG_ERR_RET(ctgMetaRentUpdate(&pCtg->stbRent, &metaRent, metaRent.suid, sizeof(SSTableVersion),
+                                ctgStbVersionSortCompare, ctgStbVersionSearchCompare));
 
-  ctgDebug("db %s,0x%" PRIx64 " stb %s,0x%" PRIx64 " sver %d tver %d smaVer %d updated to stbRent", 
-           dbFName, dbId, tbName, suid, metaRent.sversion, metaRent.tversion, metaRent.smaVer);
+  ctgDebug("db %s,0x%" PRIx64 " stb %s,0x%" PRIx64 " sver %d tver %d smaVer %d updated to stbRent", dbFName, dbId,
+           tbName, suid, metaRent.sversion, metaRent.tversion, metaRent.smaVer);
 
   return TSDB_CODE_SUCCESS;
 }
 
-
-int32_t ctgWriteTbMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFName, uint64_t dbId, char *tbName, STableMeta *meta, int32_t metaSize) {
+int32_t ctgWriteTbMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFName, uint64_t dbId, char *tbName,
+                              STableMeta *meta, int32_t metaSize) {
   if (NULL == dbCache->tbCache || NULL == dbCache->stbCache) {
     taosMemoryFree(meta);
-    ctgError("db is dropping, dbId:0x%"PRIx64, dbCache->dbId);
+    ctgError("db is dropping, dbId:0x%" PRIx64, dbCache->dbId);
     CTG_ERR_RET(TSDB_CODE_CTG_DB_DROPPED);
   }
 
   bool         isStb = meta->tableType == TSDB_SUPER_TABLE;
-  SCtgTbCache* pCache = taosHashGet(dbCache->tbCache, tbName, strlen(tbName));
+  SCtgTbCache *pCache = taosHashGet(dbCache->tbCache, tbName, strlen(tbName));
   STableMeta  *orig = (pCache ? pCache->pMeta : NULL);
   int8_t       origType = 0;
   uint64_t     origSuid = 0;
@@ -1425,7 +1363,8 @@ int32_t ctgWriteTbMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFNam
   if (orig) {
     origType = orig->tableType;
 
-    if (origType == meta->tableType && orig->uid == meta->uid && (origType == TSDB_CHILD_TABLE || (orig->sversion >= meta->sversion && orig->tversion >= meta->tversion))) {
+    if (origType == meta->tableType && orig->uid == meta->uid &&
+        (origType == TSDB_CHILD_TABLE || (orig->sversion >= meta->sversion && orig->tversion >= meta->tversion))) {
       taosMemoryFree(meta);
       ctgDebug("ignore table %s meta update", tbName);
       return TSDB_CODE_SUCCESS;
@@ -1433,10 +1372,10 @@ int32_t ctgWriteTbMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFNam
 
     if (origType == TSDB_SUPER_TABLE) {
       if (taosHashRemove(dbCache->stbCache, &orig->suid, sizeof(orig->suid))) {
-        ctgError("stb not exist in stbCache, dbFName:%s, stb:%s, suid:0x%"PRIx64, dbFName, tbName, orig->suid);
+        ctgError("stb not exist in stbCache, dbFName:%s, stb:%s, suid:0x%" PRIx64, dbFName, tbName, orig->suid);
       } else {
         CTG_CACHE_STAT_DEC(numOfStb, 1);
-        ctgDebug("stb removed from stbCache, dbFName:%s, stb:%s, suid:0x%"PRIx64, dbFName, tbName, orig->suid);
+        ctgDebug("stb removed from stbCache, dbFName:%s, stb:%s, suid:0x%" PRIx64, dbFName, tbName, orig->suid);
       }
 
       origSuid = orig->suid;
@@ -1469,31 +1408,33 @@ int32_t ctgWriteTbMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFNam
     return TSDB_CODE_SUCCESS;
   }
 
-  if (origSuid != meta->suid && taosHashPut(dbCache->stbCache, &meta->suid, sizeof(meta->suid), tbName, strlen(tbName) + 1) != 0) {
-    ctgError("taosHashPut to stable cache failed, suid:0x%"PRIx64, meta->suid);
+  if (origSuid != meta->suid &&
+      taosHashPut(dbCache->stbCache, &meta->suid, sizeof(meta->suid), tbName, strlen(tbName) + 1) != 0) {
+    ctgError("taosHashPut to stable cache failed, suid:0x%" PRIx64, meta->suid);
     CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
   }
 
   CTG_CACHE_STAT_INC(numOfStb, 1);
 
-  ctgDebug("stb 0x%" PRIx64 " updated to cache, dbFName:%s, tbName:%s, tbType:%d", meta->suid, dbFName, tbName, meta->tableType);
+  ctgDebug("stb 0x%" PRIx64 " updated to cache, dbFName:%s, tbName:%s, tbType:%d", meta->suid, dbFName, tbName,
+           meta->tableType);
 
   CTG_ERR_RET(ctgUpdateRentStbVersion(pCtg, dbFName, tbName, dbId, meta->suid, pCache));
 
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t ctgWriteTbIndexToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char* dbFName, char *tbName, STableIndex **index) {
+int32_t ctgWriteTbIndexToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFName, char *tbName, STableIndex **index) {
   if (NULL == dbCache->tbCache) {
     ctgFreeSTableIndex(*index);
     taosMemoryFreeClear(*index);
-    ctgError("db is dropping, dbId:0x%"PRIx64, dbCache->dbId);
+    ctgError("db is dropping, dbId:0x%" PRIx64, dbCache->dbId);
     CTG_ERR_RET(TSDB_CODE_CTG_DB_DROPPED);
   }
 
-  STableIndex* pIndex = *index;
+  STableIndex *pIndex = *index;
   uint64_t     suid = pIndex->suid;
-  SCtgTbCache* pCache = taosHashGet(dbCache->tbCache, tbName, strlen(tbName));
+  SCtgTbCache *pCache = taosHashGet(dbCache->tbCache, tbName, strlen(tbName));
   if (NULL == pCache) {
     SCtgTbCache cache = {0};
     cache.pIndex = pIndex;
@@ -1506,7 +1447,8 @@ int32_t ctgWriteTbIndexToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char* dbFNa
     }
 
     *index = NULL;
-    ctgDebug("table %s index updated to cache, ver:%d, num:%d", tbName, pIndex->version, (int32_t)taosArrayGetSize(pIndex->pIndex));
+    ctgDebug("table %s index updated to cache, ver:%d, num:%d", tbName, pIndex->version,
+             (int32_t)taosArrayGetSize(pIndex->pIndex));
 
     if (suid) {
       CTG_ERR_RET(ctgUpdateRentStbVersion(pCtg, dbFName, tbName, dbCache->dbId, pIndex->suid, &cache));
@@ -1526,7 +1468,8 @@ int32_t ctgWriteTbIndexToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char* dbFNa
   pCache->pIndex = pIndex;
   *index = NULL;
 
-  ctgDebug("table %s index updated to cache, ver:%d, num:%d", tbName, pIndex->version, (int32_t)taosArrayGetSize(pIndex->pIndex));
+  ctgDebug("table %s index updated to cache, ver:%d, num:%d", tbName, pIndex->version,
+           (int32_t)taosArrayGetSize(pIndex->pIndex));
 
   if (suid) {
     CTG_ERR_RET(ctgUpdateRentStbVersion(pCtg, dbFName, tbName, dbCache->dbId, suid, pCache));
@@ -1535,8 +1478,8 @@ int32_t ctgWriteTbIndexToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char* dbFNa
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t ctgUpdateTbMetaToCache(SCatalog* pCtg, STableMetaOutput* pOut, bool syncReq) {
-  STableMetaOutput* pOutput = NULL;
+int32_t ctgUpdateTbMetaToCache(SCatalog *pCtg, STableMetaOutput *pOut, bool syncReq) {
+  STableMetaOutput *pOutput = NULL;
   int32_t           code = 0;
 
   CTG_ERR_RET(ctgCloneMetaOutput(pOut, &pOutput));
@@ -1551,11 +1494,11 @@ _return:
 }
 
 void ctgClearAllInstance(void) {
-  SCatalog* pCtg = NULL;
+  SCatalog *pCtg = NULL;
 
-  void* pIter = taosHashIterate(gCtgMgmt.pCluster, NULL);
+  void *pIter = taosHashIterate(gCtgMgmt.pCluster, NULL);
   while (pIter) {
-    pCtg = *(SCatalog**)pIter;
+    pCtg = *(SCatalog **)pIter;
 
     if (pCtg) {
       ctgClearHandle(pCtg);
@@ -1566,11 +1509,11 @@ void ctgClearAllInstance(void) {
 }
 
 void ctgFreeAllInstance(void) {
-  SCatalog* pCtg = NULL;
+  SCatalog *pCtg = NULL;
 
-  void* pIter = taosHashIterate(gCtgMgmt.pCluster, NULL);
+  void *pIter = taosHashIterate(gCtgMgmt.pCluster, NULL);
   while (pIter) {
-    pCtg = *(SCatalog**)pIter;
+    pCtg = *(SCatalog **)pIter;
 
     if (pCtg) {
       ctgFreeHandle(pCtg);
@@ -1582,21 +1525,20 @@ void ctgFreeAllInstance(void) {
   taosHashClear(gCtgMgmt.pCluster);
 }
 
-
 int32_t ctgOpUpdateVgroup(SCtgCacheOperation *operation) {
   int32_t          code = 0;
   SCtgUpdateVgMsg *msg = operation->data;
-  SDBVgInfo* dbInfo = msg->dbInfo;
-  char* dbFName = msg->dbFName;
-  SCatalog* pCtg = msg->pCtg;
+  SDBVgInfo       *dbInfo = msg->dbInfo;
+  char            *dbFName = msg->dbFName;
+  SCatalog        *pCtg = msg->pCtg;
 
   if (NULL == dbInfo->vgHash) {
     goto _return;
   }
 
   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_JRET(TSDB_CODE_APP_ERROR);
   }
 
@@ -1606,7 +1548,7 @@ int32_t ctgOpUpdateVgroup(SCtgCacheOperation *operation) {
   SCtgDBCache *dbCache = NULL;
   CTG_ERR_JRET(ctgGetAddDBCache(msg->pCtg, dbFName, msg->dbId, &dbCache));
   if (NULL == dbCache) {
-    ctgInfo("conflict db update, ignore this update, dbFName:%s, dbId:0x%"PRIx64, dbFName, msg->dbId);
+    ctgInfo("conflict db update, ignore this update, dbFName:%s, dbId:0x%" PRIx64, dbFName, msg->dbId);
     CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR);
   }
 
@@ -1624,7 +1566,8 @@ int32_t ctgOpUpdateVgroup(SCtgCacheOperation *operation) {
     }
 
     if (dbInfo->vgVersion == vgInfo->vgVersion && dbInfo->numOfTable == vgInfo->numOfTable) {
-      ctgDebug("no new db vgVer or numOfTable, dbFName:%s, vgVer:%d, numOfTable:%d", dbFName, dbInfo->vgVersion, dbInfo->numOfTable);
+      ctgDebug("no new db vgVer or numOfTable, dbFName:%s, vgVer:%d, numOfTable:%d", dbFName, dbInfo->vgVersion,
+               dbInfo->numOfTable);
       ctgWUnlockVgInfo(dbCache);
 
       goto _return;
@@ -1636,14 +1579,15 @@ int32_t ctgOpUpdateVgroup(SCtgCacheOperation *operation) {
   vgCache->vgInfo = dbInfo;
   msg->dbInfo = NULL;
 
-  ctgDebug("db vgInfo updated, dbFName:%s, vgVer:%d, dbId:0x%"PRIx64, dbFName, vgVersion.vgVersion, vgVersion.dbId);
+  ctgDebug("db vgInfo updated, dbFName:%s, vgVer:%d, dbId:0x%" PRIx64, dbFName, vgVersion.vgVersion, vgVersion.dbId);
 
   ctgWUnlockVgInfo(dbCache);
 
   dbCache = NULL;
 
   strncpy(vgVersion.dbFName, dbFName, sizeof(vgVersion.dbFName));
-  CTG_ERR_RET(ctgMetaRentUpdate(&msg->pCtg->dbRent, &vgVersion, vgVersion.dbId, sizeof(SDbVgVersion), ctgDbVgVersionSortCompare, ctgDbVgVersionSearchCompare));
+  CTG_ERR_JRET(ctgMetaRentUpdate(&msg->pCtg->dbRent, &vgVersion, vgVersion.dbId, sizeof(SDbVgVersion),
+                                 ctgDbVgVersionSortCompare, ctgDbVgVersionSearchCompare));
 
 _return:
 
@@ -1656,7 +1600,7 @@ _return:
 int32_t ctgOpDropDbCache(SCtgCacheOperation *operation) {
   int32_t        code = 0;
   SCtgDropDBMsg *msg = operation->data;
-  SCatalog* pCtg = msg->pCtg;
+  SCatalog      *pCtg = msg->pCtg;
 
   SCtgDBCache *dbCache = NULL;
   ctgGetDBCache(msg->pCtg, msg->dbFName, &dbCache);
@@ -1665,7 +1609,8 @@ int32_t ctgOpDropDbCache(SCtgCacheOperation *operation) {
   }
 
   if (dbCache->dbId != msg->dbId) {
-    ctgInfo("dbId already updated, dbFName:%s, dbId:0x%"PRIx64 ", targetId:0x%"PRIx64, msg->dbFName, dbCache->dbId, msg->dbId);
+    ctgInfo("dbId already updated, dbFName:%s, dbId:0x%" PRIx64 ", targetId:0x%" PRIx64, msg->dbFName, dbCache->dbId,
+            msg->dbId);
     goto _return;
   }
 
@@ -1681,7 +1626,7 @@ _return:
 int32_t ctgOpDropDbVgroup(SCtgCacheOperation *operation) {
   int32_t              code = 0;
   SCtgDropDbVgroupMsg *msg = operation->data;
-  SCatalog* pCtg = msg->pCtg;
+  SCatalog            *pCtg = msg->pCtg;
 
   SCtgDBCache *dbCache = NULL;
   ctgGetDBCache(msg->pCtg, msg->dbFName, &dbCache);
@@ -1689,7 +1634,7 @@ int32_t ctgOpDropDbVgroup(SCtgCacheOperation *operation) {
     goto _return;
   }
 
-  CTG_ERR_RET(ctgWLockVgInfo(pCtg, dbCache));
+  CTG_ERR_JRET(ctgWLockVgInfo(pCtg, dbCache));
 
   ctgFreeVgInfo(dbCache->vgCache.vgInfo);
   dbCache->vgCache.vgInfo = NULL;
@@ -1705,12 +1650,11 @@ _return:
   CTG_RET(code);
 }
 
-
 int32_t ctgOpUpdateTbMeta(SCtgCacheOperation *operation) {
   int32_t              code = 0;
   SCtgUpdateTbMetaMsg *msg = operation->data;
-  SCatalog* pCtg = msg->pCtg;
-  STableMetaOutput* pMeta = msg->pMeta;
+  SCatalog            *pCtg = msg->pCtg;
+  STableMetaOutput    *pMeta = msg->pMeta;
   SCtgDBCache         *dbCache = NULL;
 
   if ((!CTG_IS_META_CTABLE(pMeta->metaType)) && NULL == pMeta->tbMeta) {
@@ -1731,17 +1675,19 @@ int32_t ctgOpUpdateTbMeta(SCtgCacheOperation *operation) {
 
   if (CTG_IS_META_TABLE(pMeta->metaType) || CTG_IS_META_BOTH(pMeta->metaType)) {
     int32_t metaSize = CTG_META_SIZE(pMeta->tbMeta);
-    CTG_ERR_JRET(ctgWriteTbMetaToCache(pCtg, dbCache, pMeta->dbFName, pMeta->dbId, pMeta->tbName, pMeta->tbMeta, metaSize));
+    CTG_ERR_JRET(
+        ctgWriteTbMetaToCache(pCtg, dbCache, pMeta->dbFName, pMeta->dbId, pMeta->tbName, pMeta->tbMeta, metaSize));
     pMeta->tbMeta = NULL;
   }
 
   if (CTG_IS_META_CTABLE(pMeta->metaType) || CTG_IS_META_BOTH(pMeta->metaType)) {
-    SCTableMeta* ctbMeta = taosMemoryMalloc(sizeof(SCTableMeta));
+    SCTableMeta *ctbMeta = taosMemoryMalloc(sizeof(SCTableMeta));
     if (NULL == ctbMeta) {
       CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY);
     }
     memcpy(ctbMeta, &pMeta->ctbMeta, sizeof(SCTableMeta));
-    CTG_ERR_JRET(ctgWriteTbMetaToCache(pCtg, dbCache, pMeta->dbFName, pMeta->dbId, pMeta->ctbName, (STableMeta *)ctbMeta, sizeof(SCTableMeta)));
+    CTG_ERR_JRET(ctgWriteTbMetaToCache(pCtg, dbCache, pMeta->dbFName, pMeta->dbId, pMeta->ctbName,
+                                       (STableMeta *)ctbMeta, sizeof(SCTableMeta)));
   }
 
 _return:
@@ -1756,31 +1702,31 @@ _return:
   CTG_RET(code);
 }
 
-
 int32_t ctgOpDropStbMeta(SCtgCacheOperation *operation) {
   int32_t             code = 0;
   SCtgDropStbMetaMsg *msg = operation->data;
-  SCatalog* pCtg = msg->pCtg;
+  SCatalog           *pCtg = msg->pCtg;
 
   SCtgDBCache *dbCache = NULL;
   ctgGetDBCache(pCtg, msg->dbFName, &dbCache);
   if (NULL == dbCache) {
-    return TSDB_CODE_SUCCESS;
+    goto _return;
   }
 
   if (msg->dbId && (dbCache->dbId != msg->dbId)) {
-    ctgDebug("dbId already modified, dbFName:%s, current:0x%"PRIx64", dbId:0x%"PRIx64", stb:%s, suid:0x%"PRIx64, 
+    ctgDebug("dbId already modified, dbFName:%s, current:0x%" PRIx64 ", dbId:0x%" PRIx64 ", stb:%s, suid:0x%" PRIx64,
              msg->dbFName, dbCache->dbId, msg->dbId, msg->stbName, msg->suid);
-    return TSDB_CODE_SUCCESS;
+    goto _return;
   }
 
   if (taosHashRemove(dbCache->stbCache, &msg->suid, sizeof(msg->suid))) {
-    ctgDebug("stb not exist in stbCache, may be removed, dbFName:%s, stb:%s, suid:0x%"PRIx64, msg->dbFName, msg->stbName, msg->suid);
+    ctgDebug("stb not exist in stbCache, may be removed, dbFName:%s, stb:%s, suid:0x%" PRIx64, msg->dbFName,
+             msg->stbName, msg->suid);
   } else {
     CTG_CACHE_STAT_DEC(numOfStb, 1);
   }
 
-  SCtgTbCache* pTbCache = taosHashGet(dbCache->tbCache, msg->stbName, strlen(msg->stbName));
+  SCtgTbCache *pTbCache = taosHashGet(dbCache->tbCache, msg->stbName, strlen(msg->stbName));
   if (NULL == pTbCache) {
     ctgDebug("stb %s already not in cache", msg->stbName);
     goto _return;
@@ -1791,16 +1737,16 @@ int32_t ctgOpDropStbMeta(SCtgCacheOperation *operation) {
   CTG_UNLOCK(CTG_WRITE, &pTbCache->metaLock);
 
   if (taosHashRemove(dbCache->tbCache, msg->stbName, strlen(msg->stbName))) {
-    ctgError("stb not exist in cache, dbFName:%s, stb:%s, suid:0x%"PRIx64, msg->dbFName, msg->stbName, msg->suid);
+    ctgError("stb not exist in cache, dbFName:%s, stb:%s, suid:0x%" PRIx64, msg->dbFName, msg->stbName, msg->suid);
   } else {
     CTG_CACHE_STAT_DEC(numOfTbl, 1);
   }
 
-  ctgInfo("stb removed from cache, dbFName:%s, stbName:%s, suid:0x%"PRIx64, msg->dbFName, msg->stbName, msg->suid);
+  ctgInfo("stb removed from cache, dbFName:%s, stbName:%s, suid:0x%" 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:0x%"PRIx64, msg->dbFName, msg->stbName, msg->suid);
+  ctgDebug("stb removed from rent, dbFName:%s, stbName:%s, suid:0x%" PRIx64, msg->dbFName, msg->stbName, msg->suid);
 
 _return:
 
@@ -1812,7 +1758,7 @@ _return:
 int32_t ctgOpDropTbMeta(SCtgCacheOperation *operation) {
   int32_t             code = 0;
   SCtgDropTblMetaMsg *msg = operation->data;
-  SCatalog* pCtg = msg->pCtg;
+  SCatalog           *pCtg = msg->pCtg;
 
   SCtgDBCache *dbCache = NULL;
   ctgGetDBCache(pCtg, msg->dbFName, &dbCache);
@@ -1821,11 +1767,12 @@ int32_t ctgOpDropTbMeta(SCtgCacheOperation *operation) {
   }
 
   if (dbCache->dbId != msg->dbId) {
-    ctgDebug("dbId 0x%" PRIx64 " not match with curId 0x%"PRIx64", dbFName:%s, tbName:%s", msg->dbId, dbCache->dbId, msg->dbFName, msg->tbName);
+    ctgDebug("dbId 0x%" PRIx64 " not match with curId 0x%" PRIx64 ", dbFName:%s, tbName:%s", msg->dbId, dbCache->dbId,
+             msg->dbFName, msg->tbName);
     goto _return;
   }
 
-  SCtgTbCache* pTbCache = taosHashGet(dbCache->tbCache, msg->tbName, strlen(msg->tbName));
+  SCtgTbCache *pTbCache = taosHashGet(dbCache->tbCache, msg->tbName, strlen(msg->tbName));
   if (NULL == pTbCache) {
     ctgDebug("tb %s already not in cache", msg->tbName);
     goto _return;
@@ -1854,7 +1801,7 @@ _return:
 int32_t ctgOpUpdateUser(SCtgCacheOperation *operation) {
   int32_t            code = 0;
   SCtgUpdateUserMsg *msg = operation->data;
-  SCatalog* pCtg = msg->pCtg;
+  SCatalog          *pCtg = msg->pCtg;
 
   SCtgUserAuth *pUser = (SCtgUserAuth *)taosHashGet(pCtg->userCache, msg->userAuth.user, strlen(msg->userAuth.user));
   if (NULL == pUser) {
@@ -1908,7 +1855,7 @@ _return:
 int32_t ctgOpUpdateEpset(SCtgCacheOperation *operation) {
   int32_t             code = 0;
   SCtgUpdateEpsetMsg *msg = operation->data;
-  SCatalog* pCtg = msg->pCtg;
+  SCatalog           *pCtg = msg->pCtg;
 
   SCtgDBCache *dbCache = NULL;
   CTG_ERR_JRET(ctgGetDBCache(pCtg, msg->dbFName, &dbCache));
@@ -1925,17 +1872,17 @@ int32_t ctgOpUpdateEpset(SCtgCacheOperation *operation) {
     goto _return;
   }
 
-  SVgroupInfo* pInfo = taosHashGet(vgInfo->vgHash, &msg->vgId, sizeof(msg->vgId));
+  SVgroupInfo *pInfo = taosHashGet(vgInfo->vgHash, &msg->vgId, sizeof(msg->vgId));
   if (NULL == pInfo) {
     ctgDebug("no vgroup %d in db %s, ignore epset update", msg->vgId, msg->dbFName);
     goto _return;
   }
 
-  SEp* pOrigEp = &pInfo->epSet.eps[pInfo->epSet.inUse];
-  SEp* pNewEp = &msg->epSet.eps[msg->epSet.inUse];
-  ctgDebug("vgroup %d epset updated from %d/%d=>%s:%d to %d/%d=>%s:%d, dbFName:%s in ctg", 
-          pInfo->vgId, pInfo->epSet.inUse, pInfo->epSet.numOfEps, pOrigEp->fqdn, pOrigEp->port, 
-          msg->epSet.inUse, msg->epSet.numOfEps, pNewEp->fqdn, pNewEp->port, msg->dbFName);
+  SEp *pOrigEp = &pInfo->epSet.eps[pInfo->epSet.inUse];
+  SEp *pNewEp = &msg->epSet.eps[msg->epSet.inUse];
+  ctgDebug("vgroup %d epset updated from %d/%d=>%s:%d to %d/%d=>%s:%d, dbFName:%s in ctg", pInfo->vgId,
+           pInfo->epSet.inUse, pInfo->epSet.numOfEps, pOrigEp->fqdn, pOrigEp->port, msg->epSet.inUse,
+           msg->epSet.numOfEps, pNewEp->fqdn, pNewEp->port, msg->dbFName);
 
   pInfo->epSet = msg->epSet;
 
@@ -1953,8 +1900,8 @@ _return:
 int32_t ctgOpUpdateTbIndex(SCtgCacheOperation *operation) {
   int32_t               code = 0;
   SCtgUpdateTbIndexMsg *msg = operation->data;
-  SCatalog* pCtg = msg->pCtg;
-  STableIndex* pIndex = msg->pIndex;
+  SCatalog             *pCtg = msg->pCtg;
+  STableIndex          *pIndex = msg->pIndex;
   SCtgDBCache          *dbCache = NULL;
 
   CTG_ERR_JRET(ctgGetAddDBCache(pCtg, pIndex->dbFName, 0, &dbCache));
@@ -1976,7 +1923,7 @@ _return:
 int32_t ctgOpDropTbIndex(SCtgCacheOperation *operation) {
   int32_t             code = 0;
   SCtgDropTbIndexMsg *msg = operation->data;
-  SCatalog* pCtg = msg->pCtg;
+  SCatalog           *pCtg = msg->pCtg;
   SCtgDBCache        *dbCache = NULL;
 
   CTG_ERR_JRET(ctgGetDBCache(pCtg, msg->dbFName, &dbCache));
@@ -1984,7 +1931,7 @@ int32_t ctgOpDropTbIndex(SCtgCacheOperation *operation) {
     return TSDB_CODE_SUCCESS;
   }
 
-  STableIndex* pIndex = taosMemoryCalloc(1, sizeof(STableIndex));
+  STableIndex *pIndex = taosMemoryCalloc(1, sizeof(STableIndex));
   if (NULL == pIndex) {
     CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY);
   }
@@ -2006,11 +1953,10 @@ _return:
   CTG_RET(code);
 }
 
-
 int32_t ctgOpClearCache(SCtgCacheOperation *operation) {
   int32_t            code = 0;
   SCtgClearCacheMsg *msg = operation->data;
-  SCatalog* pCtg = msg->pCtg;
+  SCatalog          *pCtg = msg->pCtg;
 
   CTG_LOCK(CTG_WRITE, &gCtgMgmt.lock);
 
@@ -2085,7 +2031,7 @@ void ctgCleanupCacheQueue(void) {
   gCtgMgmt.queue.tail = NULL;
 }
 
-void* ctgUpdateThreadFunc(void* param) {
+void *ctgUpdateThreadFunc(void *param) {
   setThreadName("catalog");
 
   qInfo("catalog update thread started");
@@ -2095,7 +2041,7 @@ void* ctgUpdateThreadFunc(void* param) {
       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)) {
       ctgCleanupCacheQueue();
       break;
     }
@@ -2125,7 +2071,6 @@ void* ctgUpdateThreadFunc(void* param) {
   return NULL;
 }
 
-
 int32_t ctgStartUpdateThread() {
   TdThreadAttr thAttr;
   taosThreadAttrInit(&thAttr);
@@ -2140,8 +2085,7 @@ int32_t ctgStartUpdateThread() {
   return TSDB_CODE_SUCCESS;
 }
 
-
-int32_t ctgGetTbMetaFromCache(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgTbMetaCtx* ctx, STableMeta** pTableMeta) {
+int32_t ctgGetTbMetaFromCache(SCatalog *pCtg, SRequestConnInfo *pConn, SCtgTbMetaCtx *ctx, STableMeta **pTableMeta) {
   if (IS_SYS_DBNAME(ctx->pName->dbname)) {
     CTG_FLAG_SET_SYS_DB(ctx->flag);
   }
@@ -2221,13 +2165,14 @@ int32_t ctgGetTbMetaBFromCache(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgTbMe
 }
 #endif
 
-int32_t ctgGetTbMetasFromCache(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgTbMetasCtx* ctx, int32_t dbIdx, int32_t *fetchIdx, int32_t baseResIdx, SArray* pList) {
+int32_t ctgGetTbMetasFromCache(SCatalog *pCtg, SRequestConnInfo *pConn, SCtgTbMetasCtx *ctx, int32_t dbIdx,
+                               int32_t *fetchIdx, int32_t baseResIdx, SArray *pList) {
   int32_t     tbNum = taosArrayGetSize(pList);
-  SName* pName = taosArrayGet(pList, 0);
+  SName      *pName = taosArrayGet(pList, 0);
   char        dbFName[TSDB_DB_FNAME_LEN] = {0};
   int32_t     flag = CTG_FLAG_UNKNOWN_STB;
   uint64_t    lastSuid = 0;
-  STableMeta* lastTableMeta = NULL;
+  STableMeta *lastTableMeta = NULL;
 
   if (IS_SYS_DBNAME(pName->dbname)) {
     CTG_FLAG_SET_SYS_DB(flag);
@@ -2237,7 +2182,7 @@ int32_t ctgGetTbMetasFromCache(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgTbMe
   }
 
   SCtgDBCache *dbCache = NULL;
-  SCtgTbCache* pCache = NULL;
+  SCtgTbCache *pCache = NULL;
   ctgAcquireDBCache(pCtg, dbFName, &dbCache);
 
   if (NULL == dbCache) {
@@ -2251,7 +2196,7 @@ int32_t ctgGetTbMetasFromCache(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgTbMe
   }
 
   for (int32_t i = 0; i < tbNum; ++i) {
-    SName* pName = taosArrayGet(pList, i);
+    SName *pName = taosArrayGet(pList, i);
 
     pCache = taosHashAcquire(dbCache->tbCache, pName->tname, strlen(pName->tname));
     if (NULL == pCache) {
@@ -2271,7 +2216,7 @@ int32_t ctgGetTbMetasFromCache(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgTbMe
       continue;
     }
 
-    STableMeta* tbMeta = pCache->pMeta;
+    STableMeta *tbMeta = pCache->pMeta;
 
     SCtgTbMetaCtx nctx = {0};
     nctx.flag = flag;
@@ -2281,7 +2226,7 @@ int32_t ctgGetTbMetasFromCache(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgTbMe
     nctx.tbInfo.tbType = tbMeta->tableType;
 
     SMetaRes    res = {0};
-    STableMeta* pTableMeta = NULL;
+    STableMeta *pTableMeta = NULL;
     if (tbMeta->tableType != TSDB_CHILD_TABLE) {
       int32_t metaSize = CTG_META_SIZE(tbMeta);
       pTableMeta = taosMemoryCalloc(1, metaSize);
@@ -2332,10 +2277,10 @@ int32_t ctgGetTbMetasFromCache(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgTbMe
     CTG_UNLOCK(CTG_READ, &pCache->metaLock);
     taosHashRelease(dbCache->tbCache, pCache);
 
-    ctgDebug("Got ctb %s meta from cache, will continue to get its stb meta, type:%d, dbFName:%s", 
-             pName->tname, nctx.tbInfo.tbType, dbFName);
+    ctgDebug("Got ctb %s meta from cache, will continue to get its stb meta, type:%d, dbFName:%s", pName->tname,
+             nctx.tbInfo.tbType, dbFName);
 
-    char* stName = taosHashAcquire(dbCache->stbCache, &pTableMeta->suid, sizeof(pTableMeta->suid));
+    char *stName = taosHashAcquire(dbCache->stbCache, &pTableMeta->suid, sizeof(pTableMeta->suid));
     if (NULL == stName) {
       ctgDebug("stb 0x%" PRIx64 " not in cache, dbFName:%s", pTableMeta->suid, dbFName);
       ctgAddFetch(&ctx->pFetchs, dbIdx, i, fetchIdx, baseResIdx + i, flag);
@@ -2373,12 +2318,13 @@ int32_t ctgGetTbMetasFromCache(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgTbMe
       continue;
     }
 
-    STableMeta* stbMeta = pCache->pMeta;
+    STableMeta *stbMeta = pCache->pMeta;
     if (stbMeta->suid != nctx.tbInfo.suid) {
       CTG_UNLOCK(CTG_READ, &pCache->metaLock);
       taosHashRelease(dbCache->tbCache, pCache);
 
-      ctgError("stb suid 0x%" PRIx64 " in stbCache mis-match, expected suid 0x%"PRIx64 , stbMeta->suid, nctx.tbInfo.suid);
+      ctgError("stb suid 0x%" PRIx64 " in stbCache mis-match, expected suid 0x%" PRIx64, stbMeta->suid,
+               nctx.tbInfo.suid);
 
       ctgAddFetch(&ctx->pFetchs, dbIdx, i, fetchIdx, baseResIdx + i, flag);
       taosArraySetSize(ctx->pResList, taosArrayGetSize(ctx->pResList) + 1);
@@ -2412,10 +2358,9 @@ int32_t ctgGetTbMetasFromCache(SCatalog* pCtg, SRequestConnInfo *pConn, SCtgTbMe
   return TSDB_CODE_SUCCESS;
 }
 
-
-int32_t ctgRemoveTbMetaFromCache(SCatalog* pCtg, SName* pTableName, bool syncReq) {
+int32_t ctgRemoveTbMetaFromCache(SCatalog *pCtg, SName *pTableName, bool syncReq) {
   int32_t       code = 0;
-  STableMeta*   tblMeta = NULL;
+  STableMeta   *tblMeta = NULL;
   SCtgTbMetaCtx tbCtx = {0};
   tbCtx.flag = CTG_FLAG_UNKNOWN_STB;
   tbCtx.pName = pTableName;
@@ -2449,7 +2394,7 @@ int32_t ctgGetTbHashVgroupFromCache(SCatalog *pCtg, const SName *pTableName, SVg
     CTG_ERR_RET(TSDB_CODE_CTG_INVALID_INPUT);
   }
 
-  SCtgDBCache* dbCache = NULL;
+  SCtgDBCache *dbCache = NULL;
   int32_t      code = 0;
   char         dbFName[TSDB_DB_FNAME_LEN] = {0};
   tNameGetFullDbName(pTableName, dbFName);
@@ -2476,5 +2421,3 @@ _return:
 
   CTG_RET(code);
 }
-
-