From 0ebd3281c504013a92132e276fb85efd4cddf621 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Tue, 23 Aug 2022 18:26:27 +0800
Subject: [PATCH 1/8] enh: update table meta after creating table

---
 include/common/tmsg.h                   | 48 +++++++++-----
 source/client/inc/clientInt.h           |  5 +-
 source/client/src/clientImpl.c          | 35 ++++++----
 source/client/src/clientMsgHandler.c    | 27 +++++++-
 source/common/src/tmsg.c                | 87 +++++++++++++++++++++++--
 source/dnode/mnode/impl/inc/mndStb.h    |  1 +
 source/dnode/mnode/impl/src/mndStb.c    | 61 +++++++++++++++++
 source/dnode/mnode/impl/src/mndTrans.c  | 25 ++++---
 source/dnode/vnode/src/inc/vnodeInt.h   |  2 +-
 source/dnode/vnode/src/meta/metaTable.c | 17 ++++-
 source/dnode/vnode/src/vnd/vnodeSvr.c   | 11 +++-
 source/libs/qcom/src/queryUtil.c        |  5 ++
 source/libs/scheduler/src/schRemote.c   | 15 ++++-
 13 files changed, 285 insertions(+), 54 deletions(-)

diff --git a/include/common/tmsg.h b/include/common/tmsg.h
index 8f199c72f7..ae6f034df5 100644
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@@ -441,6 +441,25 @@ static FORCE_INLINE int32_t tDecodeSSchemaWrapperEx(SDecoder* pDecoder, SSchemaW
 
 STSchema* tdGetSTSChemaFromSSChema(SSchema* pSchema, int32_t nCols, int32_t sver);
 
+
+typedef struct {
+  char     tbName[TSDB_TABLE_NAME_LEN];
+  char     stbName[TSDB_TABLE_NAME_LEN];
+  char     dbFName[TSDB_DB_FNAME_LEN];
+  int64_t  dbId;
+  int32_t  numOfTags;
+  int32_t  numOfColumns;
+  int8_t   precision;
+  int8_t   tableType;
+  int32_t  sversion;
+  int32_t  tversion;
+  uint64_t suid;
+  uint64_t tuid;
+  int32_t  vgId;
+  SSchema* pSchemas;
+} STableMetaRsp;
+
+
 typedef struct {
   char     name[TSDB_TABLE_FNAME_LEN];
   int8_t   igExists;
@@ -472,6 +491,14 @@ int32_t tSerializeSMCreateStbReq(void* buf, int32_t bufLen, SMCreateStbReq* pReq
 int32_t tDeserializeSMCreateStbReq(void* buf, int32_t bufLen, SMCreateStbReq* pReq);
 void    tFreeSMCreateStbReq(SMCreateStbReq* pReq);
 
+typedef struct {
+  STableMetaRsp* pMeta;
+} SMCreateStbRsp;
+
+int32_t tEncodeSMCreateStbRsp(SEncoder* pEncoder, const SMCreateStbRsp* pRsp);
+int32_t tDecodeSMCreateStbRsp(SDecoder* pDecoder, SMCreateStbRsp* pRsp);
+void    tFreeSMCreateStbRsp(SMCreateStbRsp* pRsp);
+
 typedef struct {
   char     name[TSDB_TABLE_FNAME_LEN];
   int8_t   igNotExists;
@@ -1239,23 +1266,6 @@ typedef struct {
   SVgroupInfo vgroups[];
 } SVgroupsInfo;
 
-typedef struct {
-  char     tbName[TSDB_TABLE_NAME_LEN];
-  char     stbName[TSDB_TABLE_NAME_LEN];
-  char     dbFName[TSDB_DB_FNAME_LEN];
-  int64_t  dbId;
-  int32_t  numOfTags;
-  int32_t  numOfColumns;
-  int8_t   precision;
-  int8_t   tableType;
-  int32_t  sversion;
-  int32_t  tversion;
-  uint64_t suid;
-  uint64_t tuid;
-  int32_t  vgId;
-  SSchema* pSchemas;
-} STableMetaRsp;
-
 typedef struct {
   STableMetaRsp* pMeta;
 } SMAlterStbRsp;
@@ -2028,11 +2038,13 @@ int tEncodeSVCreateTbBatchReq(SEncoder* pCoder, const SVCreateTbBatchReq* pReq);
 int tDecodeSVCreateTbBatchReq(SDecoder* pCoder, SVCreateTbBatchReq* pReq);
 
 typedef struct {
-  int32_t code;
+  int32_t        code;
+  STableMetaRsp* pMeta;
 } SVCreateTbRsp, SVUpdateTbRsp;
 
 int tEncodeSVCreateTbRsp(SEncoder* pCoder, const SVCreateTbRsp* pRsp);
 int tDecodeSVCreateTbRsp(SDecoder* pCoder, SVCreateTbRsp* pRsp);
+void tFreeSVCreateTbRsp(void* param);
 
 int32_t tSerializeSVCreateTbReq(void** buf, SVCreateTbReq* pReq);
 void*   tDeserializeSVCreateTbReq(void* buf, SVCreateTbReq* pReq);
diff --git a/source/client/inc/clientInt.h b/source/client/inc/clientInt.h
index f275ae0885..de91703f82 100644
--- a/source/client/inc/clientInt.h
+++ b/source/client/inc/clientInt.h
@@ -363,8 +363,9 @@ void         launchAsyncQuery(SRequestObj* pRequest, SQuery* pQuery, SMetaData*
 int32_t      refreshMeta(STscObj* pTscObj, SRequestObj* pRequest);
 int32_t      updateQnodeList(SAppInstInfo* pInfo, SArray* pNodeList);
 void         doAsyncQuery(SRequestObj* pRequest, bool forceUpdateMeta);
-int32_t      removeMeta(STscObj* pTscObj, SArray* tbList);  // todo move to clientImpl.c and become a static function
-int32_t      handleAlterTbExecRes(void* res, struct SCatalog* pCatalog);  // todo move to xxx
+int32_t      removeMeta(STscObj* pTscObj, SArray* tbList);  
+int32_t      handleAlterTbExecRes(void* res, struct SCatalog* pCatalog);
+int32_t      handleCreateTbExecRes(void* res, SCatalog* pCatalog);
 bool         qnodeRequired(SRequestObj* pRequest);
 
 #ifdef __cplusplus
diff --git a/source/client/src/clientImpl.c b/source/client/src/clientImpl.c
index 5f0af55d13..df3e82a05e 100644
--- a/source/client/src/clientImpl.c
+++ b/source/client/src/clientImpl.c
@@ -780,6 +780,10 @@ int32_t handleAlterTbExecRes(void* res, SCatalog* pCatalog) {
   return catalogUpdateTableMeta(pCatalog, (STableMetaRsp*)res);
 }
 
+int32_t handleCreateTbExecRes(void* res, SCatalog* pCatalog) {
+  return catalogUpdateTableMeta(pCatalog, (STableMetaRsp*)res);
+}
+
 int32_t handleQueryExecRsp(SRequestObj* pRequest) {
   if (NULL == pRequest->body.resInfo.execRes.res) {
     return TSDB_CODE_SUCCESS;
@@ -802,6 +806,19 @@ int32_t handleQueryExecRsp(SRequestObj* pRequest) {
       code = handleAlterTbExecRes(pRes->res, pCatalog);
       break;
     }
+    case TDMT_VND_CREATE_TABLE: {
+      SArray* pList = (SArray*)pRes->res;
+      int32_t num = taosArrayGetSize(pList);
+      for (int32_t i = 0; i < num; ++i) {
+        void* res = taosArrayGetP(pList, i);
+        code = handleCreateTbExecRes(res, pCatalog);
+      }
+      break;
+    }
+    case TDMT_MND_CREATE_STB: {
+      code = handleCreateTbExecRes(pRes->res, pCatalog);
+      break;
+    }
     case TDMT_VND_SUBMIT: {
       atomic_add_fetch_64((int64_t*)&pAppInfo->summary.insertBytes, pRes->numOfBytes);
 
@@ -859,17 +876,13 @@ void schedulerExecCb(SExecResult* pResult, void* param, int32_t code) {
     return;
   }
 
-  if (code == TSDB_CODE_SUCCESS) {
-    code = handleQueryExecRsp(pRequest);
-    ASSERT(pRequest->code == TSDB_CODE_SUCCESS);
-    pRequest->code = code;
-  }
-
   tscDebug("schedulerExecCb request type %s", TMSG_INFO(pRequest->type));
-  if (NEED_CLIENT_RM_TBLMETA_REQ(pRequest->type)) {
+  if (NEED_CLIENT_RM_TBLMETA_REQ(pRequest->type) && NULL == pRequest->body.resInfo.execRes.res) {
     removeMeta(pTscObj, pRequest->targetTableList);
   }
 
+  handleQueryExecRsp(pRequest);
+
   // return to client
   pRequest->body.queryFp(pRequest->body.param, pRequest, code);
 }
@@ -930,6 +943,10 @@ SRequestObj* launchQueryImpl(SRequestObj* pRequest, SQuery* pQuery, bool keepQue
     qDestroyQuery(pQuery);
   }
 
+  if (NEED_CLIENT_RM_TBLMETA_REQ(pRequest->type) && NULL == pRequest->body.resInfo.execRes.res) {
+    removeMeta(pRequest->pTscObj, pRequest->targetTableList);
+  }
+
   handleQueryExecRsp(pRequest);
 
   if (NULL != pRequest && TSDB_CODE_SUCCESS != code) {
@@ -1127,10 +1144,6 @@ SRequestObj* execQuery(uint64_t connId, const char* sql, int sqlLen, bool valida
     inRetry = true;
   } while (retryNum++ < REQUEST_TOTAL_EXEC_TIMES);
 
-  if (NEED_CLIENT_RM_TBLMETA_REQ(pRequest->type)) {
-    removeMeta(pRequest->pTscObj, pRequest->targetTableList);
-  }
-
   return pRequest;
 }
 
diff --git a/source/client/src/clientMsgHandler.c b/source/client/src/clientMsgHandler.c
index 0c4cf23c4e..68aeb68ee0 100644
--- a/source/client/src/clientMsgHandler.c
+++ b/source/client/src/clientMsgHandler.c
@@ -232,13 +232,36 @@ int32_t processCreateSTableRsp(void* param, SDataBuf* pMsg, int32_t code) {
   assert(pMsg != NULL && param != NULL);
   SRequestObj* pRequest = param;
 
-  taosMemoryFree(pMsg->pData);
   if (code != TSDB_CODE_SUCCESS) {
     setErrno(pRequest, code);
+  } else {
+    SMCreateStbRsp createRsp = {0};
+    SDecoder      coder = {0};
+    tDecoderInit(&coder, pMsg->pData, pMsg->len);
+    tDecodeSMCreateStbRsp(&coder, &createRsp);
+    tDecoderClear(&coder);
+
+    pRequest->body.resInfo.execRes.msgType = TDMT_MND_CREATE_STB;
+    pRequest->body.resInfo.execRes.res = createRsp.pMeta;
   }
 
+  taosMemoryFree(pMsg->pData);
+
   if (pRequest->body.queryFp != NULL) {
-    removeMeta(pRequest->pTscObj, pRequest->tableList);
+    SExecResult* pRes = &pRequest->body.resInfo.execRes;
+
+    if (code == TSDB_CODE_SUCCESS) {
+      SCatalog* pCatalog = NULL;
+      int32_t   ret = catalogGetHandle(pRequest->pTscObj->pAppInfo->clusterId, &pCatalog);
+      if (pRes->res != NULL) {
+        ret = handleCreateTbExecRes(pRes->res, pCatalog);
+      }
+
+      if (ret != TSDB_CODE_SUCCESS) {
+        code = ret;
+      }
+    }
+    
     pRequest->body.queryFp(pRequest->body.param, pRequest, code);
   } else {
     tsem_post(&pRequest->body.rspSem);
diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c
index 533d924546..3ceb9ca192 100644
--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@@ -3196,12 +3196,16 @@ static int32_t tDecodeSTableMetaRsp(SDecoder *pDecoder, STableMetaRsp *pRsp) {
   if (tDecodeI32(pDecoder, &pRsp->vgId) < 0) return -1;
 
   int32_t totalCols = pRsp->numOfTags + pRsp->numOfColumns;
-  pRsp->pSchemas = taosMemoryMalloc(sizeof(SSchema) * totalCols);
-  if (pRsp->pSchemas == NULL) return -1;
+  if (totalCols > 0) {
+    pRsp->pSchemas = taosMemoryMalloc(sizeof(SSchema) * totalCols);
+    if (pRsp->pSchemas == NULL) return -1;
 
-  for (int32_t i = 0; i < totalCols; ++i) {
-    SSchema *pSchema = &pRsp->pSchemas[i];
-    if (tDecodeSSchema(pDecoder, pSchema) < 0) return -1;
+    for (int32_t i = 0; i < totalCols; ++i) {
+      SSchema *pSchema = &pRsp->pSchemas[i];
+      if (tDecodeSSchema(pDecoder, pSchema) < 0) return -1;
+    }
+  } else {
+    pRsp->pSchemas = NULL;
   }
 
   return 0;
@@ -5090,6 +5094,10 @@ int tEncodeSVCreateTbRsp(SEncoder *pCoder, const SVCreateTbRsp *pRsp) {
   if (tStartEncode(pCoder) < 0) return -1;
 
   if (tEncodeI32(pCoder, pRsp->code) < 0) return -1;
+  if (tEncodeI32(pCoder, pRsp->pMeta ? 1 : 0) < 0) return -1;
+  if (pRsp->pMeta) {
+    if (tEncodeSTableMetaRsp(pCoder, pRsp->pMeta) < 0) return -1;
+  }
 
   tEndEncode(pCoder);
   return 0;
@@ -5100,10 +5108,25 @@ int tDecodeSVCreateTbRsp(SDecoder *pCoder, SVCreateTbRsp *pRsp) {
 
   if (tDecodeI32(pCoder, &pRsp->code) < 0) return -1;
 
+  int32_t meta = 0;
+  if (tDecodeI32(pCoder, &meta) < 0) return -1;
+  if (meta) {
+    pRsp->pMeta = taosMemoryCalloc(1, sizeof(STableMetaRsp));
+    if (NULL == pRsp->pMeta) return -1;
+    if (tDecodeSTableMetaRsp(pCoder, pRsp->pMeta) < 0) return -1;
+  } else {
+    pRsp->pMeta = NULL;
+  }
+  
   tEndDecode(pCoder);
   return 0;
 }
 
+void tFreeSVCreateTbRsp(void* param) {
+  SVCreateTbRsp* pRsp = (SVCreateTbRsp*)param;
+  taosMemoryFree(pRsp->pMeta);
+}
+
 // TDMT_VND_DROP_TABLE =================
 static int32_t tEncodeSVDropTbReq(SEncoder *pCoder, const SVDropTbReq *pReq) {
   if (tStartEncode(pCoder) < 0) return -1;
@@ -5558,6 +5581,60 @@ void tFreeSMAlterStbRsp(SMAlterStbRsp *pRsp) {
   }
 }
 
+
+int32_t tEncodeSMCreateStbRsp(SEncoder *pEncoder, const SMCreateStbRsp *pRsp) {
+  if (tStartEncode(pEncoder) < 0) return -1;
+  if (tEncodeI32(pEncoder, pRsp->pMeta->pSchemas ? 1 : 0) < 0) return -1;
+  if (pRsp->pMeta->pSchemas) {
+    if (tEncodeSTableMetaRsp(pEncoder, pRsp->pMeta) < 0) return -1;
+  }
+  tEndEncode(pEncoder);
+  return 0;
+}
+
+int32_t tDecodeSMCreateStbRsp(SDecoder *pDecoder, SMCreateStbRsp *pRsp) {
+  int32_t meta = 0;
+  if (tStartDecode(pDecoder) < 0) return -1;
+  if (tDecodeI32(pDecoder, &meta) < 0) return -1;
+  if (meta) {
+    pRsp->pMeta = taosMemoryCalloc(1, sizeof(STableMetaRsp));
+    if (NULL == pRsp->pMeta) return -1;
+    if (tDecodeSTableMetaRsp(pDecoder, pRsp->pMeta) < 0) return -1;
+  }
+  tEndDecode(pDecoder);
+  return 0;
+}
+
+int32_t tDeserializeSMCreateStbRsp(void *buf, int32_t bufLen, SMCreateStbRsp *pRsp) {
+  int32_t  meta = 0;
+  SDecoder decoder = {0};
+  tDecoderInit(&decoder, buf, bufLen);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeI32(&decoder, &meta) < 0) return -1;
+  if (meta) {
+    pRsp->pMeta = taosMemoryCalloc(1, sizeof(STableMetaRsp));
+    if (NULL == pRsp->pMeta) return -1;
+    if (tDecodeSTableMetaRsp(&decoder, pRsp->pMeta) < 0) return -1;
+  }
+  tEndDecode(&decoder);
+  tDecoderClear(&decoder);
+  return 0;
+}
+
+void tFreeSMCreateStbRsp(SMCreateStbRsp *pRsp) {
+  if (NULL == pRsp) {
+    return;
+  }
+
+  if (pRsp->pMeta) {
+    taosMemoryFree(pRsp->pMeta->pSchemas);
+    taosMemoryFree(pRsp->pMeta);
+  }
+}
+
+
+
 int32_t tEncodeSTqOffsetVal(SEncoder *pEncoder, const STqOffsetVal *pOffsetVal) {
   if (tEncodeI8(pEncoder, pOffsetVal->type) < 0) return -1;
   if (pOffsetVal->type == TMQ_OFFSET__SNAPSHOT_DATA) {
diff --git a/source/dnode/mnode/impl/inc/mndStb.h b/source/dnode/mnode/impl/inc/mndStb.h
index 010199a89f..8f0d55e100 100644
--- a/source/dnode/mnode/impl/inc/mndStb.h
+++ b/source/dnode/mnode/impl/inc/mndStb.h
@@ -35,6 +35,7 @@ SDbObj *mndAcquireDbByStb(SMnode *pMnode, const char *stbName);
 int32_t mndBuildStbFromReq(SMnode *pMnode, SStbObj *pDst, SMCreateStbReq *pCreate, SDbObj *pDb);
 int32_t mndAddStbToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *pStb);
 void    mndFreeStb(SStbObj *pStb);
+int32_t mndBuildSMCreateStbRsp(SMnode *pMnode, char* dbFName, char* stbFName, void **pCont, int32_t *pLen);
 
 void mndExtractDbNameFromStbFullName(const char *stbFullName, char *dst);
 void mndExtractTbNameFromStbFullName(const char *stbFullName, char *dst, int32_t dstSize);
diff --git a/source/dnode/mnode/impl/src/mndStb.c b/source/dnode/mnode/impl/src/mndStb.c
index ebec3d5ea6..b29271e455 100644
--- a/source/dnode/mnode/impl/src/mndStb.c
+++ b/source/dnode/mnode/impl/src/mndStb.c
@@ -1774,6 +1774,67 @@ static int32_t mndBuildSMAlterStbRsp(SDbObj *pDb, SStbObj *pObj, void **pCont, i
   return 0;
 }
 
+int32_t mndBuildSMCreateStbRsp(SMnode *pMnode, char* dbFName, char* stbFName, void **pCont, int32_t *pLen) {
+  int32_t       ret = -1;
+  SDbObj *pDb = mndAcquireDb(pMnode, dbFName);
+  if (NULL == pDb) {
+    return -1;
+  }
+
+  SStbObj *pObj = mndAcquireStb(pMnode, stbFName);
+  if (NULL == pObj) {
+    goto _OVER;
+  }
+  
+  SEncoder      ec = {0};
+  uint32_t      contLen = 0;
+  SMCreateStbRsp stbRsp = {0};
+  SName         name = {0};
+  tNameFromString(&name, pObj->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+
+  stbRsp.pMeta = taosMemoryCalloc(1, sizeof(STableMetaRsp));
+  if (NULL == stbRsp.pMeta) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    goto _OVER;
+  }
+
+  ret = mndBuildStbSchemaImp(pDb, pObj, name.tname, stbRsp.pMeta);
+  if (ret) {
+    tFreeSMCreateStbRsp(&stbRsp);
+    goto _OVER;
+  }
+
+  tEncodeSize(tEncodeSMCreateStbRsp, &stbRsp, contLen, ret);
+  if (ret) {
+    tFreeSMCreateStbRsp(&stbRsp);
+    goto _OVER;
+  }
+
+  void *cont = taosMemoryMalloc(contLen);
+  tEncoderInit(&ec, cont, contLen);
+  tEncodeSMCreateStbRsp(&ec, &stbRsp);
+  tEncoderClear(&ec);
+
+  tFreeSMCreateStbRsp(&stbRsp);
+
+  *pCont = cont;
+  *pLen = contLen;
+
+  ret = 0;
+  
+_OVER:
+  if (pObj) {
+    mndReleaseStb(pMnode, pObj);
+  }
+  
+  if (pDb) {
+    mndReleaseDb(pMnode, pDb);
+  }
+
+  return ret;
+}
+
+
 static int32_t mndAlterStbImp(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SStbObj *pStb, bool needRsp,
                               void *alterOriData, int32_t alterOriDataLen) {
   int32_t code = -1;
diff --git a/source/dnode/mnode/impl/src/mndTrans.c b/source/dnode/mnode/impl/src/mndTrans.c
index 17b4336465..e610fa6d27 100644
--- a/source/dnode/mnode/impl/src/mndTrans.c
+++ b/source/dnode/mnode/impl/src/mndTrans.c
@@ -17,6 +17,7 @@
 #include "mndTrans.h"
 #include "mndConsumer.h"
 #include "mndDb.h"
+#include "mndStb.h"
 #include "mndPrivilege.h"
 #include "mndShow.h"
 #include "mndSync.h"
@@ -900,15 +901,6 @@ static void mndTransSendRpcRsp(SMnode *pMnode, STrans *pTrans) {
       }
       SRpcMsg rspMsg = {.code = code, .info = *pInfo};
 
-      if (pTrans->rpcRspLen != 0) {
-        void *rpcCont = rpcMallocCont(pTrans->rpcRspLen);
-        if (rpcCont != NULL) {
-          memcpy(rpcCont, pTrans->rpcRsp, pTrans->rpcRspLen);
-          rspMsg.pCont = rpcCont;
-          rspMsg.contLen = pTrans->rpcRspLen;
-        }
-      }
-
       if (pTrans->originRpcType == TDMT_MND_CREATE_DB) {
         mDebug("trans:%d, origin msgtype:%s", pTrans->id, TMSG_INFO(pTrans->originRpcType));
         SDbObj *pDb = mndAcquireDb(pMnode, pTrans->dbname1);
@@ -924,6 +916,21 @@ static void mndTransSendRpcRsp(SMnode *pMnode, STrans *pTrans) {
           }
         }
         mndReleaseDb(pMnode, pDb);
+      } else if (pTrans->originRpcType == TDMT_MND_CREATE_STB) {
+        void   *pCont = NULL;
+        int32_t contLen = 0;
+        if (0 == mndBuildSMCreateStbRsp(pMnode, pTrans->dbname1, pTrans->dbname2, &pCont, &contLen) != 0) {
+          mndTransSetRpcRsp(pTrans, pCont, contLen);
+        }
+      }
+
+      if (pTrans->rpcRspLen != 0) {
+        void *rpcCont = rpcMallocCont(pTrans->rpcRspLen);
+        if (rpcCont != NULL) {
+          memcpy(rpcCont, pTrans->rpcRsp, pTrans->rpcRspLen);
+          rspMsg.pCont = rpcCont;
+          rspMsg.contLen = pTrans->rpcRspLen;
+        }
       }
 
       tmsgSendRsp(&rspMsg);
diff --git a/source/dnode/vnode/src/inc/vnodeInt.h b/source/dnode/vnode/src/inc/vnodeInt.h
index 39c5f3873e..927c314a4c 100644
--- a/source/dnode/vnode/src/inc/vnodeInt.h
+++ b/source/dnode/vnode/src/inc/vnodeInt.h
@@ -102,7 +102,7 @@ int             metaCommit(SMeta* pMeta);
 int             metaCreateSTable(SMeta* pMeta, int64_t version, SVCreateStbReq* pReq);
 int             metaAlterSTable(SMeta* pMeta, int64_t version, SVCreateStbReq* pReq);
 int             metaDropSTable(SMeta* pMeta, int64_t verison, SVDropStbReq* pReq, SArray* tbUidList);
-int             metaCreateTable(SMeta* pMeta, int64_t version, SVCreateTbReq* pReq);
+int             metaCreateTable(SMeta* pMeta, int64_t version, SVCreateTbReq* pReq, STableMetaRsp **pMetaRsp);
 int             metaDropTable(SMeta* pMeta, int64_t version, SVDropTbReq* pReq, SArray* tbUids);
 int             metaTtlDropTable(SMeta* pMeta, int64_t ttl, SArray* tbUids);
 int             metaAlterTable(SMeta* pMeta, int64_t version, SVAlterTbReq* pReq, STableMetaRsp* pMetaRsp);
diff --git a/source/dnode/vnode/src/meta/metaTable.c b/source/dnode/vnode/src/meta/metaTable.c
index aa107ab253..6b18e1b48d 100644
--- a/source/dnode/vnode/src/meta/metaTable.c
+++ b/source/dnode/vnode/src/meta/metaTable.c
@@ -367,7 +367,7 @@ int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
   return 0;
 }
 
-int metaCreateTable(SMeta *pMeta, int64_t version, SVCreateTbReq *pReq) {
+int metaCreateTable(SMeta *pMeta, int64_t version, SVCreateTbReq *pReq, STableMetaRsp **pMetaRsp) {
   SMetaEntry  me = {0};
   SMetaReader mr = {0};
 
@@ -427,6 +427,21 @@ int metaCreateTable(SMeta *pMeta, int64_t version, SVCreateTbReq *pReq) {
 
   if (metaHandleEntry(pMeta, &me) < 0) goto _err;
 
+  if (pMetaRsp) {
+    *pMetaRsp = taosMemoryCalloc(1, sizeof(STableMetaRsp));
+
+    if (*pMetaRsp) {
+      if (me.type == TSDB_CHILD_TABLE) {
+        (*pMetaRsp)->tableType = TSDB_CHILD_TABLE;
+        (*pMetaRsp)->tuid = pReq->uid;
+        (*pMetaRsp)->suid = pReq->ctb.suid;
+        strcpy((*pMetaRsp)->tbName, pReq->name);
+      } else {
+        metaUpdateMetaRsp(pReq->uid, pReq->name, pReq->ntb.schemaRow, *pMetaRsp);
+      }
+    }
+  }
+
   metaDebug("vgId:%d, table:%s uid %" PRId64 " is created, type:%" PRId8, TD_VID(pMeta->pVnode), pReq->name, pReq->uid,
             pReq->type);
   return 0;
diff --git a/source/dnode/vnode/src/vnd/vnodeSvr.c b/source/dnode/vnode/src/vnd/vnodeSvr.c
index 7a8d168f4f..947fb845cd 100644
--- a/source/dnode/vnode/src/vnd/vnodeSvr.c
+++ b/source/dnode/vnode/src/vnd/vnodeSvr.c
@@ -370,6 +370,10 @@ void smaHandleRes(void *pVnode, int64_t smaId, const SArray *data) {
 }
 
 void vnodeUpdateMetaRsp(SVnode *pVnode, STableMetaRsp *pMetaRsp) {
+  if (NULL == pMetaRsp) {
+    return;
+  }
+  
   strcpy(pMetaRsp->dbFName, pVnode->config.dbname);
   pMetaRsp->dbId = pVnode->config.dbId;
   pMetaRsp->vgId = TD_VID(pVnode);
@@ -514,7 +518,7 @@ static int32_t vnodeProcessCreateTbReq(SVnode *pVnode, int64_t version, void *pR
     }
 
     // do create table
-    if (metaCreateTable(pVnode->pMeta, version, pCreateReq) < 0) {
+    if (metaCreateTable(pVnode->pMeta, version, pCreateReq, &cRsp.pMeta) < 0) {
       if (pCreateReq->flags & TD_CREATE_IF_NOT_EXISTS && terrno == TSDB_CODE_TDB_TABLE_ALREADY_EXIST) {
         cRsp.code = TSDB_CODE_SUCCESS;
       } else {
@@ -524,6 +528,7 @@ static int32_t vnodeProcessCreateTbReq(SVnode *pVnode, int64_t version, void *pR
       cRsp.code = TSDB_CODE_SUCCESS;
       tdFetchTbUidList(pVnode->pSma, &pStore, pCreateReq->ctb.suid, pCreateReq->uid);
       taosArrayPush(tbUids, &pCreateReq->uid);
+      vnodeUpdateMetaRsp(pVnode, cRsp.pMeta); 
     }
 
     taosArrayPush(rsp.pArray, &cRsp);
@@ -552,7 +557,7 @@ _exit:
     pCreateReq = req.pReqs + iReq;
     taosArrayDestroy(pCreateReq->ctb.tagName);
   }
-  taosArrayDestroy(rsp.pArray);
+  taosArrayDestroyEx(rsp.pArray, tFreeSVCreateTbRsp);
   taosArrayDestroy(tbUids);
   tDecoderClear(&decoder);
   tEncoderClear(&encoder);
@@ -864,7 +869,7 @@ static int32_t vnodeProcessSubmitReq(SVnode *pVnode, int64_t version, void *pReq
         goto _exit;
       }
 
-      if (metaCreateTable(pVnode->pMeta, version, &createTbReq) < 0) {
+      if (metaCreateTable(pVnode->pMeta, version, &createTbReq, NULL) < 0) {
         if (terrno != TSDB_CODE_TDB_TABLE_ALREADY_EXIST) {
           submitBlkRsp.code = terrno;
           pRsp->code = terrno;
diff --git a/source/libs/qcom/src/queryUtil.c b/source/libs/qcom/src/queryUtil.c
index 5143aa4af1..3c8b019d81 100644
--- a/source/libs/qcom/src/queryUtil.c
+++ b/source/libs/qcom/src/queryUtil.c
@@ -219,6 +219,11 @@ void destroyQueryExecRes(SExecResult* pRes) {
   }
 
   switch (pRes->msgType) {
+    case TDMT_VND_CREATE_TABLE: {
+      taosArrayDestroyEx((SArray*)pRes->res, tFreeSTableMetaRsp);
+      break;
+    }
+    case TDMT_MND_CREATE_STB:
     case TDMT_VND_ALTER_TABLE:
     case TDMT_MND_ALTER_STB: {
       tFreeSTableMetaRsp((STableMetaRsp*)pRes->res);
diff --git a/source/libs/scheduler/src/schRemote.c b/source/libs/scheduler/src/schRemote.c
index ecd9daf1bc..bd0c3009b0 100644
--- a/source/libs/scheduler/src/schRemote.c
+++ b/source/libs/scheduler/src/schRemote.c
@@ -102,15 +102,26 @@ int32_t schHandleResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SDa
         tDecoderInit(&coder, msg, msgSize);
         code = tDecodeSVCreateTbBatchRsp(&coder, &batchRsp);
         if (TSDB_CODE_SUCCESS == code && batchRsp.nRsps > 0) {
+          pJob->execRes.res = taosArrayInit(batchRsp.nRsps, POINTER_BYTES);
+          pJob->execRes.msgType = TDMT_VND_CREATE_TABLE;
+
           for (int32_t i = 0; i < batchRsp.nRsps; ++i) {
             SVCreateTbRsp *rsp = batchRsp.pRsps + i;
+            if (rsp->pMeta) {
+              taosArrayPush((SArray*)pJob->execRes.res, &rsp->pMeta);
+            }
+            
             if (TSDB_CODE_SUCCESS != rsp->code) {
               code = rsp->code;
-              tDecoderClear(&coder);
-              SCH_ERR_JRET(code);
             }
           }
+
+          if (taosArrayGetSize((SArray*)pJob->execRes.res) <= 0) {        
+            taosArrayDestroy((SArray*)pJob->execRes.res);
+            pJob->execRes.res = NULL;
+          }
         }
+        
         tDecoderClear(&coder);
         SCH_ERR_JRET(code);
       }

From 150956ffd38f88b40257dd701a96d96e1d4c75ae Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Wed, 24 Aug 2022 13:19:52 +0800
Subject: [PATCH 2/8] enh: update tbMeta after creating table

---
 include/common/tmsg.h                   |  2 +-
 include/libs/qcom/query.h               |  1 +
 source/common/src/tmsg.c                |  2 +-
 source/dnode/vnode/src/meta/metaTable.c |  2 +-
 source/libs/catalog/src/catalog.c       | 15 ++++++++++++---
 source/libs/qcom/src/queryUtil.c        |  9 +++++++--
 source/libs/qcom/src/querymsg.c         | 13 +++++++++++++
 source/libs/scheduler/src/schRemote.c   | 10 +++++++---
 8 files changed, 43 insertions(+), 11 deletions(-)

diff --git a/include/common/tmsg.h b/include/common/tmsg.h
index ae6f034df5..7c7f017fe6 100644
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@@ -1276,7 +1276,7 @@ void    tFreeSMAlterStbRsp(SMAlterStbRsp* pRsp);
 
 int32_t tSerializeSTableMetaRsp(void* buf, int32_t bufLen, STableMetaRsp* pRsp);
 int32_t tDeserializeSTableMetaRsp(void* buf, int32_t bufLen, STableMetaRsp* pRsp);
-void    tFreeSTableMetaRsp(STableMetaRsp* pRsp);
+void    tFreeSTableMetaRsp(void* pRsp);
 void    tFreeSTableIndexRsp(void* info);
 
 typedef struct {
diff --git a/include/libs/qcom/query.h b/include/libs/qcom/query.h
index 34d870397f..1fa7dca7dc 100644
--- a/include/libs/qcom/query.h
+++ b/include/libs/qcom/query.h
@@ -215,6 +215,7 @@ void initQueryModuleMsgHandle();
 const SSchema* tGetTbnameColumnSchema();
 bool           tIsValidSchema(struct SSchema* pSchema, int32_t numOfCols, int32_t numOfTags);
 
+int32_t queryCreateCTableMetaFromMsg(STableMetaRsp *msg, SCTableMeta *pMeta);
 int32_t queryCreateTableMetaFromMsg(STableMetaRsp* msg, bool isSuperTable, STableMeta** pMeta);
 char*   jobTaskStatusStr(int32_t status);
 
diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c
index 3ceb9ca192..b3c0363e44 100644
--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@@ -3330,7 +3330,7 @@ int32_t tDeserializeSSTbHbRsp(void *buf, int32_t bufLen, SSTbHbRsp *pRsp) {
   return 0;
 }
 
-void tFreeSTableMetaRsp(STableMetaRsp *pRsp) { taosMemoryFreeClear(pRsp->pSchemas); }
+void tFreeSTableMetaRsp(void *pRsp) { taosMemoryFreeClear(((STableMetaRsp*)pRsp)->pSchemas); }
 
 void tFreeSTableIndexRsp(void *info) {
   if (NULL == info) {
diff --git a/source/dnode/vnode/src/meta/metaTable.c b/source/dnode/vnode/src/meta/metaTable.c
index 6b18e1b48d..811aac28b7 100644
--- a/source/dnode/vnode/src/meta/metaTable.c
+++ b/source/dnode/vnode/src/meta/metaTable.c
@@ -437,7 +437,7 @@ int metaCreateTable(SMeta *pMeta, int64_t version, SVCreateTbReq *pReq, STableMe
         (*pMetaRsp)->suid = pReq->ctb.suid;
         strcpy((*pMetaRsp)->tbName, pReq->name);
       } else {
-        metaUpdateMetaRsp(pReq->uid, pReq->name, pReq->ntb.schemaRow, *pMetaRsp);
+        metaUpdateMetaRsp(pReq->uid, pReq->name, &pReq->ntb.schemaRow, *pMetaRsp);
       }
     }
   }
diff --git a/source/libs/catalog/src/catalog.c b/source/libs/catalog/src/catalog.c
index b6e958e192..7b32eadcd4 100644
--- a/source/libs/catalog/src/catalog.c
+++ b/source/libs/catalog/src/catalog.c
@@ -270,13 +270,22 @@ int32_t ctgUpdateTbMeta(SCatalog* pCtg, STableMetaRsp* rspMsg, bool syncOp) {
   int32_t code = 0;
 
   strcpy(output->dbFName, rspMsg->dbFName);
-  strcpy(output->tbName, rspMsg->tbName);
 
   output->dbId = rspMsg->dbId;
 
-  SET_META_TYPE_TABLE(output->metaType);
+  if (TSDB_CHILD_TABLE == rspMsg->tableType && NULL == rspMsg->pSchemas) {
+    strcpy(output->ctbName, rspMsg->tbName);
 
-  CTG_ERR_JRET(queryCreateTableMetaFromMsg(rspMsg, rspMsg->tableType == TSDB_SUPER_TABLE, &output->tbMeta));
+    SET_META_TYPE_CTABLE(output->metaType);
+
+    CTG_ERR_JRET(queryCreateCTableMetaFromMsg(rspMsg, &output->ctbMeta));
+  } else {
+    strcpy(output->tbName, rspMsg->tbName);
+
+    SET_META_TYPE_TABLE(output->metaType);
+
+    CTG_ERR_JRET(queryCreateTableMetaFromMsg(rspMsg, rspMsg->tableType == TSDB_SUPER_TABLE, &output->tbMeta));
+  }
 
   CTG_ERR_JRET(ctgUpdateTbMetaEnqueue(pCtg, output, syncOp));
 
diff --git a/source/libs/qcom/src/queryUtil.c b/source/libs/qcom/src/queryUtil.c
index 3c8b019d81..d848016e46 100644
--- a/source/libs/qcom/src/queryUtil.c
+++ b/source/libs/qcom/src/queryUtil.c
@@ -213,6 +213,11 @@ SSchema createSchema(int8_t type, int32_t bytes, col_id_t colId, const char* nam
   return s;
 }
 
+void freeSTableMetaRspPointer(void *p) {
+  tFreeSTableMetaRsp(*(void**)p);
+  taosMemoryFreeClear(*(void**)p);
+}
+
 void destroyQueryExecRes(SExecResult* pRes) {
   if (NULL == pRes || NULL == pRes->res) {
     return;
@@ -220,13 +225,13 @@ void destroyQueryExecRes(SExecResult* pRes) {
 
   switch (pRes->msgType) {
     case TDMT_VND_CREATE_TABLE: {
-      taosArrayDestroyEx((SArray*)pRes->res, tFreeSTableMetaRsp);
+      taosArrayDestroyEx((SArray*)pRes->res, freeSTableMetaRspPointer);
       break;
     }
     case TDMT_MND_CREATE_STB:
     case TDMT_VND_ALTER_TABLE:
     case TDMT_MND_ALTER_STB: {
-      tFreeSTableMetaRsp((STableMetaRsp*)pRes->res);
+      tFreeSTableMetaRsp(pRes->res);
       taosMemoryFreeClear(pRes->res);
       break;
     }
diff --git a/source/libs/qcom/src/querymsg.c b/source/libs/qcom/src/querymsg.c
index ed8786170d..e2d3ac1583 100644
--- a/source/libs/qcom/src/querymsg.c
+++ b/source/libs/qcom/src/querymsg.c
@@ -354,6 +354,19 @@ static int32_t queryConvertTableMetaMsg(STableMetaRsp *pMetaMsg) {
   return TSDB_CODE_SUCCESS;
 }
 
+int32_t queryCreateCTableMetaFromMsg(STableMetaRsp *msg, SCTableMeta *pMeta) {
+  pMeta->vgId = msg->vgId;
+  pMeta->tableType = msg->tableType;
+  pMeta->uid = msg->tuid;
+  pMeta->suid = msg->suid;
+
+  qDebug("ctable %s uid %" PRIx64 " meta returned, type %d vgId:%d db %s suid %" PRIx64 ,
+         msg->tbName, pMeta->uid, pMeta->tableType, pMeta->vgId, msg->dbFName, pMeta->suid);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
 int32_t queryCreateTableMetaFromMsg(STableMetaRsp *msg, bool isStb, STableMeta **pMeta) {
   int32_t total = msg->numOfColumns + msg->numOfTags;
   int32_t metaSize = sizeof(STableMeta) + sizeof(SSchema) * total;
diff --git a/source/libs/scheduler/src/schRemote.c b/source/libs/scheduler/src/schRemote.c
index bd0c3009b0..fc2a8d1e08 100644
--- a/source/libs/scheduler/src/schRemote.c
+++ b/source/libs/scheduler/src/schRemote.c
@@ -102,8 +102,11 @@ int32_t schHandleResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SDa
         tDecoderInit(&coder, msg, msgSize);
         code = tDecodeSVCreateTbBatchRsp(&coder, &batchRsp);
         if (TSDB_CODE_SUCCESS == code && batchRsp.nRsps > 0) {
-          pJob->execRes.res = taosArrayInit(batchRsp.nRsps, POINTER_BYTES);
-          pJob->execRes.msgType = TDMT_VND_CREATE_TABLE;
+          SCH_LOCK(SCH_WRITE, &pJob->resLock);
+          if (NULL == pJob->execRes.res) {
+            pJob->execRes.res = taosArrayInit(batchRsp.nRsps, POINTER_BYTES);
+            pJob->execRes.msgType = TDMT_VND_CREATE_TABLE;
+          }
 
           for (int32_t i = 0; i < batchRsp.nRsps; ++i) {
             SVCreateTbRsp *rsp = batchRsp.pRsps + i;
@@ -115,6 +118,7 @@ int32_t schHandleResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SDa
               code = rsp->code;
             }
           }
+          SCH_UNLOCK(SCH_WRITE, &pJob->resLock);
 
           if (taosArrayGetSize((SArray*)pJob->execRes.res) <= 0) {        
             taosArrayDestroy((SArray*)pJob->execRes.res);
@@ -1113,7 +1117,7 @@ int32_t schBuildAndSendMsg(SSchJob *pJob, SSchTask *pTask, SQueryNodeAddr *addr,
       break;
   }
 
-#if 1
+#if 0
   SSchTrans trans = {.pTrans = pJob->conn.pTrans, .pHandle = SCH_GET_TASK_HANDLE(pTask)};
   code = schAsyncSendMsg(pJob, pTask, &trans, addr, msgType, msg, msgSize, persistHandle, (rpcCtx.args ? &rpcCtx : NULL));
   msg = NULL;

From f6b39e5911de1701845d0d80a5be3735342b567f Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Wed, 24 Aug 2022 18:21:49 +0800
Subject: [PATCH 3/8] enh: add hash performance test

---
 include/util/thash.h          |   2 +
 source/util/src/thash.c       |   8 +-
 source/util/test/hashTest.cpp | 167 ++++++++++++++++++++++++++++++++++
 3 files changed, 176 insertions(+), 1 deletion(-)

diff --git a/include/util/thash.h b/include/util/thash.h
index 781c22a56a..f4d09eb090 100644
--- a/include/util/thash.h
+++ b/include/util/thash.h
@@ -210,6 +210,8 @@ void taosHashSetEqualFp(SHashObj *pHashObj, _equal_fn_t fp);
  */
 void taosHashSetFreeFp(SHashObj *pHashObj, _hash_free_fn_t fp);
 
+int64_t taosHashGetCompTimes(SHashObj *pHashObj);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/util/src/thash.c b/source/util/src/thash.c
index aee84a0d55..0029f1ab1e 100644
--- a/source/util/src/thash.c
+++ b/source/util/src/thash.c
@@ -21,7 +21,7 @@
 
 // the add ref count operation may trigger the warning if the reference count is greater than the MAX_WARNING_REF_COUNT
 #define MAX_WARNING_REF_COUNT    10000
-#define HASH_MAX_CAPACITY        (1024 * 1024 * 16)
+#define HASH_MAX_CAPACITY        (1024 * 1024 * 1024)
 #define HASH_DEFAULT_LOAD_FACTOR (0.75)
 #define HASH_INDEX(v, c)         ((v) & ((c)-1))
 
@@ -67,6 +67,7 @@ struct SHashObj {
   bool              enableUpdate;  // enable update
   SArray           *pMemBlock;     // memory block allocated for SHashEntry
   _hash_before_fn_t callbackFp;    // function invoked before return the value to caller
+  int64_t           compTimes;
 };
 
 /*
@@ -146,6 +147,7 @@ static FORCE_INLINE SHashNode *doSearchInEntryList(SHashObj *pHashObj, SHashEntr
                                                    uint32_t hashVal) {
   SHashNode *pNode = pe->next;
   while (pNode) {
+    atomic_add_fetch_64(&pHashObj->compTimes, 1);
     if ((pNode->keyLen == keyLen) && ((*(pHashObj->equalFp))(GET_HASH_NODE_KEY(pNode), key, keyLen) == 0) &&
         pNode->removed == 0) {
       assert(pNode->hashVal == hashVal);
@@ -882,3 +884,7 @@ void *taosHashAcquire(SHashObj *pHashObj, const void *key, size_t keyLen) {
 }
 
 void taosHashRelease(SHashObj *pHashObj, void *p) { taosHashCancelIterate(pHashObj, p); }
+
+int64_t taosHashGetCompTimes(SHashObj *pHashObj) { return atomic_load_64(&pHashObj->compTimes); }
+
+
diff --git a/source/util/test/hashTest.cpp b/source/util/test/hashTest.cpp
index 99f5a761c5..5a426f9317 100644
--- a/source/util/test/hashTest.cpp
+++ b/source/util/test/hashTest.cpp
@@ -197,6 +197,172 @@ void acquireRleaseTest() {
   taosMemoryFreeClear(data.p);
 }
 
+void perfTest() {
+  SHashObj* hash1h = (SHashObj*) taosHashInit(100, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
+  SHashObj* hash1s = (SHashObj*) taosHashInit(1000, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
+  SHashObj* hash10s = (SHashObj*) taosHashInit(10000, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
+  SHashObj* hash100s = (SHashObj*) taosHashInit(100000, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
+  SHashObj* hash1m = (SHashObj*) taosHashInit(1000000, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
+  SHashObj* hash10m = (SHashObj*) taosHashInit(10000000, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
+  SHashObj* hash100m = (SHashObj*) taosHashInit(100000000, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
+
+  char *name = (char*)taosMemoryCalloc(50000000, 9);
+  for (int64_t i = 0; i < 50000000; ++i) {
+    sprintf(name + i * 9, "t%08d", i);
+  }
+  
+  for (int64_t i = 0; i < 50; ++i) {
+    taosHashPut(hash1h, name + i * 9, 9, &i, sizeof(i));
+  }
+
+  for (int64_t i = 0; i < 500; ++i) {
+    taosHashPut(hash1s, name + i * 9, 9, &i, sizeof(i));
+  }
+
+  for (int64_t i = 0; i < 5000; ++i) {
+    taosHashPut(hash10s, name + i * 9, 9, &i, sizeof(i));
+  }
+
+  for (int64_t i = 0; i < 50000; ++i) {
+    taosHashPut(hash100s, name + i * 9, 9, &i, sizeof(i));
+  }
+
+  for (int64_t i = 0; i < 500000; ++i) {
+    taosHashPut(hash1m, name + i * 9, 9, &i, sizeof(i));
+  }
+
+  for (int64_t i = 0; i < 5000000; ++i) {
+    taosHashPut(hash10m, name + i * 9, 9, &i, sizeof(i));
+  }
+
+  for (int64_t i = 0; i < 50000000; ++i) {
+    taosHashPut(hash100m, name + i * 9, 9, &i, sizeof(i));
+  }
+
+  int64_t start1h = taosGetTimestampMs();
+  int64_t start1hCt = taosHashGetCompTimes(hash1h);
+  for (int64_t i = 0; i < 10000000; ++i) {
+    ASSERT(taosHashGet(hash1h, name + (i % 50) * 9, 9));
+  }
+  int64_t end1h = taosGetTimestampMs();
+  int64_t end1hCt = taosHashGetCompTimes(hash1h);
+
+  int64_t start1s = taosGetTimestampMs();
+  int64_t start1sCt = taosHashGetCompTimes(hash1s);
+  for (int64_t i = 0; i < 10000000; ++i) {
+    ASSERT(taosHashGet(hash1s, name + (i % 500) * 9, 9));
+  }
+  int64_t end1s = taosGetTimestampMs();
+  int64_t end1sCt = taosHashGetCompTimes(hash1s);
+
+  int64_t start10s = taosGetTimestampMs();
+  int64_t start10sCt = taosHashGetCompTimes(hash10s);
+  for (int64_t i = 0; i < 10000000; ++i) {
+    ASSERT(taosHashGet(hash10s, name + (i % 5000) * 9, 9));
+  }
+  int64_t end10s = taosGetTimestampMs();
+  int64_t end10sCt = taosHashGetCompTimes(hash10s);
+
+  int64_t start100s = taosGetTimestampMs();
+  int64_t start100sCt = taosHashGetCompTimes(hash100s);
+  for (int64_t i = 0; i < 10000000; ++i) {
+    ASSERT(taosHashGet(hash100s, name + (i % 50000) * 9, 9));
+  }
+  int64_t end100s = taosGetTimestampMs();
+  int64_t end100sCt = taosHashGetCompTimes(hash100s);
+
+  int64_t start1m = taosGetTimestampMs();
+  int64_t start1mCt = taosHashGetCompTimes(hash1m);
+  for (int64_t i = 0; i < 10000000; ++i) {
+    ASSERT(taosHashGet(hash1m, name + (i % 500000) * 9, 9));
+  }
+  int64_t end1m = taosGetTimestampMs();
+  int64_t end1mCt = taosHashGetCompTimes(hash1m);
+
+  int64_t start10m = taosGetTimestampMs();
+  int64_t start10mCt = taosHashGetCompTimes(hash10m);
+  for (int64_t i = 0; i < 10000000; ++i) {
+    ASSERT(taosHashGet(hash10m, name + (i % 5000000) * 9, 9));
+  }
+  int64_t end10m = taosGetTimestampMs();
+  int64_t end10mCt = taosHashGetCompTimes(hash10m);
+
+  int64_t start100m = taosGetTimestampMs();
+  int64_t start100mCt = taosHashGetCompTimes(hash100m);
+  for (int64_t i = 0; i < 10000000; ++i) {
+    ASSERT(taosHashGet(hash100m, name + (i % 50000000) * 9, 9));
+  }
+  int64_t end100m = taosGetTimestampMs();
+  int64_t end100mCt = taosHashGetCompTimes(hash100m);
+
+  int64_t start100mS = taosGetTimestampMs();
+  int64_t start100mSCt = taosHashGetCompTimes(hash100m);
+  _hash_fn_t hashFp = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
+  for (int64_t i = 0; i < 10000000; ++i) {
+    ASSERT(taosHashGet(hash100m, name + (i % 50000000) * 9, 9));
+  }
+  int64_t end100mS = taosGetTimestampMs();
+  int64_t end100mSCt = taosHashGetCompTimes(hash100m);
+
+
+  printf("1h \t %" PRId64 "ms,%" PRId64 "\n", end1h - start1h, end1hCt - start1hCt);
+  printf("1s \t %" PRId64 "ms,%" PRId64 "\n", end1s - start1s, end1sCt - start1sCt);
+  printf("10s \t %" PRId64 "ms,%" PRId64 "\n", end10s - start10s, end10sCt - start10sCt);
+  printf("100s \t %" PRId64 "ms,%" PRId64 "\n", end100s - start100s, end100sCt - start100sCt);
+  printf("1m \t %" PRId64 "ms,%" PRId64 "\n", end1m - start1m, end1mCt - start1mCt);
+  printf("10m \t %" PRId64 "ms,%" PRId64 "\n", end10m - start10m, end10mCt - start10mCt);
+  printf("100m \t %" PRId64 "ms,%" PRId64 "\n", end100m - start100m, end100mCt - start100mCt);
+
+  taosHashCleanup(hash1h);
+  taosHashCleanup(hash1s);
+  taosHashCleanup(hash10s);
+  taosHashCleanup(hash100s);
+  taosHashCleanup(hash1m);
+  taosHashCleanup(hash10m);
+  taosHashCleanup(hash100m);
+
+  SHashObj *mhash[1000] = {0};
+  for (int64_t i = 0; i < 1000; ++i) {
+    mhash[i] = (SHashObj*) taosHashInit(100000, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
+  }
+
+  for (int64_t i = 0; i < 50000000; ++i) {
+#if 0
+    taosHashPut(mhash[i%1000], name + i * 9, 9, &i, sizeof(i));
+#else
+    taosHashPut(mhash[i/50000], name + i * 9, 9, &i, sizeof(i));
+#endif    
+  }
+
+  int64_t startMhashCt = 0;
+  for (int64_t i = 0; i < 1000; ++i) {
+    startMhashCt += taosHashGetCompTimes(mhash[i]);
+  }
+
+  int64_t startMhash = taosGetTimestampMs();
+#if 0
+  for (int32_t i = 0; i < 10000000; ++i) {
+    ASSERT(taosHashGet(mhash[i%1000], name + i * 9, 9));
+  }
+#else
+  for (int64_t i = 0; i < 10000000; ++i) {
+    ASSERT(taosHashGet(mhash[i/50000], name + i * 9, 9));
+  }
+#endif  
+  int64_t endMhash = taosGetTimestampMs();
+  int64_t endMhashCt = 0;
+  for (int64_t i = 0; i < 1000; ++i) {
+    printf(" %" PRId64 , taosHashGetCompTimes(mhash[i]));
+    endMhashCt += taosHashGetCompTimes(mhash[i]);
+  }
+  printf("\n100m \t %" PRId64 "ms,%" PRId64 "\n", endMhash - startMhash, endMhashCt - startMhashCt);
+
+  for (int64_t i = 0; i < 1000; ++i) {
+    taosHashCleanup(mhash[i]);
+  }
+}
+
+
 }
 
 int main(int argc, char** argv) {
@@ -210,4 +376,5 @@ TEST(testCase, hashTest) {
   noLockPerformanceTest();
   multithreadsTest();
   acquireRleaseTest();
+  //perfTest();
 }

From b49d4ed414d33d4e182baebdf3f9d7a809a4ee70 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Thu, 25 Aug 2022 10:40:15 +0800
Subject: [PATCH 4/8] fix: remove debug info

---
 source/libs/scheduler/src/schRemote.c |  2 +-
 source/util/test/hashTest.cpp         | 41 +++++++++++++++++++++++----
 2 files changed, 37 insertions(+), 6 deletions(-)

diff --git a/source/libs/scheduler/src/schRemote.c b/source/libs/scheduler/src/schRemote.c
index fc2a8d1e08..5a64aaaebb 100644
--- a/source/libs/scheduler/src/schRemote.c
+++ b/source/libs/scheduler/src/schRemote.c
@@ -1117,7 +1117,7 @@ int32_t schBuildAndSendMsg(SSchJob *pJob, SSchTask *pTask, SQueryNodeAddr *addr,
       break;
   }
 
-#if 0
+#if 1
   SSchTrans trans = {.pTrans = pJob->conn.pTrans, .pHandle = SCH_GET_TASK_HANDLE(pTask)};
   code = schAsyncSendMsg(pJob, pTask, &trans, addr, msgType, msg, msgSize, persistHandle, (rpcCtx.args ? &rpcCtx : NULL));
   msg = NULL;
diff --git a/source/util/test/hashTest.cpp b/source/util/test/hashTest.cpp
index 5a426f9317..135db8192a 100644
--- a/source/util/test/hashTest.cpp
+++ b/source/util/test/hashTest.cpp
@@ -295,15 +295,44 @@ void perfTest() {
   int64_t end100m = taosGetTimestampMs();
   int64_t end100mCt = taosHashGetCompTimes(hash100m);
 
+
+  SArray *sArray[1000] = {0};
+  for (int64_t i = 0; i < 1000; ++i) {
+    sArray[i] = taosArrayInit(100000, 9);
+  }
+  int64_t cap = 4;
+  while (cap < 100000000) cap = (cap << 1u);
+  
+  _hash_fn_t hashFp = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
+  int32_t slotR = cap / 1000 + 1;
+  for (int64_t i = 0; i < 10000000; ++i) {
+    char* p = name + (i % 50000000) * 9;
+    uint32_t v = (*hashFp)(p, 9);
+    taosArrayPush(sArray[(v%cap)/slotR], p);
+  }
+  SArray *slArray = taosArrayInit(100000000, 9);
+  for (int64_t i = 0; i < 1000; ++i) {
+    int32_t num = taosArrayGetSize(sArray[i]);
+    printf("%d ", num);
+    SArray* pArray = sArray[i];
+    for (int64_t m = 0; m < num; ++m) {
+      char* p = (char*)taosArrayGet(pArray, m);
+      ASSERT(taosArrayPush(slArray, p));
+    }
+  }
+  printf("\n");
   int64_t start100mS = taosGetTimestampMs();
   int64_t start100mSCt = taosHashGetCompTimes(hash100m);
-  _hash_fn_t hashFp = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
-  for (int64_t i = 0; i < 10000000; ++i) {
-    ASSERT(taosHashGet(hash100m, name + (i % 50000000) * 9, 9));
+  int32_t num = taosArrayGetSize(slArray);
+  for (int64_t i = 0; i < num; ++i) {
+    ASSERT(taosHashGet(hash100m, (char*)TARRAY_GET_ELEM(slArray, i), 9));
   }
   int64_t end100mS = taosGetTimestampMs();
   int64_t end100mSCt = taosHashGetCompTimes(hash100m);
-
+  for (int64_t i = 0; i < 1000; ++i) {
+    taosArrayDestroy(sArray[i]);
+  }
+  taosArrayDestroy(slArray);
 
   printf("1h \t %" PRId64 "ms,%" PRId64 "\n", end1h - start1h, end1hCt - start1hCt);
   printf("1s \t %" PRId64 "ms,%" PRId64 "\n", end1s - start1s, end1sCt - start1sCt);
@@ -312,6 +341,7 @@ void perfTest() {
   printf("1m \t %" PRId64 "ms,%" PRId64 "\n", end1m - start1m, end1mCt - start1mCt);
   printf("10m \t %" PRId64 "ms,%" PRId64 "\n", end10m - start10m, end10mCt - start10mCt);
   printf("100m \t %" PRId64 "ms,%" PRId64 "\n", end100m - start100m, end100mCt - start100mCt);
+  printf("100mS \t %" PRId64 "ms,%" PRId64 "\n", end100mS - start100mS, end100mSCt - start100mSCt);
 
   taosHashCleanup(hash1h);
   taosHashCleanup(hash1s);
@@ -345,7 +375,8 @@ void perfTest() {
     ASSERT(taosHashGet(mhash[i%1000], name + i * 9, 9));
   }
 #else
-  for (int64_t i = 0; i < 10000000; ++i) {
+//  for (int64_t i = 0; i < 10000000; ++i) {
+  for (int64_t i = 0; i < 50000000; i+=5) {
     ASSERT(taosHashGet(mhash[i/50000], name + i * 9, 9));
   }
 #endif  

From bebd9225cc9026643ddb9ee9fefc4652cea87cb4 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Thu, 25 Aug 2022 11:49:01 +0800
Subject: [PATCH 5/8] fix: fix explain buffer issue

---
 source/common/src/tmsg.c                |  9 ++++++++-
 source/libs/nodes/src/nodesToSQLFuncs.c | 12 +++++++++++-
 source/util/test/hashTest.cpp           |  2 --
 3 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c
index b3c0363e44..1d96131f11 100644
--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@@ -5123,8 +5123,15 @@ int tDecodeSVCreateTbRsp(SDecoder *pCoder, SVCreateTbRsp *pRsp) {
 }
 
 void tFreeSVCreateTbRsp(void* param) {
+  if (NULL == param) {
+    return;
+  }
+  
   SVCreateTbRsp* pRsp = (SVCreateTbRsp*)param;
-  taosMemoryFree(pRsp->pMeta);
+  if (pRsp->pMeta) {
+    taosMemoryFree(pRsp->pMeta->pSchemas);
+    taosMemoryFree(pRsp->pMeta);
+  }
 }
 
 // TDMT_VND_DROP_TABLE =================
diff --git a/source/libs/nodes/src/nodesToSQLFuncs.c b/source/libs/nodes/src/nodesToSQLFuncs.c
index e521c57c3d..9325d02886 100644
--- a/source/libs/nodes/src/nodesToSQLFuncs.c
+++ b/source/libs/nodes/src/nodesToSQLFuncs.c
@@ -135,7 +135,12 @@ int32_t nodesNodeToSQL(SNode *pNode, char *buf, int32_t bufSize, int32_t *len) {
         NODES_ERR_RET(TSDB_CODE_QRY_APP_ERROR);
       }
 
-      *len += snprintf(buf + *len, bufSize - *len, "%s", t);
+      int32_t tlen = strlen(t);
+      if (tlen > 32) {
+        *len += snprintf(buf + *len, bufSize - *len, "%.*s...%s", 32, t, t + tlen - 1);
+      } else {
+        *len += snprintf(buf + *len, bufSize - *len, "%s", t);
+      }
       taosMemoryFree(t);
 
       return TSDB_CODE_SUCCESS;
@@ -199,12 +204,17 @@ int32_t nodesNodeToSQL(SNode *pNode, char *buf, int32_t bufSize, int32_t *len) {
       SNodeListNode *pListNode = (SNodeListNode *)pNode;
       SNode         *node = NULL;
       bool           first = true;
+      int32_t        num = 0;
 
       *len += snprintf(buf + *len, bufSize - *len, "(");
 
       FOREACH(node, pListNode->pNodeList) {
         if (!first) {
           *len += snprintf(buf + *len, bufSize - *len, ", ");
+          if (++num >= 10) {
+            *len += snprintf(buf + *len, bufSize - *len, "...");
+            break;
+          }
         }
         NODES_ERR_RET(nodesNodeToSQL(node, buf, bufSize, len));
         first = false;
diff --git a/source/util/test/hashTest.cpp b/source/util/test/hashTest.cpp
index 135db8192a..97e67ea36e 100644
--- a/source/util/test/hashTest.cpp
+++ b/source/util/test/hashTest.cpp
@@ -313,14 +313,12 @@ void perfTest() {
   SArray *slArray = taosArrayInit(100000000, 9);
   for (int64_t i = 0; i < 1000; ++i) {
     int32_t num = taosArrayGetSize(sArray[i]);
-    printf("%d ", num);
     SArray* pArray = sArray[i];
     for (int64_t m = 0; m < num; ++m) {
       char* p = (char*)taosArrayGet(pArray, m);
       ASSERT(taosArrayPush(slArray, p));
     }
   }
-  printf("\n");
   int64_t start100mS = taosGetTimestampMs();
   int64_t start100mSCt = taosHashGetCompTimes(hash100m);
   int32_t num = taosArrayGetSize(slArray);

From c2b16acc3130e894fef26796185064664fb40942 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Thu, 25 Aug 2022 13:44:26 +0800
Subject: [PATCH 6/8] fix: fix code merge issue

---
 include/common/tmsg.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/common/tmsg.h b/include/common/tmsg.h
index b091668d67..ab90bd200a 100644
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@@ -457,6 +457,7 @@ typedef struct {
   uint64_t suid;
   uint64_t tuid;
   int32_t  vgId;
+  int8_t   sysInfo;
   SSchema* pSchemas;
 } STableMetaRsp;
 

From 48c3cffe27856ff10f3fd6c3c2226c3cfad4949b Mon Sep 17 00:00:00 2001
From: Pan YANG <arielyang@gmail.com>
Date: Thu, 25 Aug 2022 14:17:28 +0800
Subject: [PATCH 7/8] docs: correct epoch definition in English

---
 docs/en/12-taos-sql/01-data-type.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/en/12-taos-sql/01-data-type.md b/docs/en/12-taos-sql/01-data-type.md
index b830994ac9..876de50f35 100644
--- a/docs/en/12-taos-sql/01-data-type.md
+++ b/docs/en/12-taos-sql/01-data-type.md
@@ -11,7 +11,7 @@ When using TDengine to store and query data, the most important part of the data
 - The format must be `YYYY-MM-DD HH:mm:ss.MS`, the default time precision is millisecond (ms), for example `2017-08-12 18:25:58.128`
 - Internal function `now` can be used to get the current timestamp on the client side
 - The current timestamp of the client side is applied when `now` is used to insert data
-- Epoch Time：timestamp can also be a long integer number, which means the number of seconds, milliseconds or nanoseconds, depending on the time precision, from 1970-01-01 00:00:00.000 (UTC/GMT)
+- Epoch Time：timestamp can also be a long integer number, which means the number of seconds, milliseconds or nanoseconds, depending on the time precision, from UTC 1970-01-01 00:00:00.
 - Add/subtract operations can be carried out on timestamps. For example `now-2h` means 2 hours prior to the time at which query is executed. The units of time in operations can be b(nanosecond), u(microsecond), a(millisecond), s(second), m(minute), h(hour), d(day), or w(week). So `select * from t1 where ts > now-2w and ts <= now-1w` means the data between two weeks ago and one week ago. The time unit can also be n (calendar month) or y (calendar year) when specifying the time window for down sampling operations.
 
 Time precision in TDengine can be set by the `PRECISION` parameter when executing `CREATE DATABASE`. The default time precision is millisecond. In the statement below, the precision is set to nanonseconds.

From c2eb45fad7da9ec4fa74630cd3f8e0e64084bafc Mon Sep 17 00:00:00 2001
From: Jeff Tao <jhtao@taosdata.com>
Date: Thu, 25 Aug 2022 15:16:51 +0800
Subject: [PATCH 8/8] Update index.md

---
 docs/en/04-concept/index.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/docs/en/04-concept/index.md b/docs/en/04-concept/index.md
index 7b0665a5b8..5a9c55fdd6 100644
--- a/docs/en/04-concept/index.md
+++ b/docs/en/04-concept/index.md
@@ -104,7 +104,7 @@ Each row contains the device ID, time stamp, collected metrics (current, voltage
 
 ## Metric
 
-Metric refers to the physical quantity collected by sensors, equipment or other types of data collection devices, such as current, voltage, temperature, pressure, GPS position, etc., which change with time, and the data type can be integer, float, Boolean, or strings. As time goes by, the amount of collected metric data stored increases. In the meters example, current, voltage and phase are the metrics.
+Metric refers to the physical quantity collected by sensors, equipment or other types of data collection devices, such as current, voltage, temperature, pressure, GPS position, etc., which change with time, and the data type can be integer, float, Boolean, or strings. As time goes by, the amount of collected metric data stored increases. In the smart meters example, current, voltage and phase are the metrics.
 
 ## Label/Tag
 
@@ -112,7 +112,7 @@ Label/Tag refers to the static properties of sensors, equipment or other types o
 
 ## Data Collection Point
 
-Data Collection Point (DCP) refers to hardware or software that collects metrics based on preset time periods or triggered by events. A data collection point can collect one or multiple metrics, but these metrics are collected at the same time and have the same time stamp. For some complex equipment, there are often multiple data collection points, and the sampling rate of each collection point may be different, and fully independent. For example, for a car, there could be a data collection point to collect GPS position metrics, a data collection point to collect engine status metrics, and a data collection point to collect the environment metrics inside the car. So in this example the car would have three data collection points. In the meters example, d1001, d1002, d1003, and d1004 are the data collection points.
+Data Collection Point (DCP) refers to hardware or software that collects metrics based on preset time periods or triggered by events. A data collection point can collect one or multiple metrics, but these metrics are collected at the same time and have the same time stamp. For some complex equipment, there are often multiple data collection points, and the sampling rate of each collection point may be different, and fully independent. For example, for a car, there could be a data collection point to collect GPS position metrics, a data collection point to collect engine status metrics, and a data collection point to collect the environment metrics inside the car. So in this example the car would have three data collection points. In the smart meters example, d1001, d1002, d1003, and d1004 are the data collection points.
 
 ## Table
 
@@ -137,7 +137,7 @@ The design of one table for one data collection point will require a huge number
 
 STable is a template for a type of data collection point. A STable contains a set of data collection points (tables) that have the same schema or data structure, but with different static attributes (tags). To describe a STable, in addition to defining the table structure of the metrics, it is also necessary to define the schema of its tags. The data type of tags can be int, float, string, and there can be multiple tags, which can be added, deleted, or modified afterward. If the whole system has N different types of data collection points, N STables need to be established.
 
-In the design of TDengine, **a table is used to represent a specific data collection point, and STable is used to represent a set of data collection points of the same type**. In the meters example, we can create a super table named `meters`.
+In the design of TDengine, **a table is used to represent a specific data collection point, and STable is used to represent a set of data collection points of the same type**. In the smart meters example, we can create a super table named `meters`.
 
 ## Subtable
 
@@ -156,9 +156,9 @@ The relationship between a STable and the subtables created based on this STable
 
 Queries can be executed on both a table (subtable) and a STable. For a query on a STable, TDengine will treat the data in all its subtables as a whole data set for processing. TDengine will first find the subtables that meet the tag filter conditions, then scan the time-series data of these subtables to perform aggregation operation, which reduces the number of data sets to be scanned which in turn greatly improves the performance of data aggregation across multiple DCPs. In essence, querying a supertable is a very efficient aggregate query on multiple DCPs of the same type.
 
-In TDengine, it is recommended to use a subtable instead of a regular table for a DCP. In the meters example, we can create subtables like d1001, d1002, d1003, and d1004 under super table meters.
+In TDengine, it is recommended to use a subtable instead of a regular table for a DCP. In the smart meters example, we can create subtables like d1001, d1002, d1003, and d1004 under super table meters.
 
-To better understand the data model using super table and subtable, please refer to the diagram below which demonstrates the data model of meters example. ![Meters Data Model Diagram](./supertable.webp)
+To better understand the data model using metri, tags, super table and subtable, please refer to the diagram below which demonstrates the data model of the smart meters example. ![Meters Data Model Diagram](./supertable.webp)
 
 ## Database