Merge branch 'main' into test/cyjia0227

Jenkinsfile2

@@ -387,7 +387,7 @@ pipeline {
                     }
                     steps {
                         catchError(buildResult: 'FAILURE', stageResult: 'FAILURE') {
-                            timeout(time: 75, unit: 'MINUTES'){
+                            timeout(time: 126, unit: 'MINUTES'){
                                 pre_test_win()
                                 pre_test_build_win()
                                 run_win_ctest()

cmake/taosadapter_CMakeLists.txt.in

@@ -2,7 +2,7 @@
 # taosadapter
 ExternalProject_Add(taosadapter
         GIT_REPOSITORY https://github.com/taosdata/taosadapter.git
-        GIT_TAG db6c843
+        GIT_TAG 7920f98
         SOURCE_DIR "${TD_SOURCE_DIR}/tools/taosadapter"
         BINARY_DIR ""
         #BUILD_IN_SOURCE TRUE

cmake/taostools_CMakeLists.txt.in

@@ -2,7 +2,7 @@
 # taos-tools
 ExternalProject_Add(taos-tools
         GIT_REPOSITORY https://github.com/taosdata/taos-tools.git
-        GIT_TAG 1e15545
+        GIT_TAG 0111c66
         SOURCE_DIR "${TD_SOURCE_DIR}/tools/taos-tools"
         BINARY_DIR ""
         #BUILD_IN_SOURCE TRUE

docs/zh/14-reference/07-tdinsight/index.mdx

@@ -140,10 +140,10 @@ Install and configure TDinsight dashboard in Grafana on Ubuntu 18.04/20.04 syste
 | -n     | --tdengine-ds-name         | TDENGINE_DS_NAME             | TDengine 数据源名称，默认为 TDengine。                  |
 | -a     | --tdengine-api             | TDENGINE_API                 | TDengine REST API 端点。默认为`http://127.0.0.1:6041`。 |
 | -u     | --tdengine-user            | TDENGINE_USER                | TDengine 用户名。 [默认值：root]                        |
-| -p     | --tdengine-密码            | TDENGINE_PASSWORD            | TDengine 密码。 [默认：taosdata]                        |
+| -p     | --tdengine-password        | TDENGINE_PASSWORD            | TDengine 密码。 [默认：taosdata]                        |
 | -i     | --tdinsight-uid            | TDINSIGHT_DASHBOARD_UID      | TDinsight 仪表盘`uid`。 [默认值：tdinsight]             |
 | -t     | --tdinsight-title          | TDINSIGHT_DASHBOARD_TITLE    | TDinsight 仪表盘标题。 [默认：TDinsight]                |
-| -e     | --tdinsight-可编辑         | TDINSIGHT_DASHBOARD_EDITABLE | 如果配置仪表盘可以编辑。 [默认值：false]                |
+| -e     | --tdinsight-editable       | TDINSIGHT_DASHBOARD_EDITABLE | 如果配置仪表盘可以编辑。 [默认值：false]                |
 | -E     | --external-notifier        | EXTERNAL_NOTIFIER            | 将外部通知程序 uid 应用于 TDinsight 仪表盘。            |
 
 假设您在主机 `tdengine` 上启动 TDengine 数据库，HTTP API 端口为 `6041`，用户为 `root1`，密码为 `pass5ord`。执行脚本：

examples/JDBC/springbootdemo/readme.md

@@ -1,6 +1,13 @@
 ## TDengine SpringBoot + Mybatis Demo
 
 ## 需要提前创建 test 数据库
+
+```
+$ taos -s 'create database if not exists test'
+
+$ curl http://localhost:8080/weather/init
+```
+
 ### 配置 application.properties
 ```properties
 # datasource config

examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/dao/WeatherMapper.xml

@@ -7,6 +7,7 @@
         <id column="ts" jdbcType="TIMESTAMP" property="ts"/>
         <result column="temperature" jdbcType="FLOAT" property="temperature"/>
         <result column="humidity" jdbcType="FLOAT" property="humidity"/>
+        <result column="bytes" jdbcType="BINARY" property="bytes" />
     </resultMap>
 
     <select id="lastOne" resultType="java.util.Map">
@@ -36,6 +37,11 @@
             binary
         (
             64
+        ),
+            bytes
+            binary
+        (
+            64
         )) tags
         (
             location nchar
@@ -63,8 +69,8 @@
     </select>
 
     <insert id="insert" parameterType="com.taosdata.example.springbootdemo.domain.Weather">
-        insert into test.t#{groupId} (ts, temperature, humidity, note)
+        insert into test.t#{groupId} (ts, temperature, humidity, note, bytes)
-        values (#{ts}, ${temperature}, ${humidity}, #{note})
+        values (#{ts}, ${temperature}, ${humidity}, #{note}, #{bytes})
     </insert>
 
     <select id="getSubTables" resultType="String">

examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/domain/Weather.java

@@ -2,6 +2,7 @@ package com.taosdata.example.springbootdemo.domain;
 
 import com.fasterxml.jackson.annotation.JsonFormat;
 
+import java.nio.charset.StandardCharsets;
 import java.sql.Timestamp;
 
 public class Weather {
@@ -12,6 +13,9 @@ public class Weather {
     private Float humidity;
     private String location;
     private String note;
+    // In rest mode, the byte[] type is not recommended.
+    // UTF-8 is used to encode the byte arrays, that result may affect the SQL correctness
+    private byte[] bytes;
     private int groupId;
 
     public Weather() {
@@ -70,4 +74,30 @@ public class Weather {
     public void setNote(String note) {
         this.note = note;
     }
+
+    public byte[] getBytes() {
+        return bytes;
+    }
+
+    public void setBytes(byte[] bytes) {
+        this.bytes = bytes;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("Weather{");
+        sb.append("ts=").append(ts);
+        sb.append(", temperature=").append(temperature);
+        sb.append(", humidity=").append(humidity);
+        sb.append(", location='").append(location).append('\'');
+        sb.append(", note='").append(note).append('\'');
+        sb.append(", bytes -> string=");
+        if (bytes == null) sb.append("null");
+        else {
+            sb.append(new String(bytes, StandardCharsets.UTF_8));
+        }
+        sb.append(", groupId=").append(groupId);
+        sb.append('}');
+        return sb.toString();
+    }
 }

examples/JDBC/springbootdemo/src/main/java/com/taosdata/example/springbootdemo/service/WeatherService.java

@@ -5,6 +5,7 @@ import com.taosdata.example.springbootdemo.domain.Weather;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
+import java.nio.charset.StandardCharsets;
 import java.sql.Timestamp;
 import java.util.List;
 import java.util.Map;
@@ -30,6 +31,7 @@ public class WeatherService {
             weather.setLocation(locations[random.nextInt(locations.length)]);
             weather.setGroupId(i % locations.length);
             weather.setNote("note-" + i);
+            weather.setBytes(locations[random.nextInt(locations.length)].getBytes(StandardCharsets.UTF_8));
             weatherMapper.createTable(weather);
             count += weatherMapper.insert(weather);
         }

include/common/tglobal.h

@@ -50,6 +50,7 @@ extern int32_t tsTagFilterResCacheSize;
 // queue & threads
 extern int32_t tsNumOfRpcThreads;
 extern int32_t tsNumOfRpcSessions;
+extern int32_t tsTimeToGetAvailableConn;
 extern int32_t tsNumOfCommitThreads;
 extern int32_t tsNumOfTaskQueueThreads;
 extern int32_t tsNumOfMnodeQueryThreads;

include/common/tmsg.h

@@ -929,12 +929,19 @@ typedef struct {
   int32_t minRows;
   int32_t maxRows;
   int32_t walFsyncPeriod;
+  int16_t hashPrefix;
+  int16_t hashSuffix;
   int8_t  walLevel;
   int8_t  precision;
   int8_t  compression;
   int8_t  replications;
   int8_t  strict;
   int8_t  cacheLast;
+  int32_t tsdbPageSize;
+  int32_t walRetentionPeriod;
+  int32_t walRollPeriod;
+  int64_t walRetentionSize;
+  int64_t walSegmentSize;
   int32_t numOfRetensions;
   SArray* pRetensions;
   int8_t  schemaless;
@@ -1812,7 +1819,7 @@ typedef struct {
 #define STREAM_TRIGGER_AT_ONCE        1
 #define STREAM_TRIGGER_WINDOW_CLOSE   2
 #define STREAM_TRIGGER_MAX_DELAY      3
-#define STREAM_DEFAULT_IGNORE_EXPIRED 0
+#define STREAM_DEFAULT_IGNORE_EXPIRED 1
 #define STREAM_FILL_HISTORY_ON        1
 #define STREAM_FILL_HISTORY_OFF       0
 #define STREAM_DEFAULT_FILL_HISTORY   STREAM_FILL_HISTORY_OFF
@@ -2684,7 +2691,7 @@ typedef struct {
   char    subKey[TSDB_SUBSCRIBE_KEY_LEN];
   int8_t  subType;
   int8_t  withMeta;
-  char*   qmsg;
+  char*   qmsg;     //SubPlanToString
   int64_t suid;
 } SMqRebVgReq;
 

include/common/ttypes.h

@@ -53,10 +53,6 @@ typedef struct {
 #define varDataNetLen(v)  (htons(((VarDataLenT *)(v))[0]))
 #define varDataNetTLen(v) (sizeof(VarDataLenT) + varDataNetLen(v))
 
-// this data type is internally used only in 'in' query to hold the values
-#define TSDB_DATA_TYPE_POINTER_ARRAY (1000)
-#define TSDB_DATA_TYPE_VALUE_ARRAY   (1001)
-
 #define GET_TYPED_DATA(_v, _finalType, _type, _data) \
   do {                                               \
     switch (_type) {                                 \

include/libs/nodes/cmdnodes.h

@@ -265,6 +265,7 @@ typedef struct SShowStmt {
 typedef struct SShowCreateDatabaseStmt {
   ENodeType type;
   char      dbName[TSDB_DB_NAME_LEN];
+  char      dbFName[TSDB_DB_FNAME_LEN];
   void*     pCfg;  // SDbCfgInfo
 } SShowCreateDatabaseStmt;
 

include/libs/transport/thttp.h

@@ -17,6 +17,7 @@
 #define _TD_UTIL_HTTP_H_
 
 #include "os.h"
+#include "tref.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -24,7 +25,8 @@ extern "C" {
 
 typedef enum { HTTP_GZIP, HTTP_FLAT } EHttpCompFlag;
 
-int32_t taosSendHttpReport(const char* server, const char* uri, uint16_t port, char* pCont, int32_t contLen, EHttpCompFlag flag);
+int32_t taosSendHttpReport(const char* server, const char* uri, uint16_t port, char* pCont, int32_t contLen,
+                           EHttpCompFlag flag);
 
 #ifdef __cplusplus
 }

include/libs/transport/trpc.h

@@ -114,7 +114,7 @@ typedef struct SRpcInit {
 
   int32_t connLimitNum;
   int32_t connLimitLock;
-
+  int32_t timeToGetConn;
   int8_t  supportBatch;  // 0: no batch, 1. batch
   int32_t batchSize;
   void   *parent;

include/os/osMemory.h

@@ -29,9 +29,11 @@ extern "C" {
 #define calloc  CALLOC_FUNC_TAOS_FORBID
 #define realloc REALLOC_FUNC_TAOS_FORBID
 #define free    FREE_FUNC_TAOS_FORBID
+#ifdef strdup
+#undef strdup
 #define strdup  STRDUP_FUNC_TAOS_FORBID
+#endif
 #endif // ifndef ALLOW_FORBID_FUNC
-
 #endif // if !defined(WINDOWS)
 
 int32_t taosMemoryDbgInit();

include/util/taoserror.h

@@ -116,6 +116,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_NO_DISKSPACE                  TAOS_DEF_ERROR_CODE(0, 0x012B)
 #define TSDB_CODE_TIMEOUT_ERROR                 TAOS_DEF_ERROR_CODE(0, 0x012C)
 #define TSDB_CODE_MSG_ENCODE_ERROR              TAOS_DEF_ERROR_CODE(0, 0x012D)
+#define TSDB_CODE_NO_ENOUGH_DISKSPACE           TAOS_DEF_ERROR_CODE(0, 0x012E)
 
 #define TSDB_CODE_APP_IS_STARTING               TAOS_DEF_ERROR_CODE(0, 0x0130) //
 #define TSDB_CODE_APP_IS_STOPPING               TAOS_DEF_ERROR_CODE(0, 0x0131) //

include/util/ttrace.h

@@ -59,11 +59,13 @@ typedef struct STraceId {
     char*   _t = _buf;                                            \
     _t[0] = '0';                                                  \
     _t[1] = 'x';                                                  \
-    _t += titoa(rootId, 16, &_t[2]);                              \
+    _t += 2;                                                      \
+    _t += titoa(rootId, 16, &_t[0]);                              \
     _t[0] = ':';                                                  \
     _t[1] = '0';                                                  \
     _t[2] = 'x';                                                  \
-    _t += titoa(msgId, 16, &_t[3]);                               \
+    _t += 3;                                                      \
+    _t += titoa(msgId, 16, &_t[0]);                               \
   } while (0)
 
 #ifdef __cplusplus

packaging/tools/install.sh

@@ -34,6 +34,7 @@ benchmarkName="taosBenchmark"
 dumpName="taosdump"
 demoName="taosdemo"
 xname="taosx"
+explorerName="${clientName}-explorer"
 
 clientName2="taos"
 serverName2="taosd"
@@ -214,6 +215,7 @@ function install_bin() {
   ${csudo}rm -f ${bin_link_dir}/${benchmarkName} || :
   ${csudo}rm -f ${bin_link_dir}/${dumpName} || :
   ${csudo}rm -f ${bin_link_dir}/${xname} || :
+  ${csudo}rm -f ${bin_link_dir}/${explorerName} || :
   ${csudo}rm -f ${bin_link_dir}/set_core || :
   ${csudo}rm -f ${bin_link_dir}/TDinsight.sh || :
 
@@ -228,6 +230,7 @@ function install_bin() {
   [ -x ${install_main_dir}/bin/${benchmarkName} ] && ${csudo}ln -sf ${install_main_dir}/bin/${benchmarkName} ${bin_link_dir}/${benchmarkName} || :
   [ -x ${install_main_dir}/bin/${dumpName} ] && ${csudo}ln -s ${install_main_dir}/bin/${dumpName} ${bin_link_dir}/${dumpName} || :
   [ -x ${install_main_dir}/bin/${xname} ] && ${csudo}ln -s ${install_main_dir}/bin/${xname} ${bin_link_dir}/${xname} || :
+  [ -x ${install_main_dir}/bin/${explorerName} ] && ${csudo}ln -s ${install_main_dir}/bin/${explorerName} ${bin_link_dir}/${explorerName} || :
   [ -x ${install_main_dir}/bin/TDinsight.sh ] && ${csudo}ln -s ${install_main_dir}/bin/TDinsight.sh ${bin_link_dir}/TDinsight.sh || :
   [ -x ${install_main_dir}/bin/remove.sh ] && ${csudo}ln -s ${install_main_dir}/bin/remove.sh ${bin_link_dir}/${uninstallScript} || :
   [ -x ${install_main_dir}/bin/set_core.sh ] && ${csudo}ln -s ${install_main_dir}/bin/set_core.sh ${bin_link_dir}/set_core || :

packaging/tools/make_install.bat

@@ -70,6 +70,9 @@ if %Enterprise% == TRUE (
     if exist %binary_dir%\\build\\bin\\taosx.exe (
         copy %binary_dir%\\build\\bin\\taosx.exe %target_dir% > nul
     )
+    if exist %binary_dir%\\build\\bin\\taos-explorer.exe (
+        copy %binary_dir%\\build\\bin\\taos-explorer.exe %target_dir% > nul
+    )
     if exist %binary_dir%\\build\\bin\\tmq_sim.exe (
         copy %binary_dir%\\build\\bin\\tmq_sim.exe %target_dir% > nul
     )

packaging/tools/makepkg.sh

@@ -89,11 +89,13 @@ else
       ${build_dir}/bin/tdengine-datasource.zip \
       ${build_dir}/bin/tdengine-datasource.zip.md5sum"
   [ -f ${build_dir}/bin/taosx ] && taosx_bin="${build_dir}/bin/taosx"
+  explorer_bin_files=$(find ${build_dir}/bin/ -name '*-explorer')
 
   bin_files="${build_dir}/bin/${serverName} \
       ${build_dir}/bin/${clientName} \
       ${taostools_bin_files} \
       ${taosx_bin} \
+      ${explorer_bin_files} \
       ${build_dir}/bin/taosadapter \
       ${build_dir}/bin/udfd \
       ${script_dir}/remove.sh \

packaging/tools/remove.sh

@@ -119,6 +119,7 @@ function clean_bin() {
   ${csudo}rm -f ${bin_link_dir}/TDinsight.sh || :
   ${csudo}rm -f ${bin_link_dir}/taoskeeper || :
   ${csudo}rm -f ${bin_link_dir}/taosx || :
+  ${csudo}rm -f ${bin_link_dir}/taos-explorer || :
 
   if [ "$verMode" == "cluster" ] && [ "$clientName" != "$clientName2" ]; then
     ${csudo}rm -f ${bin_link_dir}/${clientName2} || :

source/client/inc/clientInt.h

@@ -67,6 +67,7 @@ typedef struct SAppInstInfo SAppInstInfo;
 
 typedef struct {
   char*   key;
+  int32_t idx;
   // statistics
   int32_t reportCnt;
   int32_t connKeyCnt;

source/client/jni/com_taosdata_jdbc_tmq_TMQConnector.h

@@ -99,6 +99,9 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqCommitSync(JNI
  */
 JNIEXPORT void JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqCommitAsync(JNIEnv *, jobject, jlong, jlong, jobject);
 
+JNIEXPORT void JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_consumerCommitAsync(JNIEnv *, jobject, jlong, jlong,
+                                                                                   jobject);
+
 /*
  * Class:     com_taosdata_jdbc_tmq_TMQConnector
  * Method:    tmqUnsubscribeImp

source/client/src/clientEnv.c

@@ -144,7 +144,7 @@ void *openTransporter(const char *user, const char *auth, int32_t numOfThread) {
   memset(&rpcInit, 0, sizeof(rpcInit));
   rpcInit.localPort = 0;
   rpcInit.label = "TSC";
-  rpcInit.numOfThreads = numOfThread;
+  rpcInit.numOfThreads = tsNumOfRpcThreads;
   rpcInit.cfp = processMsgFromServer;
   rpcInit.rfp = clientRpcRfp;
   rpcInit.sessions = 1024;
@@ -159,6 +159,12 @@ void *openTransporter(const char *user, const char *auth, int32_t numOfThread) {
   rpcInit.retryMaxInterval = tsRedirectMaxPeriod;
   rpcInit.retryMaxTimouet = tsMaxRetryWaitTime;
 
+  int32_t connLimitNum = tsNumOfRpcSessions / (tsNumOfRpcThreads * 5);
+  connLimitNum = TMAX(connLimitNum, 10);
+  connLimitNum = TMIN(connLimitNum, 500);
+  rpcInit.connLimitNum = connLimitNum;
+  rpcInit.timeToGetConn = tsTimeToGetAvailableConn;
+
   void *pDnodeConn = rpcOpen(&rpcInit);
   if (pDnodeConn == NULL) {
     tscError("failed to init connection to server");

source/client/src/clientHb.c

@@ -303,8 +303,12 @@ static int32_t hbQueryHbRspHandle(SAppHbMgr *pAppHbMgr, SClientHbRsp *pRsp) {
 }
 
 static int32_t hbAsyncCallBack(void *param, SDataBuf *pMsg, int32_t code) {
+  if (0 == atomic_load_8(&clientHbMgr.inited)) {
+    goto _return;
+  }
+
   static int32_t    emptyRspNum = 0;
-  char             *key = (char *)param;
+  int32_t idx = *(int32_t *)param;
   SClientHbBatchRsp pRsp = {0};
   if (TSDB_CODE_SUCCESS == code) {
     tDeserializeSClientHbBatchRsp(pMsg->pData, pMsg->len, &pRsp);
@@ -319,22 +323,24 @@ static int32_t hbAsyncCallBack(void *param, SDataBuf *pMsg, int32_t code) {
 
   int32_t rspNum = taosArrayGetSize(pRsp.rsps);
 
-  taosThreadMutexLock(&appInfo.mutex);
+  taosThreadMutexLock(&clientHbMgr.lock);
 
-  SAppInstInfo **pInst = taosHashGet(appInfo.pInstMap, key, strlen(key));
+  SAppHbMgr *pAppHbMgr = taosArrayGetP(clientHbMgr.appHbMgrs, idx);
-  if (pInst == NULL || NULL == *pInst) {
+  if (pAppHbMgr == NULL) {
-    taosThreadMutexUnlock(&appInfo.mutex);
+    taosThreadMutexUnlock(&clientHbMgr.lock);
-    tscError("cluster not exist, key:%s", key);
+    tscError("appHbMgr not exist, idx:%d", idx);
     taosMemoryFree(pMsg->pData);
     taosMemoryFree(pMsg->pEpSet);
     tFreeClientHbBatchRsp(&pRsp);
     return -1;
   }
 
+  SAppInstInfo *pInst = pAppHbMgr->pAppInstInfo;
+
   if (code != 0) {
-    (*pInst)->onlineDnodes = ((*pInst)->totalDnodes ? 0 : -1);
+    pInst->onlineDnodes = pInst->totalDnodes ? 0 : -1;
-    tscDebug("hb rsp error %s, update server status %d/%d", tstrerror(code), (*pInst)->onlineDnodes,
+    tscDebug("hb rsp error %s, update server status %d/%d", tstrerror(code), pInst->onlineDnodes,
-             (*pInst)->totalDnodes);
+             pInst->totalDnodes);
   }
 
   if (rspNum) {
@@ -346,15 +352,17 @@ static int32_t hbAsyncCallBack(void *param, SDataBuf *pMsg, int32_t code) {
 
   for (int32_t i = 0; i < rspNum; ++i) {
     SClientHbRsp *rsp = taosArrayGet(pRsp.rsps, i);
-    code = (*clientHbMgr.rspHandle[rsp->connKey.connType])((*pInst)->pAppHbMgr, rsp);
+    code = (*clientHbMgr.rspHandle[rsp->connKey.connType])(pAppHbMgr, rsp);
     if (code) {
       break;
     }
   }
 
-  taosThreadMutexUnlock(&appInfo.mutex);
+  taosThreadMutexUnlock(&clientHbMgr.lock);
 
   tFreeClientHbBatchRsp(&pRsp);
+
+_return:
   taosMemoryFree(pMsg->pData);
   taosMemoryFree(pMsg->pEpSet);
   return code;
@@ -788,7 +796,8 @@ static void *hbThreadFunc(void *param) {
       pInfo->msgInfo.pData = buf;
       pInfo->msgInfo.len = tlen;
       pInfo->msgType = TDMT_MND_HEARTBEAT;
-      pInfo->param = taosStrdup(pAppHbMgr->key);
+      pInfo->param = taosMemoryMalloc(sizeof(int32_t));
+      *(int32_t *)pInfo->param = i;
       pInfo->paramFreeFp = taosMemoryFree;
       pInfo->requestId = generateRequestId();
       pInfo->requestObjRefId = 0;
@@ -874,6 +883,7 @@ SAppHbMgr *appHbMgrInit(SAppInstInfo *pAppInstInfo, char *key) {
 
   taosThreadMutexLock(&clientHbMgr.lock);
   taosArrayPush(clientHbMgr.appHbMgrs, &pAppHbMgr);
+  pAppHbMgr->idx = taosArrayGetSize(clientHbMgr.appHbMgrs) - 1;
   taosThreadMutexUnlock(&clientHbMgr.lock);
 
   return pAppHbMgr;

source/client/src/clientImpl.c

@@ -2034,6 +2034,12 @@ TSDB_SERVER_STATUS taos_check_server_status(const char* fqdn, int port, char* de
   rpcInit.compressSize = tsCompressMsgSize;
   rpcInit.user = "_dnd";
 
+  int32_t connLimitNum = tsNumOfRpcSessions / (tsNumOfRpcThreads * 3);
+  connLimitNum = TMAX(connLimitNum, 10);
+  connLimitNum = TMIN(connLimitNum, 500);
+  rpcInit.connLimitNum = connLimitNum;
+  rpcInit.timeToGetConn = tsTimeToGetAvailableConn;
+
   clientRpc = rpcOpen(&rpcInit);
   if (clientRpc == NULL) {
     tscError("failed to init server status client");

source/client/src/clientJniConnector.c

@@ -56,6 +56,7 @@ jmethodID g_createConsumerErrorCallback;
 jmethodID g_topicListCallback;
 
 jclass    g_consumerClass;
+// deprecated
 jmethodID g_commitCallback;
 
 void jniGetGlobalMethod(JNIEnv *env) {

source/client/src/clientTmqConnector.c

@@ -17,6 +17,36 @@
 #include "jniCommon.h"
 #include "taos.h"
 
+int __init_tmq = 0;
+jmethodID g_offsetCallback;
+
+void tmqGlobalMethod(JNIEnv *env) {
+  // make sure init function executed once
+  switch (atomic_val_compare_exchange_32(&__init_tmq, 0, 1)) {
+    case 0:
+      break;
+    case 1:
+      do {
+        taosMsleep(0);
+      } while (atomic_load_32(&__init_tmq) == 1);
+    case 2:
+      return;
+  }
+
+  if (g_vm == NULL) {
+    (*env)->GetJavaVM(env, &g_vm);
+  }
+
+  jclass offset = (*env)->FindClass(env, "com/taosdata/jdbc/tmq/OffsetWaitCallback");
+  jclass g_offsetCallbackClass = (*env)->NewGlobalRef(env, offset);
+  g_offsetCallback = (*env)->GetMethodID(env, g_offsetCallbackClass, "commitCallbackHandler", "(I)V");
+  (*env)->DeleteLocalRef(env, offset);
+
+  atomic_store_32(&__init_tmq, 2);
+  jniDebug("tmq method register finished");
+}
+
+// deprecated
 void commit_cb(tmq_t *tmq, int32_t code, void *param) {
   JNIEnv *env = NULL;
   int     status = (*g_vm)->GetEnv(g_vm, (void **)&env, JNI_VERSION_1_6);
@@ -40,6 +70,28 @@ void commit_cb(tmq_t *tmq, int32_t code, void *param) {
   env = NULL;
 }
 
+void consumer_callback(tmq_t *tmq, int32_t code, void *param) {
+  JNIEnv *env = NULL;
+  int     status = (*g_vm)->GetEnv(g_vm, (void **)&env, JNI_VERSION_1_6);
+  bool    needDetach = false;
+  if (status < 0) {
+    if ((*g_vm)->AttachCurrentThread(g_vm, (void **)&env, NULL) != 0) {
+      return;
+    }
+    needDetach = true;
+  }
+
+  jobject obj = (jobject)param;
+  (*env)->CallVoidMethod(env, obj, g_offsetCallback, code);
+  (*env)->DeleteGlobalRef(env, obj);
+  param = NULL;
+
+  if (needDetach) {
+    (*g_vm)->DetachCurrentThread(g_vm);
+  }
+  env = NULL;
+}
+
 JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqConfNewImp(JNIEnv *env, jobject jobj) {
   tmq_conf_t *conf = tmq_conf_new();
   jniGetGlobalMethod(env);
@@ -201,6 +253,7 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqCommitSync(JNI
   return tmq_commit_sync(tmq, res);
 }
 
+// deprecated
 JNIEXPORT void JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqCommitAsync(JNIEnv *env, jobject jobj, jlong jtmq,
                                                                               jlong jres, jobject consumer) {
   tmq_t *tmq = (tmq_t *)jtmq;
@@ -213,6 +266,19 @@ JNIEXPORT void JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqCommitAsync(JN
   tmq_commit_async(tmq, res, commit_cb, consumer);
 }
 
+JNIEXPORT void JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_consumerCommitAsync(JNIEnv *env, jobject jobj, jlong jtmq,
+                                                                              jlong jres, jobject offset) {
+  tmqGlobalMethod(env);
+  tmq_t *tmq = (tmq_t *)jtmq;
+  if (tmq == NULL) {
+    jniError("jobj:%p, tmq is closed", jobj);
+    return;
+  }
+  TAOS_RES *res = (TAOS_RES *)jres;
+  offset = (*env)->NewGlobalRef(env, offset);
+  tmq_commit_async(tmq, res, consumer_callback, offset);
+}
+
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqUnsubscribeImp(JNIEnv *env, jobject jobj,
                                                                                  jlong jtmq) {
   tmq_t *tmq = (tmq_t *)jtmq;

source/common/src/tglobal.c

@@ -41,7 +41,8 @@ bool    tsPrintAuth = false;
 
 // queue & threads
 int32_t tsNumOfRpcThreads = 1;
-int32_t tsNumOfRpcSessions = 2000;
+int32_t tsNumOfRpcSessions = 6000;
+int32_t tsTimeToGetAvailableConn = 500000;
 int32_t tsNumOfCommitThreads = 2;
 int32_t tsNumOfTaskQueueThreads = 4;
 int32_t tsNumOfMnodeQueryThreads = 4;
@@ -326,6 +327,12 @@ static int32_t taosAddClientCfg(SConfig *pCfg) {
   if (cfgAddBool(pCfg, "useAdapter", tsUseAdapter, true) != 0) return -1;
   if (cfgAddBool(pCfg, "crashReporting", tsEnableCrashReport, true) != 0) return -1;
 
+  tsNumOfRpcSessions = TRANGE(tsNumOfRpcSessions, 100, 100000);
+  if (cfgAddInt32(pCfg, "numOfRpcSessions", tsNumOfRpcSessions, 1, 100000, 0) != 0) return -1;
+
+  tsTimeToGetAvailableConn = TRANGE(tsTimeToGetAvailableConn, 20, 10000000);
+  if (cfgAddInt32(pCfg, "timeToGetAvailableConn", tsTimeToGetAvailableConn, 20, 1000000, 0) != 0) return -1;
+
   tsNumOfTaskQueueThreads = tsNumOfCores / 2;
   tsNumOfTaskQueueThreads = TMAX(tsNumOfTaskQueueThreads, 4);
   if (tsNumOfTaskQueueThreads >= 10) {
@@ -397,6 +404,9 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
   tsNumOfRpcSessions = TRANGE(tsNumOfRpcSessions, 100, 10000);
   if (cfgAddInt32(pCfg, "numOfRpcSessions", tsNumOfRpcSessions, 1, 100000, 0) != 0) return -1;
 
+  tsTimeToGetAvailableConn = TRANGE(tsTimeToGetAvailableConn, 20, 1000000);
+  if (cfgAddInt32(pCfg, "timeToGetAvailableConn", tsNumOfRpcSessions, 20, 1000000, 0) != 0) return -1;
+
   tsNumOfCommitThreads = tsNumOfCores / 2;
   tsNumOfCommitThreads = TRANGE(tsNumOfCommitThreads, 2, 4);
   if (cfgAddInt32(pCfg, "numOfCommitThreads", tsNumOfCommitThreads, 1, 1024, 0) != 0) return -1;
@@ -511,12 +521,18 @@ static int32_t taosUpdateServerCfg(SConfig *pCfg) {
 
   pItem = cfgGetItem(tsCfg, "numOfRpcSessions");
   if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {
-    tsNumOfRpcSessions = 2000;
     tsNumOfRpcSessions = TRANGE(tsNumOfRpcSessions, 100, 10000);
     pItem->i32 = tsNumOfRpcSessions;
     pItem->stype = stype;
   }
 
+  pItem = cfgGetItem(tsCfg, "timeToGetAvailableConn");
+  if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {
+    tsTimeToGetAvailableConn = TRANGE(tsTimeToGetAvailableConn, 20, 1000000);
+    pItem->i32 = tsTimeToGetAvailableConn;
+    pItem->stype = stype;
+  }
+
   pItem = cfgGetItem(tsCfg, "numOfCommitThreads");
   if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {
     tsNumOfCommitThreads = numOfCores / 2;
@@ -698,6 +714,10 @@ static int32_t taosSetClientCfg(SConfig *pCfg) {
   tsEnableCrashReport = cfgGetItem(pCfg, "crashReporting")->bval;
 
   tsMaxRetryWaitTime = cfgGetItem(pCfg, "maxRetryWaitTime")->i32;
+
+  tsNumOfRpcSessions = cfgGetItem(pCfg, "numOfRpcSessions")->i32;
+
+  tsTimeToGetAvailableConn = cfgGetItem(pCfg, "timeToGetAvailableConn")->i32;
   return 0;
 }
 
@@ -735,6 +755,8 @@ static int32_t taosSetServerCfg(SConfig *pCfg) {
 
   tsNumOfRpcThreads = cfgGetItem(pCfg, "numOfRpcThreads")->i32;
   tsNumOfRpcSessions = cfgGetItem(pCfg, "numOfRpcSessions")->i32;
+  tsTimeToGetAvailableConn = cfgGetItem(pCfg, "timeToGetAvailableConn")->i32;
+
   tsNumOfCommitThreads = cfgGetItem(pCfg, "numOfCommitThreads")->i32;
   tsNumOfMnodeReadThreads = cfgGetItem(pCfg, "numOfMnodeReadThreads")->i32;
   tsNumOfVnodeQueryThreads = cfgGetItem(pCfg, "numOfVnodeQueryThreads")->i32;
@@ -742,7 +764,7 @@ static int32_t taosSetServerCfg(SConfig *pCfg) {
   tsNumOfVnodeFetchThreads = cfgGetItem(pCfg, "numOfVnodeFetchThreads")->i32;
   tsNumOfVnodeRsmaThreads = cfgGetItem(pCfg, "numOfVnodeRsmaThreads")->i32;
   tsNumOfQnodeQueryThreads = cfgGetItem(pCfg, "numOfQnodeQueryThreads")->i32;
-  //  tsNumOfQnodeFetchThreads = cfgGetItem(pCfg, "numOfQnodeFetchThreads")->i32;
+  //  tsNumOfQnodeFetchThreads = cfgGetItem(pCfg, "numOfQnodeFetchTereads")->i32;
   tsNumOfSnodeStreamThreads = cfgGetItem(pCfg, "numOfSnodeSharedThreads")->i32;
   tsNumOfSnodeWriteThreads = cfgGetItem(pCfg, "numOfSnodeUniqueThreads")->i32;
   tsRpcQueueMemoryAllowed = cfgGetItem(pCfg, "rpcQueueMemoryAllowed")->i64;

source/common/src/tmsg.c

@@ -2865,12 +2865,19 @@ int32_t tSerializeSDbCfgRsp(void *buf, int32_t bufLen, const SDbCfgRsp *pRsp) {
   if (tEncodeI32(&encoder, pRsp->minRows) < 0) return -1;
   if (tEncodeI32(&encoder, pRsp->maxRows) < 0) return -1;
   if (tEncodeI32(&encoder, pRsp->walFsyncPeriod) < 0) return -1;
+  if (tEncodeI16(&encoder, pRsp->hashPrefix) < 0) return -1;
+  if (tEncodeI16(&encoder, pRsp->hashSuffix) < 0) return -1;
   if (tEncodeI8(&encoder, pRsp->walLevel) < 0) return -1;
   if (tEncodeI8(&encoder, pRsp->precision) < 0) return -1;
   if (tEncodeI8(&encoder, pRsp->compression) < 0) return -1;
   if (tEncodeI8(&encoder, pRsp->replications) < 0) return -1;
   if (tEncodeI8(&encoder, pRsp->strict) < 0) return -1;
   if (tEncodeI8(&encoder, pRsp->cacheLast) < 0) return -1;
+  if (tEncodeI32(&encoder, pRsp->tsdbPageSize) < 0) return -1;
+  if (tEncodeI32(&encoder, pRsp->walRetentionPeriod) < 0) return -1;
+  if (tEncodeI32(&encoder, pRsp->walRollPeriod) < 0) return -1;
+  if (tEncodeI64(&encoder, pRsp->walRetentionSize) < 0) return -1;
+  if (tEncodeI64(&encoder, pRsp->walSegmentSize) < 0) return -1;
   if (tEncodeI32(&encoder, pRsp->numOfRetensions) < 0) return -1;
   for (int32_t i = 0; i < pRsp->numOfRetensions; ++i) {
     SRetention *pRetension = taosArrayGet(pRsp->pRetensions, i);
@@ -2905,12 +2912,19 @@ int32_t tDeserializeSDbCfgRsp(void *buf, int32_t bufLen, SDbCfgRsp *pRsp) {
   if (tDecodeI32(&decoder, &pRsp->minRows) < 0) return -1;
   if (tDecodeI32(&decoder, &pRsp->maxRows) < 0) return -1;
   if (tDecodeI32(&decoder, &pRsp->walFsyncPeriod) < 0) return -1;
+  if (tDecodeI16(&decoder, &pRsp->hashPrefix) < 0) return -1;
+  if (tDecodeI16(&decoder, &pRsp->hashSuffix) < 0) return -1;
   if (tDecodeI8(&decoder, &pRsp->walLevel) < 0) return -1;
   if (tDecodeI8(&decoder, &pRsp->precision) < 0) return -1;
   if (tDecodeI8(&decoder, &pRsp->compression) < 0) return -1;
   if (tDecodeI8(&decoder, &pRsp->replications) < 0) return -1;
   if (tDecodeI8(&decoder, &pRsp->strict) < 0) return -1;
   if (tDecodeI8(&decoder, &pRsp->cacheLast) < 0) return -1;
+  if (tDecodeI32(&decoder, &pRsp->tsdbPageSize) < 0) return -1;
+  if (tDecodeI32(&decoder, &pRsp->walRetentionPeriod) < 0) return -1;
+  if (tDecodeI32(&decoder, &pRsp->walRollPeriod) < 0) return -1;
+  if (tDecodeI64(&decoder, &pRsp->walRetentionSize) < 0) return -1;
+  if (tDecodeI64(&decoder, &pRsp->walSegmentSize) < 0) return -1;
   if (tDecodeI32(&decoder, &pRsp->numOfRetensions) < 0) return -1;
   if (pRsp->numOfRetensions > 0) {
     pRsp->pRetensions = taosArrayInit(pRsp->numOfRetensions, sizeof(SRetention));

source/common/src/tvariant.c

@@ -145,19 +145,6 @@ void taosVariantDestroy(SVariant *pVar) {
     pVar->nLen = 0;
   }
 
-  // NOTE: this is only for string array
-  if (pVar->nType == TSDB_DATA_TYPE_POINTER_ARRAY) {
-    size_t num = taosArrayGetSize(pVar->arr);
-    for (size_t i = 0; i < num; i++) {
-      void *p = taosArrayGetP(pVar->arr, i);
-      taosMemoryFree(p);
-    }
-    taosArrayDestroy(pVar->arr);
-    pVar->arr = NULL;
-  } else if (pVar->nType == TSDB_DATA_TYPE_VALUE_ARRAY) {
-    taosArrayDestroy(pVar->arr);
-    pVar->arr = NULL;
-  }
 }
 
 void taosVariantAssign(SVariant *pDst, const SVariant *pSrc) {
@@ -180,28 +167,8 @@ void taosVariantAssign(SVariant *pDst, const SVariant *pSrc) {
 
   if (IS_NUMERIC_TYPE(pSrc->nType) || (pSrc->nType == TSDB_DATA_TYPE_BOOL)) {
     pDst->i = pSrc->i;
-  } else if (pSrc->nType == TSDB_DATA_TYPE_POINTER_ARRAY) {  // this is only for string array
-    size_t num = taosArrayGetSize(pSrc->arr);
-    pDst->arr = taosArrayInit(num, sizeof(char *));
-    for (size_t i = 0; i < num; i++) {
-      char *p = (char *)taosArrayGetP(pSrc->arr, i);
-      char *n = taosStrdup(p);
-      taosArrayPush(pDst->arr, &n);
-    }
-  } else if (pSrc->nType == TSDB_DATA_TYPE_VALUE_ARRAY) {
-    size_t num = taosArrayGetSize(pSrc->arr);
-    pDst->arr = taosArrayInit(num, sizeof(int64_t));
-    pDst->nLen = pSrc->nLen;
-    ASSERT(pSrc->nLen == num);
-    for (size_t i = 0; i < num; i++) {
-      int64_t *p = taosArrayGet(pSrc->arr, i);
-      taosArrayPush(pDst->arr, p);
-    }
   }
 
-  if (pDst->nType != TSDB_DATA_TYPE_POINTER_ARRAY && pDst->nType != TSDB_DATA_TYPE_VALUE_ARRAY) {
-    pDst->nLen = tDataTypes[pDst->nType].bytes;
-  }
 }
 
 int32_t taosVariantCompare(const SVariant *p1, const SVariant *p2) {

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

@@ -192,8 +192,8 @@ static int32_t vmPutMsgToQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg, EQueueType qtyp
       taosWriteQitem(pVnode->pFetchQ, pMsg);
       break;
     case WRITE_QUEUE:
-      if (!osDataSpaceAvailable()) {
+      if (!osDataSpaceSufficient()) {
-        terrno = TSDB_CODE_NO_DISKSPACE;
+        terrno = TSDB_CODE_NO_ENOUGH_DISKSPACE;
         code = terrno;
         dError("vgId:%d, msg:%p put into vnode-write queue failed since %s", pVnode->vgId, pMsg, terrstr(code));
         break;

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

@@ -304,6 +304,7 @@ int32_t dmInitClient(SDnode *pDnode) {
   rpcInit.connLimitLock = 1;
   rpcInit.supportBatch = 1;
   rpcInit.batchSize = 8 * 1024;
+  rpcInit.timeToGetConn = tsTimeToGetAvailableConn;
 
   pTrans->clientRpc = rpcOpen(&rpcInit);
   if (pTrans->clientRpc == NULL) {

source/dnode/mgmt/node_util/inc/dmUtil.h

@@ -53,12 +53,12 @@ extern "C" {
 #define dDebug(...) { if (dDebugFlag & DEBUG_DEBUG) { taosPrintLog("DND ",       DEBUG_DEBUG, dDebugFlag, __VA_ARGS__); }}
 #define dTrace(...) { if (dDebugFlag & DEBUG_TRACE) { taosPrintLog("DND ",       DEBUG_TRACE, dDebugFlag, __VA_ARGS__); }}
 
-#define dGFatal(param, ...) { char buf[40] = {0}; TRACE_TO_STR(trace, buf); dFatal(param ", gtid:%s", __VA_ARGS__, buf);}
+#define dGFatal(param, ...) {if (dDebugFlag & DEBUG_FATAL) { char buf[40] = {0}; TRACE_TO_STR(trace, buf); dFatal(param ", gtid:%s", __VA_ARGS__, buf);}}
-#define dGError(param, ...) { char buf[40] = {0}; TRACE_TO_STR(trace, buf); dError(param ", gtid:%s", __VA_ARGS__, buf);}
+#define dGError(param, ...) {if (dDebugFlag & DEBUG_ERROR) { char buf[40] = {0}; TRACE_TO_STR(trace, buf); dError(param ", gtid:%s", __VA_ARGS__, buf);}}
-#define dGWarn(param, ...)  { char buf[40] = {0}; TRACE_TO_STR(trace, buf); dWarn (param ", gtid:%s", __VA_ARGS__, buf);}
+#define dGWarn(param, ...)  {if (dDebugFlag & DEBUG_WARN)  { char buf[40] = {0}; TRACE_TO_STR(trace, buf); dWarn(param ", gtid:%s", __VA_ARGS__, buf);}}
-#define dGInfo(param, ...)  { char buf[40] = {0}; TRACE_TO_STR(trace, buf); dInfo (param ", gtid:%s", __VA_ARGS__, buf);}
+#define dGInfo(param, ...)  {if (dDebugFlag & DEBUG_INFO)  { char buf[40] = {0}; TRACE_TO_STR(trace, buf); dInfo(param ", gtid:%s", __VA_ARGS__, buf);}}
-#define dGDebug(param, ...) { char buf[40] = {0}; TRACE_TO_STR(trace, buf); dDebug(param ", gtid:%s", __VA_ARGS__, buf);}
+#define dGDebug(param, ...) {if (dDebugFlag & DEBUG_DEBUG) { char buf[40] = {0}; TRACE_TO_STR(trace, buf); dDebug(param ", gtid:%s", __VA_ARGS__, buf);}}
-#define dGTrace(param, ...) { char buf[40] = {0}; TRACE_TO_STR(trace, buf); dTrace(param ", gtid:%s", __VA_ARGS__, buf);}
+#define dGTrace(param, ...) {if (dDebugFlag & DEBUG_TRACE) { char buf[40] = {0}; TRACE_TO_STR(trace, buf); dTrace(param ", gtid:%s", __VA_ARGS__, buf);}}
 
 // clang-format on
 

source/dnode/mnode/impl/CMakeLists.txt

@@ -2,8 +2,9 @@ aux_source_directory(src MNODE_SRC)
 IF (TD_PRIVILEGE)
   ADD_DEFINITIONS(-D_PRIVILEGE)
 ENDIF ()
-IF (TD_PRIVILEGE)
+IF (TD_ENTERPRISE)
   LIST(APPEND MNODE_SRC ${TD_ENTERPRISE_DIR}/src/plugins/privilege/src/privilege.c)
+  LIST(APPEND MNODE_SRC ${TD_ENTERPRISE_DIR}/src/plugins/mnode/src/mndDb.c)
 ENDIF ()
 
 add_library(mnode STATIC ${MNODE_SRC})

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

@@ -33,6 +33,8 @@ bool    mndIsDbReady(SMnode *pMnode, SDbObj *pDb);
 SSdbRaw    *mndDbActionEncode(SDbObj *pDb);
 const char *mndGetDbStr(const char *src);
 
+int32_t mndProcessCompactDbReq(SRpcMsg *pReq);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -542,7 +542,7 @@ void*           tDecodeSMqConsumerObj(const void* buf, SMqConsumerObj* pConsumer
 
 typedef struct {
   int32_t vgId;
-  char*   qmsg;
+  char*   qmsg;   //SubPlanToString
   SEpSet  epSet;
 } SMqVgEp;
 

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

@@ -41,12 +41,12 @@ extern "C" {
 #define mDebug(...) { if (mDebugFlag & DEBUG_DEBUG) { taosPrintLog("MND ",       DEBUG_DEBUG, mDebugFlag, __VA_ARGS__); }}
 #define mTrace(...) { if (mDebugFlag & DEBUG_TRACE) { taosPrintLog("MND ",       DEBUG_TRACE, mDebugFlag, __VA_ARGS__); }}
 
-#define mGFatal(param, ...) { char buf[40] = {0}; TRACE_TO_STR(trace, buf); mFatal(param ", gtid:%s", __VA_ARGS__, buf);}
+#define mGFatal(param, ...) { if (mDebugFlag & DEBUG_FATAL){ char buf[40] = {0}; TRACE_TO_STR(trace, buf); mFatal(param ", gtid:%s", __VA_ARGS__, buf);}} 
-#define mGError(param, ...) { char buf[40] = {0}; TRACE_TO_STR(trace, buf); mError(param ", gtid:%s", __VA_ARGS__, buf);}
+#define mGError(param, ...) { if (mDebugFlag & DEBUG_ERROR){ char buf[40] = {0}; TRACE_TO_STR(trace, buf); mError(param ", gtid:%s", __VA_ARGS__, buf);}}
-#define mGWarn(param, ...)  { char buf[40] = {0}; TRACE_TO_STR(trace, buf); mWarn (param ", gtid:%s", __VA_ARGS__, buf);}
+#define mGWarn(param, ...)  { if (mDebugFlag & DEBUG_WARN){ char buf[40] = {0}; TRACE_TO_STR(trace, buf); mWarn (param ", gtid:%s", __VA_ARGS__, buf);}}
-#define mGInfo(param, ...)  { char buf[40] = {0}; TRACE_TO_STR(trace, buf); mInfo (param ", gtid:%s", __VA_ARGS__, buf);}
+#define mGInfo(param, ...)  { if (mDebugFlag & DEBUG_INFO){ char buf[40] = {0}; TRACE_TO_STR(trace, buf); mInfo (param ", gtid:%s", __VA_ARGS__, buf);}}
-#define mGDebug(param, ...) { char buf[40] = {0}; TRACE_TO_STR(trace, buf); mDebug(param ", gtid:%s", __VA_ARGS__, buf);}
+#define mGDebug(param, ...) { if (mDebugFlag & DEBUG_DEBUG){ char buf[40] = {0}; TRACE_TO_STR(trace, buf); mDebug(param ", gtid:%s", __VA_ARGS__, buf);}}
-#define mGTrace(param, ...) { char buf[40] = {0}; TRACE_TO_STR(trace, buf); mTrace(param ", gtid:%s", __VA_ARGS__, buf);}
+#define mGTrace(param, ...) { if (mDebugFlag & DEBUG_TRACE){ char buf[40] = {0}; TRACE_TO_STR(trace, buf); mTrace(param ", gtid:%s", __VA_ARGS__, buf);}}
 // clang-format on
 
 #define SYSTABLE_SCH_TABLE_NAME_LEN ((TSDB_TABLE_NAME_LEN - 1) + VARSTR_HEADER_SIZE)

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

@@ -15,17 +15,11 @@
 
 #define _DEFAULT_SOURCE
 #include "mndConsumer.h"
-#include "mndDb.h"
-#include "mndDnode.h"
-#include "mndMnode.h"
 #include "mndPrivilege.h"
 #include "mndShow.h"
-#include "mndStb.h"
 #include "mndSubscribe.h"
 #include "mndTopic.h"
 #include "mndTrans.h"
-#include "mndUser.h"
-#include "mndVgroup.h"
 #include "tcompare.h"
 #include "tname.h"
 
@@ -209,6 +203,7 @@ static int32_t mndProcessConsumerClearMsg(SRpcMsg *pMsg) {
   taosMemoryFree(pConsumerNew);
   mndTransDrop(pTrans);
   return 0;
+
 FAIL:
   tDeleteSMqConsumerObj(pConsumerNew);
   taosMemoryFree(pConsumerNew);
@@ -580,6 +575,10 @@ static int32_t validateTopics(const SArray* pTopicList, SMnode* pMnode, const ch
   return 0;
 }
 
+static void* topicNameDup(void* p){
+  return taosStrdup((char*) p);
+}
+
 int32_t mndProcessSubscribeReq(SRpcMsg *pMsg) {
   SMnode *pMnode = pMsg->info.node;
   char   *msgStr = pMsg->pCont;
@@ -616,15 +615,16 @@ int32_t mndProcessSubscribeReq(SRpcMsg *pMsg) {
 
     pConsumerNew = tNewSMqConsumerObj(consumerId, cgroup);
     tstrncpy(pConsumerNew->clientId, subscribe.clientId, 256);
-    pConsumerNew->updateType = CONSUMER_UPDATE__MODIFY;
-    taosArrayDestroy(pConsumerNew->rebNewTopics);
-    pConsumerNew->rebNewTopics = pTopicList;  // all subscribe topics should re-balance.
-    subscribe.topicNames = NULL;
 
-    for (int32_t i = 0; i < newTopicNum; i++) {
+    // set the update type
-      char *newTopicCopy = taosStrdup(taosArrayGetP(pTopicList, i));
+    pConsumerNew->updateType = CONSUMER_UPDATE__MODIFY;
-      taosArrayPush(pConsumerNew->assignedTopics, &newTopicCopy);
+    taosArrayDestroy(pConsumerNew->assignedTopics);
-    }
+    pConsumerNew->assignedTopics = taosArrayDup(pTopicList, topicNameDup);
+
+    // all subscribed topics should re-balance.
+    taosArrayDestroy(pConsumerNew->rebNewTopics);
+    pConsumerNew->rebNewTopics = pTopicList;
+    subscribe.topicNames = NULL;
 
     if (mndSetConsumerCommitLogs(pMnode, pTrans, pConsumerNew) != 0) goto _over;
     if (mndTransPrepare(pMnode, pTrans) != 0) goto _over;
@@ -646,17 +646,12 @@ int32_t mndProcessSubscribeReq(SRpcMsg *pMsg) {
       goto _over;
     }
 
+    // set the update type
     pConsumerNew->updateType = CONSUMER_UPDATE__MODIFY;
+    taosArrayDestroy(pConsumerNew->assignedTopics);
+    pConsumerNew->assignedTopics = taosArrayDup(pTopicList, topicNameDup);
 
-    for (int32_t i = 0; i < newTopicNum; i++) {
+    int32_t oldTopicNum = (pExistedConsumer->currentTopics)? taosArrayGetSize(pExistedConsumer->currentTopics):0;
-      char *newTopicCopy = taosStrdup(taosArrayGetP(pTopicList, i));
-      taosArrayPush(pConsumerNew->assignedTopics, &newTopicCopy);
-    }
-
-    int32_t oldTopicNum = 0;
-    if (pExistedConsumer->currentTopics) {
-      oldTopicNum = taosArrayGetSize(pExistedConsumer->currentTopics);
-    }
 
     int32_t i = 0, j = 0;
     while (i < oldTopicNum || j < newTopicNum) {
@@ -692,11 +687,8 @@ int32_t mndProcessSubscribeReq(SRpcMsg *pMsg) {
       }
     }
 
-    if (pExistedConsumer && taosArrayGetSize(pConsumerNew->rebNewTopics) == 0 &&
+    // no topics need to be rebalanced
-        taosArrayGetSize(pConsumerNew->rebRemovedTopics) == 0) {
+    if (taosArrayGetSize(pConsumerNew->rebNewTopics) == 0 && taosArrayGetSize(pConsumerNew->rebRemovedTopics) == 0) {
-      /*if (taosArrayGetSize(pConsumerNew->assignedTopics) == 0) {*/
-      /*pConsumerNew->updateType = */
-      /*}*/
       goto _over;
     }
 
@@ -718,8 +710,9 @@ _over:
     tDeleteSMqConsumerObj(pConsumerNew);
     taosMemoryFree(pConsumerNew);
   }
+
   // TODO: replace with destroy subscribe msg
-  if (subscribe.topicNames) taosArrayDestroyP(subscribe.topicNames, (FDelete)taosMemoryFree);
+  taosArrayDestroyP(subscribe.topicNames, (FDelete)taosMemoryFree);
   return code;
 }
 
@@ -750,12 +743,12 @@ SSdbRaw *mndConsumerActionEncode(SMqConsumerObj *pConsumer) {
 CM_ENCODE_OVER:
   taosMemoryFreeClear(buf);
   if (terrno != 0) {
-    mError("consumer:%" PRId64 ", failed to encode to raw:%p since %s", pConsumer->consumerId, pRaw, terrstr());
+    mError("consumer:0x%" PRIx64 " failed to encode to raw:%p since %s", pConsumer->consumerId, pRaw, terrstr());
     sdbFreeRaw(pRaw);
     return NULL;
   }
 
-  mTrace("consumer:%" PRId64 ", encode to raw:%p, row:%p", pConsumer->consumerId, pRaw, pConsumer);
+  mTrace("consumer:0x%" PRIx64 ", encode to raw:%p, row:%p", pConsumer->consumerId, pRaw, pConsumer);
   return pRaw;
 }
 
@@ -823,8 +816,8 @@ static int32_t mndConsumerActionInsert(SSdb *pSdb, SMqConsumerObj *pConsumer) {
 }
 
 static int32_t mndConsumerActionDelete(SSdb *pSdb, SMqConsumerObj *pConsumer) {
-  mDebug("consumer:0x%" PRIx64 " perform delete action, status:%s", pConsumer->consumerId,
+  mDebug("consumer:0x%" PRIx64 " perform delete action, status:(%d)%s", pConsumer->consumerId,
-         mndConsumerStatusName(pConsumer->status));
+         pConsumer->status, mndConsumerStatusName(pConsumer->status));
   tDeleteSMqConsumerObj(pConsumer);
   return 0;
 }
@@ -1075,22 +1068,23 @@ static int32_t mndRetrieveConsumer(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *
 
       // consumer group
       char cgroup[TSDB_CGROUP_LEN + VARSTR_HEADER_SIZE] = {0};
-      tstrncpy(varDataVal(cgroup), pConsumer->cgroup, TSDB_CGROUP_LEN);
+      STR_TO_VARSTR(cgroup, pConsumer->cgroup);
-      varDataSetLen(cgroup, strlen(varDataVal(cgroup)));
+
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
       colDataSetVal(pColInfo, numOfRows, (const char *)cgroup, false);
 
       // client id
       char clientId[256 + VARSTR_HEADER_SIZE] = {0};
-      tstrncpy(varDataVal(clientId), pConsumer->clientId, 256);
+      STR_TO_VARSTR(clientId, pConsumer->clientId);
-      varDataSetLen(clientId, strlen(varDataVal(clientId)));
+
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
       colDataSetVal(pColInfo, numOfRows, (const char *)clientId, false);
 
       // status
       char status[20 + VARSTR_HEADER_SIZE] = {0};
-      tstrncpy(varDataVal(status), mndConsumerStatusName(pConsumer->status), 20);
+      const char* pStatusName = mndConsumerStatusName(pConsumer->status);
-      varDataSetLen(status, strlen(varDataVal(status)));
+      STR_TO_VARSTR(status, pStatusName);
+
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
       colDataSetVal(pColInfo, numOfRows, (const char *)status, false);
 
@@ -1123,8 +1117,11 @@ static int32_t mndRetrieveConsumer(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *
 
       numOfRows++;
     }
+
     taosRUnLockLatch(&pConsumer->lock);
     sdbRelease(pSdb, pConsumer);
+
+    pBlock->info.rows = numOfRows;
   }
 
   pShow->numOfRows += numOfRows;

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

@@ -41,12 +41,15 @@ static int32_t  mndProcessCreateDbReq(SRpcMsg *pReq);
 static int32_t  mndProcessAlterDbReq(SRpcMsg *pReq);
 static int32_t  mndProcessDropDbReq(SRpcMsg *pReq);
 static int32_t  mndProcessUseDbReq(SRpcMsg *pReq);
-static int32_t  mndProcessCompactDbReq(SRpcMsg *pReq);
 static int32_t  mndProcessTrimDbReq(SRpcMsg *pReq);
 static int32_t  mndRetrieveDbs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity);
 static void     mndCancelGetNextDb(SMnode *pMnode, void *pIter);
 static int32_t  mndProcessGetDbCfgReq(SRpcMsg *pReq);
 
+#ifndef TD_ENTERPRISE
+int32_t mndProcessCompactDbReq(SRpcMsg *pReq) { return TSDB_CODE_OPS_NOT_SUPPORT; }
+#endif
+
 int32_t mndInitDb(SMnode *pMnode) {
   SSdbTable table = {
       .sdbType = SDB_DB,
@@ -884,12 +887,19 @@ static int32_t mndProcessGetDbCfgReq(SRpcMsg *pReq) {
   cfgRsp.minRows = pDb->cfg.minRows;
   cfgRsp.maxRows = pDb->cfg.maxRows;
   cfgRsp.walFsyncPeriod = pDb->cfg.walFsyncPeriod;
+  cfgRsp.hashPrefix = pDb->cfg.hashPrefix;
+  cfgRsp.hashSuffix = pDb->cfg.hashSuffix;
   cfgRsp.walLevel = pDb->cfg.walLevel;
   cfgRsp.precision = pDb->cfg.precision;
   cfgRsp.compression = pDb->cfg.compression;
   cfgRsp.replications = pDb->cfg.replications;
   cfgRsp.strict = pDb->cfg.strict;
   cfgRsp.cacheLast = pDb->cfg.cacheLast;
+  cfgRsp.tsdbPageSize = pDb->cfg.tsdbPageSize;
+  cfgRsp.walRetentionPeriod = pDb->cfg.walRetentionPeriod;
+  cfgRsp.walRollPeriod = pDb->cfg.walRollPeriod;
+  cfgRsp.walRetentionSize = pDb->cfg.walRetentionSize;
+  cfgRsp.walSegmentSize = pDb->cfg.walSegmentSize;
   cfgRsp.numOfRetensions = pDb->cfg.numOfRetensions;
   cfgRsp.pRetensions = pDb->cfg.pRetensions;
   cfgRsp.schemaless = pDb->cfg.schemaless;
@@ -1395,98 +1405,6 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbVgVersion *pDbs, int32_t numOfDbs,
   return 0;
 }
 
-static int32_t mndSetCompactDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, int64_t compactTs) {
-  SDbObj dbObj = {0};
-  memcpy(&dbObj, pDb, sizeof(SDbObj));
-  dbObj.compactStartTime = compactTs;
-
-  SSdbRaw *pCommitRaw = mndDbActionEncode(&dbObj);
-  if (pCommitRaw == NULL) return -1;
-  if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
-    sdbFreeRaw(pCommitRaw);
-    return -1;
-  }
-
-  (void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
-  return 0;
-}
-
-static int32_t mndSetCompactDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, int64_t compactTs) {
-  SSdb *pSdb = pMnode->pSdb;
-  void *pIter = NULL;
-
-  while (1) {
-    SVgObj *pVgroup = NULL;
-    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);
-    if (pIter == NULL) break;
-
-    if (mndVgroupInDb(pVgroup, pDb->uid)) {
-      if (mndBuildCompactVgroupAction(pMnode, pTrans, pDb, pVgroup, compactTs) != 0) {
-        sdbCancelFetch(pSdb, pIter);
-        sdbRelease(pSdb, pVgroup);
-        return -1;
-      }
-    }
-
-    sdbRelease(pSdb, pVgroup);
-  }
-
-  return 0;
-}
-
-static int32_t mndCompactDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb) {
-  int64_t compactTs = taosGetTimestampMs();
-  int32_t code = -1;
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "compact-db");
-  if (pTrans == NULL) goto _OVER;
-
-  mInfo("trans:%d, used to compact db:%s", pTrans->id, pDb->name);
-  mndTransSetDbName(pTrans, pDb->name, NULL);
-  if (mndTrancCheckConflict(pMnode, pTrans) != 0) goto _OVER;
-  if (mndSetCompactDbCommitLogs(pMnode, pTrans, pDb, compactTs) != 0) goto _OVER;
-  if (mndSetCompactDbRedoActions(pMnode, pTrans, pDb, compactTs) != 0) goto _OVER;
-  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
-  code = 0;
-
-_OVER:
-  mndTransDrop(pTrans);
-  return code;
-}
-
-static int32_t mndProcessCompactDbReq(SRpcMsg *pReq) {
-  SMnode       *pMnode = pReq->info.node;
-  int32_t       code = -1;
-  SDbObj       *pDb = NULL;
-  SCompactDbReq compactReq = {0};
-
-  if (tDeserializeSCompactDbReq(pReq->pCont, pReq->contLen, &compactReq) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
-    goto _OVER;
-  }
-
-  mInfo("db:%s, start to compact", compactReq.db);
-
-  pDb = mndAcquireDb(pMnode, compactReq.db);
-  if (pDb == NULL) {
-    goto _OVER;
-  }
-
-  if (mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_COMPACT_DB, pDb) != 0) {
-    goto _OVER;
-  }
-
-  code = mndCompactDb(pMnode, pReq, pDb);
-  if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;
-
-_OVER:
-  if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {
-    mError("db:%s, failed to process compact db req since %s", compactReq.db, terrstr());
-  }
-
-  mndReleaseDb(pMnode, pDb);
-  return code;
-}
-
 static int32_t mndTrimDb(SMnode *pMnode, SDbObj *pDb) {
   SSdb       *pSdb = pMnode->pSdb;
   SVgObj     *pVgroup = NULL;

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

@@ -344,8 +344,8 @@ static int32_t mndInitWal(SMnode *pMnode) {
       .fsyncPeriod = 0,
       .rollPeriod = -1,
       .segSize = -1,
-      .retentionPeriod = -1,
+      .retentionPeriod = 0,
-      .retentionSize = -1,
+      .retentionSize = 0,
       .level = TAOS_WAL_FSYNC,
   };
 
@@ -370,7 +370,6 @@ static int32_t mndInitSdb(SMnode *pMnode) {
   opt.path = pMnode->path;
   opt.pMnode = pMnode;
   opt.pWal = pMnode->pWal;
-  opt.sync = pMnode->syncMgmt.sync;
 
   pMnode->pSdb = sdbInit(&opt);
   if (pMnode->pSdb == NULL) {
@@ -552,16 +551,7 @@ void mndPreClose(SMnode *pMnode) {
   if (pMnode != NULL) {
     syncLeaderTransfer(pMnode->syncMgmt.sync);
     syncPreStop(pMnode->syncMgmt.sync);
-#if 0
+    sdbWriteFile(pMnode->pSdb, 0);
-    while (syncSnapshotRecving(pMnode->syncMgmt.sync)) {
-      mInfo("vgId:1, snapshot is recving");
-      taosMsleep(300);
-    }
-    while (syncSnapshotSending(pMnode->syncMgmt.sync)) {
-      mInfo("vgId:1, snapshot is sending");
-      taosMsleep(300);
-    }
-#endif
   }
 }
 

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

@@ -1223,7 +1223,7 @@ static int32_t mndRetrieveStreamTask(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock
 
         // node id
         pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-        int32_t nodeId = TMAX(pTask->nodeId, 0);
+        int64_t nodeId = TMAX(pTask->nodeId, 0);
         colDataSetVal(pColInfo, numOfRows, (const char *)&nodeId, false);
 
         // level

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

@@ -16,15 +16,10 @@
 #define _DEFAULT_SOURCE
 #include "mndSubscribe.h"
 #include "mndConsumer.h"
-#include "mndDb.h"
-#include "mndDnode.h"
-#include "mndMnode.h"
 #include "mndScheduler.h"
 #include "mndShow.h"
-#include "mndStb.h"
 #include "mndTopic.h"
 #include "mndTrans.h"
-#include "mndUser.h"
 #include "mndVgroup.h"
 #include "tcompare.h"
 #include "tname.h"
@@ -1041,7 +1036,6 @@ int32_t mndRetrieveSubscribe(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock
     }
 
     // do not show for cleared subscription
-#if 1
     int32_t sz = taosArrayGetSize(pSub->unassignedVgs);
     for (int32_t i = 0; i < sz; i++) {
       SMqVgEp *pVgEp = taosArrayGetP(pSub->unassignedVgs, i);
@@ -1087,8 +1081,6 @@ int32_t mndRetrieveSubscribe(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock
       numOfRows++;
     }
 
-#endif
-
     pBlock->info.rows = numOfRows;
 
     taosRUnLockLatch(&pSub->lock);

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

@@ -118,12 +118,12 @@ int32_t mndProcessWriteMsg(const SSyncFSM *pFsm, SRpcMsg *pMsg, const SFsmCbMeta
             transId, pTrans->createdTime, pMgmt->transId);
       mndTransExecute(pMnode, pTrans, false);
       mndReleaseTrans(pMnode, pTrans);
-      // sdbWriteFile(pMnode->pSdb, SDB_WRITE_DELTA);
     } else {
       mError("trans:%d, not found while execute in mnode since %s", transId, terrstr());
     }
   }
 
+  sdbWriteFile(pMnode->pSdb, SDB_WRITE_DELTA);
   return 0;
 }
 
@@ -319,6 +319,7 @@ int32_t mndInitSync(SMnode *pMnode) {
     mError("failed to open sync since %s", terrstr());
     return -1;
   }
+  pMnode->pSdb->sync = pMgmt->sync;
 
   mInfo("mnode-sync is opened, id:%" PRId64, pMgmt->sync);
   return 0;

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

@@ -1645,8 +1645,6 @@ void mndTransPullup(SMnode *pMnode) {
     }
     mndReleaseTrans(pMnode, pTrans);
   }
-
-  sdbWriteFile(pMnode->pSdb, SDB_WRITE_DELTA);
   taosArrayDestroy(pArray);
 }
 

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

@@ -37,7 +37,7 @@ extern "C" {
 #define mTrace(...) { if (mDebugFlag & DEBUG_TRACE) { taosPrintLog("MND ", DEBUG_TRACE, mDebugFlag, __VA_ARGS__); }}
 // clang-format on
 
-#define SDB_WRITE_DELTA 20
+#define SDB_WRITE_DELTA 2000
 
 #define SDB_GET_VAL(pData, dataPos, val, pos, func, type) \
   {                                                       \

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

@@ -53,7 +53,6 @@ SSdb *sdbInit(SSdbOpt *pOption) {
   }
 
   pSdb->pWal = pOption->pWal;
-  pSdb->sync = pOption->sync;
   pSdb->applyIndex = -1;
   pSdb->applyTerm = -1;
   pSdb->applyConfig = -1;

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

@@ -472,10 +472,7 @@ int32_t sdbWriteFile(SSdb *pSdb, int32_t delta) {
 
   taosThreadMutexLock(&pSdb->filelock);
   if (pSdb->pWal != NULL) {
-    // code = walBeginSnapshot(pSdb->pWal, pSdb->applyIndex, 0);
+    if (pSdb->sync > 0) {
-    if (pSdb->sync == 0) {
-      code = 0;
-    } else {
       code = syncBeginSnapshot(pSdb->sync, pSdb->applyIndex);
     }
   }
@@ -484,11 +481,7 @@ int32_t sdbWriteFile(SSdb *pSdb, int32_t delta) {
   }
   if (code == 0) {
     if (pSdb->pWal != NULL) {
-      // code = walEndSnapshot(pSdb->pWal);
+      if (pSdb->sync > 0) {
-
-      if (pSdb->sync == 0) {
-        code = 0;
-      } else {
         code = syncEndSnapshot(pSdb->sync);
       }
     }

source/dnode/vnode/CMakeLists.txt

@@ -14,7 +14,7 @@ target_sources(
     "src/vnd/vnodeSvr.c"
     "src/vnd/vnodeSync.c"
     "src/vnd/vnodeSnapshot.c"
-    "src/vnd/vnodeCompact.c"
+    "src/vnd/vnodeRetention.c"
 
     # meta
     "src/meta/metaOpen.c"
@@ -52,7 +52,6 @@ target_sources(
     "src/tsdb/tsdbCacheRead.c"
     "src/tsdb/tsdbRetention.c"
     "src/tsdb/tsdbDiskData.c"
-    "src/tsdb/tsdbCompact.c"
     "src/tsdb/tsdbMergeTree.c"
     "src/tsdb/tsdbDataIter.c"
 
@@ -68,10 +67,20 @@ target_sources(
     "src/tq/tqSnapshot.c"
     "src/tq/tqOffsetSnapshot.c"
 )
+
+IF (TD_VNODE_PLUGINS)
+  target_sources(
+    vnode
+    PRIVATE
+    ${TD_ENTERPRISE_DIR}/src/plugins/vnode/src/tsdbCompact.c
+    ${TD_ENTERPRISE_DIR}/src/plugins/vnode/src/vnodeCompact.c
+  )
+ENDIF ()
+
 target_include_directories(
     vnode
     PUBLIC "inc"
-    PRIVATE "src/inc"
+    PUBLIC "src/inc"
     PUBLIC "${TD_SOURCE_DIR}/include/libs/scalar"
 )
 target_link_libraries(

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

@@ -67,7 +67,7 @@ typedef struct {
 // tqExec
 
 typedef struct {
-  char* qmsg;
+  char* qmsg;   // SubPlanToString
 } STqExecCol;
 
 typedef struct {

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

@@ -106,10 +106,6 @@ int32_t vnodeSyncCommit(SVnode* pVnode);
 int32_t vnodeAsyncCommit(SVnode* pVnode);
 bool    vnodeShouldRollback(SVnode* pVnode);
 
-// vnodeCompact.c
-int32_t vnodeAsyncCompact(SVnode* pVnode);
-int32_t vnodeSyncCompact(SVnode* pVnode);
-
 // vnodeSync.c
 int32_t vnodeSyncOpen(SVnode* pVnode, char* path);
 int32_t vnodeSyncStart(SVnode* pVnode);

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

@@ -180,7 +180,6 @@ int32_t tsdbCommit(STsdb* pTsdb, SCommitInfo* pInfo);
 int32_t tsdbCompact(STsdb* pTsdb, SCompactInfo* pInfo);
 int32_t tsdbFinishCommit(STsdb* pTsdb);
 int32_t tsdbRollbackCommit(STsdb* pTsdb);
-int32_t tsdbDoRetention(STsdb* pTsdb, int64_t now);
 int     tsdbScanAndConvertSubmitMsg(STsdb* pTsdb, SSubmitReq2* pMsg);
 int     tsdbInsertData(STsdb* pTsdb, int64_t version, SSubmitReq2* pMsg, SSubmitRsp2* pRsp);
 int32_t tsdbInsertTableData(STsdb* pTsdb, int64_t version, SSubmitTbData* pSubmitTbData, int32_t* affectedRows);

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

@@ -1921,10 +1921,10 @@ int metaCreateTagIdxKey(tb_uid_t suid, int32_t cid, const void *pTagData, int32_
   // refactor
   if (IS_VAR_DATA_TYPE(type)) {
     memcpy((*ppTagIdxKey)->data, (uint16_t *)&nTagData, VARSTR_HEADER_SIZE);
-    memcpy((*ppTagIdxKey)->data + VARSTR_HEADER_SIZE, pTagData, nTagData);
+    if (pTagData != NULL) memcpy((*ppTagIdxKey)->data + VARSTR_HEADER_SIZE, pTagData, nTagData);
     *(tb_uid_t *)((*ppTagIdxKey)->data + VARSTR_HEADER_SIZE + nTagData) = uid;
   } else {
-    memcpy((*ppTagIdxKey)->data, pTagData, nTagData);
+    if (pTagData != NULL) memcpy((*ppTagIdxKey)->data, pTagData, nTagData);
     *(tb_uid_t *)((*ppTagIdxKey)->data + nTagData) = uid;
   }
 

source/dnode/vnode/src/sma/smaRollup.c

@@ -595,6 +595,7 @@ static int32_t tdFetchSubmitReqSuids(SSubmitReq2 *pMsg, STbUidStore *pStore) {
   return 0;
 }
 
+#if 0
 /**
  * @brief retention of rsma1/rsma2
  *
@@ -618,6 +619,7 @@ int32_t smaDoRetention(SSma *pSma, int64_t now) {
 _end:
   return code;
 }
+#endif
 
 static void tdBlockDataDestroy(SArray *pBlockArr) {
   for (int32_t i = 0; i < taosArrayGetSize(pBlockArr); ++i) {

source/dnode/vnode/src/tq/tq.c

@@ -217,7 +217,7 @@ int32_t tqPushDataRsp(STQ* pTq, STqPushEntry* pPushEntry) {
   char buf2[80] = {0};
   tFormatOffset(buf1, tListLen(buf1), &pRsp->reqOffset);
   tFormatOffset(buf2, tListLen(buf2), &pRsp->rspOffset);
-  tqDebug("vgId:%d, from consumer:0x%" PRIx64 " (epoch %d) push rsp, block num: %d, reqOffset:%s, rspOffset:%s",
+  tqDebug("vgId:%d, from consumer:0x%" PRIx64 " (epoch %d) push rsp, block num: %d, req:%s, rsp:%s",
           TD_VID(pTq->pVnode), pRsp->head.consumerId, pRsp->head.epoch, pRsp->blockNum, buf1, buf2);
 
   return 0;
@@ -275,7 +275,7 @@ int32_t tqSendDataRsp(STQ* pTq, const SRpcMsg* pMsg, const SMqPollReq* pReq, con
   char buf2[80] = {0};
   tFormatOffset(buf1, 80, &pRsp->reqOffset);
   tFormatOffset(buf2, 80, &pRsp->rspOffset);
-  tqDebug("vgId:%d consumer:0x%" PRIx64 " (epoch %d), block num:%d, reqOffset:%s, rspOffset:%s",
+  tqDebug("vgId:%d consumer:0x%" PRIx64 " (epoch %d), block num:%d, req:%s, rsp:%s",
           TD_VID(pTq->pVnode), pReq->consumerId, pReq->epoch, pRsp->blockNum, buf1, buf2);
 
   return 0;
@@ -575,7 +575,6 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg) {
       return -1;
     }
 
-#if 1
     // till now, all data has been rsp to consumer, new data needs to push client once arrived.
     if (dataRsp.blockNum == 0 && dataRsp.reqOffset.type == TMQ_OFFSET__LOG &&
         dataRsp.reqOffset.version == dataRsp.rspOffset.version) {
@@ -597,14 +596,13 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg) {
         return 0;
       }
     }
-#endif
     taosWUnLockLatch(&pTq->pushLock);
 
     if (tqSendDataRsp(pTq, pMsg, &req, &dataRsp) < 0) {
       code = -1;
     }
 
-    tqDebug("tmq poll: consumer:0x%" PRIx64 ", subkey %s, vgId:%d, rsp data block:%d, offset type:%d, uid/version:%" PRId64 ", ts:%" PRId64 "",
+    tqDebug("tmq poll: consumer:0x%" PRIx64 ", subkey %s, vgId:%d, rsp block:%d, offset type:%d, uid/version:%" PRId64 ", ts:%" PRId64 "",
             consumerId, pHandle->subKey, TD_VID(pTq->pVnode), dataRsp.blockNum, dataRsp.rspOffset.type,
             dataRsp.rspOffset.uid, dataRsp.rspOffset.ts);
 
@@ -613,10 +611,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg) {
   }
 
   // for taosx
-  /*A(pHandle->execHandle.subType != TOPIC_SUB_TYPE__COLUMN);*/
-
   SMqMetaRsp metaRsp = {0};
-
   STaosxRsp taosxRsp = {0};
   tqInitTaosxRsp(&taosxRsp, &req);
 

source/dnode/vnode/src/tq/tqExec.c

@@ -113,9 +113,7 @@ int32_t tqScanData(STQ* pTq, const STqHandle* pHandle, SMqDataRsp* pRsp, STqOffs
     return -1;
   }
 
-  ASSERT(pRsp->withTbName == false);
+  ASSERT(!(pRsp->withTbName || pRsp->withSchema));
-  ASSERT(pRsp->withSchema == false);
-
   return 0;
 }
 

source/dnode/vnode/src/tq/tqPush.c

@@ -193,7 +193,7 @@ int32_t tqPushMsgNew(STQ* pTq, void* msg, int32_t msgLen, tmsg_t msgType, int64_
     memset(&pHandle->pushHandle.rpcInfo, 0, sizeof(SRpcHandleInfo));
     taosWUnLockLatch(&pHandle->pushHandle.lock);
 
-    tqDebug("vgId:%d offset %" PRId64 " from consumer:%" PRId64 ", (epoch %d) send rsp, block num: %d, reqOffset:%" PRId64 ", rspOffset:%" PRId64,
+    tqDebug("vgId:%d offset %" PRId64 " from consumer:%" PRId64 ", (epoch %d) send rsp, block num: %d, req:%" PRId64 ", rsp:%" PRId64,
             TD_VID(pTq->pVnode), fetchOffset, pHandle->pushHandle.consumerId, pHandle->pushHandle.epoch, rsp.blockNum,
             rsp.reqOffset, rsp.rspOffset);
 
@@ -210,25 +210,30 @@ int tqPushMsg(STQ* pTq, void* msg, int32_t msgLen, tmsg_t msgType, int64_t ver)
   void*   pReq = POINTER_SHIFT(msg, sizeof(SSubmitReq2Msg));
   int32_t len = msgLen - sizeof(SSubmitReq2Msg);
 
-  tqDebug("vgId:%d tq push msg version:%" PRId64 " type: %s, p head %p, p body %p, len %d", pTq->pVnode->config.vgId, ver,
-          TMSG_INFO(msgType), msg, pReq, len);
-
   if (msgType == TDMT_VND_SUBMIT) {
     // lock push mgr to avoid potential msg lost
     taosWLockLatch(&pTq->pushLock);
-    if (taosHashGetSize(pTq->pPushMgr) != 0) {
 
-      tqDebug("vgId:%d, push handle num %d", pTq->pVnode->config.vgId, taosHashGetSize(pTq->pPushMgr));
+    int32_t numOfRegisteredPush = taosHashGetSize(pTq->pPushMgr);
+    if (numOfRegisteredPush > 0) {
+      tqDebug("vgId:%d tq push msg version:%" PRId64 " type:%s, head:%p, body:%p len:%d, numOfPushed consumers:%d",
+          pTq->pVnode->config.vgId, ver, TMSG_INFO(msgType), msg, pReq, len, numOfRegisteredPush);
+
       SArray* cachedKeys = taosArrayInit(0, sizeof(void*));
       SArray* cachedKeyLens = taosArrayInit(0, sizeof(size_t));
+
       void*   data = taosMemoryMalloc(len);
       if (data == NULL) {
         terrno = TSDB_CODE_OUT_OF_MEMORY;
         tqError("failed to copy data for stream since out of memory");
         taosArrayDestroyP(cachedKeys, (FDelete)taosMemoryFree);
         taosArrayDestroy(cachedKeyLens);
+
+        // unlock
+        taosWUnLockLatch(&pTq->pushLock);
         return -1;
       }
+
       memcpy(data, pReq, len);
 
       void* pIter = NULL;
@@ -262,7 +267,7 @@ int tqPushMsg(STQ* pTq, void* msg, int32_t msgLen, tmsg_t msgType, int64_t ver)
         };
         qStreamSetScanMemData(task, submit);
 
-        // exec
+        // here start to scan submit block to extract the subscribed data
         while (1) {
           SSDataBlock* pDataBlock = NULL;
           uint64_t     ts = 0;
@@ -295,6 +300,7 @@ int tqPushMsg(STQ* pTq, void* msg, int32_t msgLen, tmsg_t msgType, int64_t ver)
           tqPushDataRsp(pTq, pPushEntry);
         }
       }
+
       // delete entry
       for (int32_t i = 0; i < taosArrayGetSize(cachedKeys); i++) {
         void*  key = taosArrayGetP(cachedKeys, i);

source/dnode/vnode/src/tq/tqRead.c

@@ -291,11 +291,16 @@ void tqCloseReader(STqReader* pReader) {
 }
 
 int32_t tqSeekVer(STqReader* pReader, int64_t ver) {
+  // todo set the correct vgId
+  tqDebug("tmq poll: vgId:%d wal seek to version:%"PRId64, 0, ver);
   if (walReadSeekVer(pReader->pWalReader, ver) < 0) {
+    tqError("tmq poll: wal reader failed to seek to ver:%"PRId64, ver);
     return -1;
-  }
+  } else {
+    tqDebug("tmq poll: wal reader seek to ver:%"PRId64, ver);
     return 0;
   }
+}
 
 int32_t tqNextBlock(STqReader* pReader, SFetchRet* ret) {
   bool fromProcessedMsg = pReader->msg2.msgStr != NULL;
@@ -304,29 +309,20 @@ int32_t tqNextBlock(STqReader* pReader, SFetchRet* ret) {
     if (!fromProcessedMsg) {
       if (walNextValidMsg(pReader->pWalReader) < 0) {
         pReader->ver =
-            pReader->pWalReader->curVersion - (pReader->pWalReader->curInvalid | pReader->pWalReader->curStopped);
+            pReader->pWalReader->curVersion - pReader->pWalReader->curStopped;
+//            pReader->pWalReader->curVersion - (pReader->pWalReader->curInvalid | pReader->pWalReader->curStopped);
         ret->offset.type = TMQ_OFFSET__LOG;
         ret->offset.version = pReader->ver;
         ret->fetchType = FETCH_TYPE__NONE;
         tqDebug("return offset %" PRId64 ", no more valid", ret->offset.version);
         return -1;
       }
+
       void*   body = POINTER_SHIFT(pReader->pWalReader->pHead->head.body, sizeof(SSubmitReq2Msg));
       int32_t bodyLen = pReader->pWalReader->pHead->head.bodyLen - sizeof(SSubmitReq2Msg);
       int64_t ver = pReader->pWalReader->pHead->head.version;
-#if 0
+
-      if (pReader->pWalReader->pHead->head.msgType != TDMT_VND_SUBMIT) {
-        // TODO do filter
-        ret->fetchType = FETCH_TYPE__META;
-        ret->meta = pReader->pWalReader->pHead->head.body;
-        return 0;
-      } else {
-#endif
       tqReaderSetSubmitReq2(pReader, body, bodyLen, ver);
-      /*tqReaderSetDataMsg(pReader, body, pReader->pWalReader->pHead->head.version);*/
-#if 0
-      }
-#endif
     }
 
     while (tqNextDataBlock2(pReader)) {
@@ -358,7 +354,7 @@ int32_t tqReaderSetDataMsg(STqReader* pReader, const SSubmitReq* pMsg, int64_t v
 //  if (tInitSubmitMsgIter(pMsg, &pReader->msgIter) < 0) return -1;
 //  while (true) {
 //    if (tGetSubmitMsgNext(&pReader->msgIter, &pReader->pBlock) < 0) return -1;
-//    tqDebug("submitnext vgId:%d, block:%p, dataLen:%d, len:%d, uid:%"PRId64, pReader->pWalReader->pWal->cfg.vgId, pReader->pBlock, pReader->msgIter.dataLen,
+//    tqDebug("submitnext vgId:%d, block:%p, dataLen:%d, len:%d, uid:%"PRId64, pWalReader->pWal->cfg.vgId, pReader->pBlock, pReader->msgIter.dataLen,
 //            pReader->msgIter.len, pReader->msgIter.uid);
 //    if (pReader->pBlock == NULL) break;
 //  }
@@ -371,10 +367,8 @@ int32_t tqReaderSetDataMsg(STqReader* pReader, const SSubmitReq* pMsg, int64_t v
 #endif
 
 int32_t tqReaderSetSubmitReq2(STqReader* pReader, void* msgStr, int32_t msgLen, int64_t ver) {
-  ASSERT(pReader->msg2.msgStr == NULL);
+  ASSERT(pReader->msg2.msgStr == NULL && msgStr && msgLen && (ver >= 0));
-  ASSERT(msgStr);
+
-  ASSERT(msgLen);
-  ASSERT(ver >= 0);
   pReader->msg2.msgStr = msgStr;
   pReader->msg2.msgLen = msgLen;
   pReader->msg2.ver = ver;
@@ -421,7 +415,10 @@ bool tqNextDataBlock(STqReader* pReader) {
 #endif
 
 bool tqNextDataBlock2(STqReader* pReader) {
-  if (pReader->msg2.msgStr == NULL) return false;
+  if (pReader->msg2.msgStr == NULL) {
+    return false;
+  }
+
   ASSERT(pReader->setMsg == 1);
 
   tqDebug("tq reader next data block %p, %d %" PRId64 " %d", pReader->msg2.msgStr, pReader->msg2.msgLen,
@@ -528,7 +525,7 @@ int32_t tqScanSubmitSplit(SArray* pBlocks, SArray* schemas, STqReader* pReader)
     if (pReader->pSchema == NULL) {
       tqWarn("vgId:%d, cannot found tsschema for table: uid:%" PRId64 " (suid:%" PRId64
              "), version %d, possibly dropped table",
-             pReader->pWalReader->pWal->cfg.vgId, pReader->msgIter.uid, pReader->msgIter.suid, sversion);
+             pWalReader->pWal->cfg.vgId, pReader->msgIter.uid, pReader->msgIter.suid, sversion);
       pReader->cachedSchemaSuid = 0;
       terrno = TSDB_CODE_TQ_TABLE_SCHEMA_NOT_FOUND;
       return -1;
@@ -538,7 +535,7 @@ int32_t tqScanSubmitSplit(SArray* pBlocks, SArray* schemas, STqReader* pReader)
     pReader->pSchemaWrapper = metaGetTableSchema(pReader->pVnodeMeta, pReader->msgIter.uid, sversion, 1);
     if (pReader->pSchemaWrapper == NULL) {
       tqWarn("vgId:%d, cannot found schema wrapper for table: suid:%" PRId64 ", version %d, possibly dropped table",
-             pReader->pWalReader->pWal->cfg.vgId, pReader->msgIter.uid, pReader->cachedSchemaVer);
+             pWalReader->pWal->cfg.vgId, pReader->msgIter.uid, pReader->cachedSchemaVer);
       pReader->cachedSchemaSuid = 0;
       terrno = TSDB_CODE_TQ_TABLE_SCHEMA_NOT_FOUND;
       return -1;

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

@@ -1,667 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "tsdb.h"
-
-extern int32_t tsdbUpdateTableSchema(SMeta *pMeta, int64_t suid, int64_t uid, SSkmInfo *pSkmInfo);
-extern int32_t tsdbWriteDataBlock(SDataFWriter *pWriter, SBlockData *pBlockData, SMapData *mDataBlk, int8_t cmprAlg);
-extern int32_t tsdbWriteSttBlock(SDataFWriter *pWriter, SBlockData *pBlockData, SArray *aSttBlk, int8_t cmprAlg);
-
-typedef struct {
-  STsdb  *pTsdb;
-  int64_t commitID;
-  int8_t  cmprAlg;
-  int32_t maxRows;
-  int32_t minRows;
-
-  STsdbFS fs;
-
-  int32_t  fid;
-  TABLEID  tbid;
-  SSkmInfo tbSkm;
-
-  // Tombstone
-  SDelFReader *pDelFReader;
-  SArray      *aDelIdx;   // SArray<SDelIdx>
-  SArray      *aDelData;  // SArray<SDelData>
-  SArray      *aSkyLine;  // SArray<TSDBKEY>
-  int32_t      iDelIdx;
-  int32_t      iSkyLine;
-  TSDBKEY     *pDKey;
-  TSDBKEY      dKey;
-
-  // Reader
-  SDataFReader   *pReader;
-  STsdbDataIter2 *iterList;  // list of iterators
-  STsdbDataIter2 *pIter;
-  SRBTree         rbt;
-
-  // Writer
-  SDataFWriter *pWriter;
-  SArray       *aBlockIdx;  // SArray<SBlockIdx>
-  SMapData      mDataBlk;   // SMapData<SDataBlk>
-  SArray       *aSttBlk;    // SArray<SSttBlk>
-  SBlockData    bData;
-  SBlockData    sData;
-} STsdbCompactor;
-
-static int32_t tsdbCommitCompact(STsdbCompactor *pCompactor) {
-  int32_t code = 0;
-  int32_t lino = 0;
-
-  STsdb *pTsdb = pCompactor->pTsdb;
-
-  code = tsdbFSPrepareCommit(pTsdb, &pCompactor->fs);
-  TSDB_CHECK_CODE(code, lino, _exit);
-
-  taosThreadRwlockWrlock(&pTsdb->rwLock);
-
-  code = tsdbFSCommit(pTsdb);
-  if (code) {
-    taosThreadRwlockUnlock(&pTsdb->rwLock);
-    TSDB_CHECK_CODE(code, lino, _exit);
-  }
-
-  taosThreadRwlockUnlock(&pTsdb->rwLock);
-
-_exit:
-  if (code) {
-    tsdbError("vgId:%d %s failed at line %d since %s", TD_VID(pTsdb->pVnode), __func__, lino, tstrerror(code));
-  }
-  return code;
-}
-
-static int32_t tsdbAbortCompact(STsdbCompactor *pCompactor) {
-  int32_t code = 0;
-  int32_t lino = 0;
-
-  STsdb *pTsdb = pCompactor->pTsdb;
-  code = tsdbFSRollback(pTsdb);
-  TSDB_CHECK_CODE(code, lino, _exit);
-
-_exit:
-  if (code) {
-    tsdbError("vgId:%d %s failed at line %d since %s", TD_VID(pTsdb->pVnode), __func__, lino, tstrerror(code));
-  } else {
-    tsdbInfo("vgId:%d %s done", TD_VID(pTsdb->pVnode), __func__);
-  }
-  return code;
-}
-
-static int32_t tsdbCompactWriteTableDataStart(STsdbCompactor *pCompactor, TABLEID *pId) {
-  int32_t code = 0;
-  int32_t lino = 0;
-
-  pCompactor->tbid = *pId;
-
-  // tombstone
-  for (;;) {
-    if (pCompactor->iDelIdx >= taosArrayGetSize(pCompactor->aDelIdx)) {
-      pCompactor->pDKey = NULL;
-      break;
-    }
-
-    SDelIdx *pDelIdx = (SDelIdx *)taosArrayGet(pCompactor->aDelIdx, pCompactor->iDelIdx);
-    int32_t  c = tTABLEIDCmprFn(pDelIdx, &pCompactor->tbid);
-    if (c < 0) {
-      pCompactor->iDelIdx++;
-    } else if (c == 0) {
-      pCompactor->iDelIdx++;
-
-      code = tsdbReadDelData(pCompactor->pDelFReader, pDelIdx, pCompactor->aDelData);
-      TSDB_CHECK_CODE(code, lino, _exit);
-
-      code = tsdbBuildDeleteSkyline(pCompactor->aDelData, 0, taosArrayGetSize(pCompactor->aDelData) - 1,
-                                    pCompactor->aSkyLine);
-      TSDB_CHECK_CODE(code, lino, _exit);
-
-      pCompactor->iSkyLine = 0;
-      if (pCompactor->iSkyLine < taosArrayGetSize(pCompactor->aSkyLine)) {
-        TSDBKEY *pKey = (TSDBKEY *)taosArrayGet(pCompactor->aSkyLine, pCompactor->iSkyLine);
-
-        pCompactor->dKey.version = 0;
-        pCompactor->dKey.ts = pKey->ts;
-        pCompactor->pDKey = &pCompactor->dKey;
-      } else {
-        pCompactor->pDKey = NULL;
-      }
-      break;
-    } else {
-      pCompactor->pDKey = NULL;
-      break;
-    }
-  }
-
-  // writer
-  code = tsdbUpdateTableSchema(pCompactor->pTsdb->pVnode->pMeta, pId->suid, pId->uid, &pCompactor->tbSkm);
-  TSDB_CHECK_CODE(code, lino, _exit);
-
-  tMapDataReset(&pCompactor->mDataBlk);
-
-  code = tBlockDataInit(&pCompactor->bData, pId, pCompactor->tbSkm.pTSchema, NULL, 0);
-  TSDB_CHECK_CODE(code, lino, _exit);
-
-  if (!TABLE_SAME_SCHEMA(pCompactor->sData.suid, pCompactor->sData.uid, pId->suid, pId->uid)) {
-    if (pCompactor->sData.nRow > 0) {
-      code = tsdbWriteSttBlock(pCompactor->pWriter, &pCompactor->sData, pCompactor->aSttBlk, pCompactor->cmprAlg);
-      TSDB_CHECK_CODE(code, lino, _exit);
-    }
-
-    TABLEID tbid = {.suid = pId->suid, .uid = pId->suid ? 0 : pId->uid};
-    code = tBlockDataInit(&pCompactor->sData, &tbid, pCompactor->tbSkm.pTSchema, NULL, 0);
-    TSDB_CHECK_CODE(code, lino, _exit);
-  }
-
-_exit:
-  if (code) {
-    tsdbError("vgId:%d %s failed at line %d since %s", TD_VID(pCompactor->pTsdb->pVnode), __func__, lino,
-              tstrerror(code));
-  } else {
-    tsdbDebug("vgId:%d %s done, suid:%" PRId64 " uid:%" PRId64, TD_VID(pCompactor->pTsdb->pVnode), __func__, pId->suid,
-              pId->uid);
-  }
-  return code;
-}
-
-static int32_t tsdbCompactWriteTableDataEnd(STsdbCompactor *pCompactor) {
-  int32_t code = 0;
-  int32_t lino = 0;
-
-  if (pCompactor->bData.nRow > 0) {
-    if (pCompactor->bData.nRow < pCompactor->minRows) {
-      for (int32_t iRow = 0; iRow < pCompactor->bData.nRow; iRow++) {
-        code = tBlockDataAppendRow(&pCompactor->sData, &tsdbRowFromBlockData(&pCompactor->bData, iRow), NULL,
-                                   pCompactor->tbid.uid);
-        TSDB_CHECK_CODE(code, lino, _exit);
-
-        if (pCompactor->sData.nRow >= pCompactor->maxRows) {
-          code = tsdbWriteSttBlock(pCompactor->pWriter, &pCompactor->sData, pCompactor->aSttBlk, pCompactor->cmprAlg);
-          TSDB_CHECK_CODE(code, lino, _exit);
-        }
-      }
-      tBlockDataClear(&pCompactor->bData);
-    } else {
-      code = tsdbWriteDataBlock(pCompactor->pWriter, &pCompactor->bData, &pCompactor->mDataBlk, pCompactor->cmprAlg);
-      TSDB_CHECK_CODE(code, lino, _exit);
-    }
-  }
-
-  if (pCompactor->mDataBlk.nItem > 0) {
-    SBlockIdx *pBlockIdx = (SBlockIdx *)taosArrayReserve(pCompactor->aBlockIdx, 1);
-    if (pBlockIdx == NULL) {
-      code = TSDB_CODE_OUT_OF_MEMORY;
-      TSDB_CHECK_CODE(code, lino, _exit);
-    }
-
-    pBlockIdx->suid = pCompactor->tbid.suid;
-    pBlockIdx->uid = pCompactor->tbid.uid;
-
-    code = tsdbWriteDataBlk(pCompactor->pWriter, &pCompactor->mDataBlk, pBlockIdx);
-    TSDB_CHECK_CODE(code, lino, _exit);
-  }
-
-_exit:
-  if (code) {
-    tsdbError("vgId:%d %s failed at line %d since %s", TD_VID(pCompactor->pTsdb->pVnode), __func__, lino,
-              tstrerror(code));
-  } else {
-    tsdbDebug("vgId:%d %s done, suid:%" PRId64 " uid:%" PRId64, TD_VID(pCompactor->pTsdb->pVnode), __func__,
-              pCompactor->tbid.suid, pCompactor->tbid.uid);
-  }
-  return code;
-}
-
-static bool tsdbCompactRowIsDeleted(STsdbCompactor *pCompactor, TSDBROW *pRow) {
-  TSDBKEY  tKey = TSDBROW_KEY(pRow);
-  TSDBKEY *aKey = (TSDBKEY *)TARRAY_DATA(pCompactor->aSkyLine);
-  int32_t  nKey = TARRAY_SIZE(pCompactor->aSkyLine);
-
-  if (tKey.ts > pCompactor->pDKey->ts) {
-    do {
-      pCompactor->pDKey->version = aKey[pCompactor->iSkyLine].version;
-      pCompactor->iSkyLine++;
-      if (pCompactor->iSkyLine < nKey) {
-        pCompactor->dKey.ts = aKey[pCompactor->iSkyLine].ts;
-      } else {
-        if (pCompactor->pDKey->version == 0) {
-          pCompactor->pDKey = NULL;
-          return false;
-        } else {
-          pCompactor->pDKey->ts = INT64_MAX;
-        }
-      }
-    } while (tKey.ts > pCompactor->pDKey->ts);
-  }
-
-  if (tKey.ts < pCompactor->pDKey->ts) {
-    if (tKey.version > pCompactor->pDKey->version) {
-      return false;
-    } else {
-      return true;
-    }
-  } else if (tKey.ts == pCompactor->pDKey->ts) {
-    ASSERT(pCompactor->iSkyLine < nKey);
-    if (tKey.version > TMAX(pCompactor->pDKey->version, aKey[pCompactor->iSkyLine].version)) {
-      return false;
-    } else {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-static int32_t tsdbCompactWriteTableData(STsdbCompactor *pCompactor, SRowInfo *pRowInfo) {
-  int32_t code = 0;
-  int32_t lino = 0;
-
-  // start a new table data write if need
-  if (pRowInfo == NULL || pRowInfo->uid != pCompactor->tbid.uid) {
-    if (pCompactor->tbid.uid) {
-      code = tsdbCompactWriteTableDataEnd(pCompactor);
-      TSDB_CHECK_CODE(code, lino, _exit);
-    }
-
-    if (pRowInfo == NULL) {
-      if (pCompactor->sData.nRow > 0) {
-        code = tsdbWriteSttBlock(pCompactor->pWriter, &pCompactor->sData, pCompactor->aSttBlk, pCompactor->cmprAlg);
-        TSDB_CHECK_CODE(code, lino, _exit);
-      }
-      return code;
-    }
-
-    code = tsdbCompactWriteTableDataStart(pCompactor, (TABLEID *)pRowInfo);
-    TSDB_CHECK_CODE(code, lino, _exit);
-  }
-
-  // check if row is deleted
-  if (pCompactor->pDKey && tsdbCompactRowIsDeleted(pCompactor, &pRowInfo->row)) goto _exit;
-
-  if (tBlockDataTryUpsertRow(&pCompactor->bData, &pRowInfo->row, pRowInfo->uid) > pCompactor->maxRows) {
-    code = tsdbWriteDataBlock(pCompactor->pWriter, &pCompactor->bData, &pCompactor->mDataBlk, pCompactor->cmprAlg);
-    TSDB_CHECK_CODE(code, lino, _exit);
-  }
-
-  code = tBlockDataUpsertRow(&pCompactor->bData, &pRowInfo->row, NULL, pRowInfo->uid);
-  TSDB_CHECK_CODE(code, lino, _exit);
-
-_exit:
-  if (code) {
-    tsdbError("vgId:%d %s failed at line %d since %s", TD_VID(pCompactor->pTsdb->pVnode), __func__, lino,
-              tstrerror(code));
-  } else if (pRowInfo) {
-    tsdbTrace("vgId:%d %s done, suid:%" PRId64 " uid:%" PRId64 " ts:%" PRId64 " version:%" PRId64,
-              TD_VID(pCompactor->pTsdb->pVnode), __func__, pRowInfo->suid, pRowInfo->uid, TSDBROW_TS(&pRowInfo->row),
-              TSDBROW_VERSION(&pRowInfo->row));
-  }
-  return code;
-}
-
-static bool tsdbCompactTableIsDropped(STsdbCompactor *pCompactor) {
-  SMetaInfo info;
-
-  if (pCompactor->pIter->rowInfo.uid == pCompactor->tbid.uid) return false;
-  if (metaGetInfo(pCompactor->pTsdb->pVnode->pMeta, pCompactor->pIter->rowInfo.uid, &info, NULL)) {
-    return true;
-  }
-  return false;
-}
-static int32_t tsdbCompactNextRow(STsdbCompactor *pCompactor, SRowInfo **ppRowInfo) {
-  int32_t code = 0;
-  int32_t lino = 0;
-
-  for (;;) {
-    if (pCompactor->pIter) {
-      code = tsdbDataIterNext2(pCompactor->pIter, NULL);
-      TSDB_CHECK_CODE(code, lino, _exit);
-
-      if (pCompactor->pIter->rowInfo.suid == 0 && pCompactor->pIter->rowInfo.uid == 0) {
-        pCompactor->pIter = NULL;
-      } else {
-        SRBTreeNode *pNode = tRBTreeMin(&pCompactor->rbt);
-        if (pNode) {
-          int32_t c = tsdbDataIterCmprFn(&pCompactor->pIter->rbtn, pNode);
-          if (c > 0) {
-            tRBTreePut(&pCompactor->rbt, &pCompactor->pIter->rbtn);
-            pCompactor->pIter = NULL;
-          } else if (c == 0) {
-            ASSERT(0);
-          }
-        }
-      }
-    }
-
-    if (pCompactor->pIter == NULL) {
-      SRBTreeNode *pNode = tRBTreeDropMin(&pCompactor->rbt);
-      if (pNode) {
-        pCompactor->pIter = TSDB_RBTN_TO_DATA_ITER(pNode);
-      }
-    }
-
-    if (pCompactor->pIter) {
-      if (tsdbCompactTableIsDropped(pCompactor)) {
-        TABLEID tbid = {.suid = pCompactor->pIter->rowInfo.suid, .uid = pCompactor->pIter->rowInfo.uid};
-        tRBTreeClear(&pCompactor->rbt);
-        for (pCompactor->pIter = pCompactor->iterList; pCompactor->pIter; pCompactor->pIter = pCompactor->pIter->next) {
-          code = tsdbDataIterNext2(pCompactor->pIter,
-                                   &(STsdbFilterInfo){.flag = TSDB_FILTER_FLAG_BY_TABLEID, .tbid = tbid});
-          TSDB_CHECK_CODE(code, lino, _exit);
-
-          if (pCompactor->pIter->rowInfo.suid || pCompactor->pIter->rowInfo.uid) {
-            tRBTreePut(&pCompactor->rbt, &pCompactor->pIter->rbtn);
-          }
-        }
-      } else {
-        *ppRowInfo = &pCompactor->pIter->rowInfo;
-        break;
-      }
-    } else {
-      *ppRowInfo = NULL;
-      break;
-    }
-  }
-
-_exit:
-  if (code) {
-    tsdbError("vgId:%d %s failed at line %d since %s", TD_VID(pCompactor->pTsdb->pVnode), __func__, lino,
-              tstrerror(code));
-  }
-  return code;
-}
-
-static int32_t tsdbCompactFileSetStart(STsdbCompactor *pCompactor, SDFileSet *pSet) {
-  int32_t code = 0;
-  int32_t lino = 0;
-
-  pCompactor->fid = pSet->fid;
-  pCompactor->tbid = (TABLEID){0};
-
-  /* tombstone */
-  pCompactor->iDelIdx = 0;
-
-  /* reader */
-  code = tsdbDataFReaderOpen(&pCompactor->pReader, pCompactor->pTsdb, pSet);
-  TSDB_CHECK_CODE(code, lino, _exit);
-
-  code = tsdbOpenDataFileDataIter(pCompactor->pReader, &pCompactor->pIter);
-  TSDB_CHECK_CODE(code, lino, _exit);
-
-  tRBTreeCreate(&pCompactor->rbt, tsdbDataIterCmprFn);
-  if (pCompactor->pIter) {
-    pCompactor->pIter->next = pCompactor->iterList;
-    pCompactor->iterList = pCompactor->pIter;
-
-    code = tsdbDataIterNext2(pCompactor->pIter, NULL);
-    TSDB_CHECK_CODE(code, lino, _exit);
-
-    ASSERT(pCompactor->pIter->rowInfo.suid || pCompactor->pIter->rowInfo.uid);
-    tRBTreePut(&pCompactor->rbt, &pCompactor->pIter->rbtn);
-  }
-
-  for (int32_t iStt = 0; iStt < pSet->nSttF; iStt++) {
-    code = tsdbOpenSttFileDataIter(pCompactor->pReader, iStt, &pCompactor->pIter);
-    TSDB_CHECK_CODE(code, lino, _exit);
-
-    if (pCompactor->pIter) {
-      pCompactor->pIter->next = pCompactor->iterList;
-      pCompactor->iterList = pCompactor->pIter;
-
-      code = tsdbDataIterNext2(pCompactor->pIter, NULL);
-      TSDB_CHECK_CODE(code, lino, _exit);
-
-      ASSERT(pCompactor->pIter->rowInfo.suid || pCompactor->pIter->rowInfo.uid);
-      tRBTreePut(&pCompactor->rbt, &pCompactor->pIter->rbtn);
-    }
-  }
-  pCompactor->pIter = NULL;
-
-  /* writer */
-  code = tsdbDataFWriterOpen(&pCompactor->pWriter, pCompactor->pTsdb,
-                             &(SDFileSet){.fid = pCompactor->fid,
-                                          .diskId = pSet->diskId,
-                                          .pHeadF = &(SHeadFile){.commitID = pCompactor->commitID},
-                                          .pDataF = &(SDataFile){.commitID = pCompactor->commitID},
-                                          .pSmaF = &(SSmaFile){.commitID = pCompactor->commitID},
-                                          .nSttF = 1,
-                                          .aSttF = {&(SSttFile){.commitID = pCompactor->commitID}}});
-  TSDB_CHECK_CODE(code, lino, _exit);
-
-  if (pCompactor->aBlockIdx) {
-    taosArrayClear(pCompactor->aBlockIdx);
-  } else if ((pCompactor->aBlockIdx = taosArrayInit(0, sizeof(SBlockIdx))) == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
-    TSDB_CHECK_CODE(code, lino, _exit);
-  }
-
-  tMapDataReset(&pCompactor->mDataBlk);
-
-  if (pCompactor->aSttBlk) {
-    taosArrayClear(pCompactor->aSttBlk);
-  } else if ((pCompactor->aSttBlk = taosArrayInit(0, sizeof(SSttBlk))) == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
-    TSDB_CHECK_CODE(code, lino, _exit);
-  }
-
-  tBlockDataReset(&pCompactor->bData);
-  tBlockDataReset(&pCompactor->sData);
-
-_exit:
-  if (code) {
-    tsdbError("vgId:%d %s failed at line %d since %s, fid:%d", TD_VID(pCompactor->pTsdb->pVnode), __func__, lino,
-              tstrerror(code), pCompactor->fid);
-  } else {
-    tsdbInfo("vgId:%d %s done, fid:%d", TD_VID(pCompactor->pTsdb->pVnode), __func__, pCompactor->fid);
-  }
-  return code;
-}
-
-static int32_t tsdbCompactFileSetEnd(STsdbCompactor *pCompactor) {
-  int32_t code = 0;
-  int32_t lino = 0;
-
-  ASSERT(pCompactor->bData.nRow == 0);
-  ASSERT(pCompactor->sData.nRow == 0);
-
-  /* update files */
-  code = tsdbWriteSttBlk(pCompactor->pWriter, pCompactor->aSttBlk);
-  TSDB_CHECK_CODE(code, lino, _exit);
-
-  code = tsdbWriteBlockIdx(pCompactor->pWriter, pCompactor->aBlockIdx);
-  TSDB_CHECK_CODE(code, lino, _exit);
-
-  code = tsdbUpdateDFileSetHeader(pCompactor->pWriter);
-  TSDB_CHECK_CODE(code, lino, _exit);
-
-  code = tsdbFSUpsertFSet(&pCompactor->fs, &pCompactor->pWriter->wSet);
-  TSDB_CHECK_CODE(code, lino, _exit);
-
-  code = tsdbDataFWriterClose(&pCompactor->pWriter, 1);
-  TSDB_CHECK_CODE(code, lino, _exit);
-
-  code = tsdbDataFReaderClose(&pCompactor->pReader);
-  TSDB_CHECK_CODE(code, lino, _exit);
-
-  /* do clear */
-  while ((pCompactor->pIter = pCompactor->iterList) != NULL) {
-    pCompactor->iterList = pCompactor->pIter->next;
-    tsdbCloseDataIter2(pCompactor->pIter);
-  }
-
-  tBlockDataReset(&pCompactor->bData);
-  tBlockDataReset(&pCompactor->sData);
-
-_exit:
-  if (code) {
-    tsdbError("vgId:%d %s failed at line %d since %s, fid:%d", TD_VID(pCompactor->pTsdb->pVnode), __func__, lino,
-              tstrerror(code), pCompactor->fid);
-  } else {
-    tsdbInfo("vgId:%d %s done, fid:%d", TD_VID(pCompactor->pTsdb->pVnode), __func__, pCompactor->fid);
-  }
-  return code;
-}
-
-static int32_t tsdbCompactFileSet(STsdbCompactor *pCompactor, SDFileSet *pSet) {
-  int32_t code = 0;
-  int32_t lino = 0;
-
-  // start compact
-  code = tsdbCompactFileSetStart(pCompactor, pSet);
-  TSDB_CHECK_CODE(code, lino, _exit);
-
-  // do compact, end with a NULL row
-  SRowInfo *pRowInfo;
-  do {
-    code = tsdbCompactNextRow(pCompactor, &pRowInfo);
-    TSDB_CHECK_CODE(code, lino, _exit);
-
-    code = tsdbCompactWriteTableData(pCompactor, pRowInfo);
-    TSDB_CHECK_CODE(code, lino, _exit);
-  } while (pRowInfo);
-
-  // end compact
-  code = tsdbCompactFileSetEnd(pCompactor);
-  TSDB_CHECK_CODE(code, lino, _exit);
-
-_exit:
-  if (code) {
-    tsdbError("vgId:%d %s failed at line %d since %s, fid:%d", TD_VID(pCompactor->pTsdb->pVnode), __func__, lino,
-              tstrerror(code), pCompactor->fid);
-    if (pCompactor->pWriter) tsdbDataFWriterClose(&pCompactor->pWriter, 0);
-    while ((pCompactor->pIter = pCompactor->iterList)) {
-      pCompactor->iterList = pCompactor->pIter->next;
-      tsdbCloseDataIter2(pCompactor->pIter);
-    }
-    if (pCompactor->pReader) tsdbDataFReaderClose(&pCompactor->pReader);
-  }
-  return code;
-}
-
-static void tsdbEndCompact(STsdbCompactor *pCompactor) {
-  // writer
-  tBlockDataDestroy(&pCompactor->sData);
-  tBlockDataDestroy(&pCompactor->bData);
-  taosArrayDestroy(pCompactor->aSttBlk);
-  tMapDataClear(&pCompactor->mDataBlk);
-  taosArrayDestroy(pCompactor->aBlockIdx);
-
-  // reader
-
-  // tombstone
-  taosArrayDestroy(pCompactor->aSkyLine);
-  taosArrayDestroy(pCompactor->aDelData);
-  taosArrayDestroy(pCompactor->aDelIdx);
-
-  // others
-  tDestroyTSchema(pCompactor->tbSkm.pTSchema);
-  tsdbFSDestroy(&pCompactor->fs);
-
-  tsdbInfo("vgId:%d %s done, commit ID:%" PRId64, TD_VID(pCompactor->pTsdb->pVnode), __func__, pCompactor->commitID);
-}
-
-static int32_t tsdbBeginCompact(STsdb *pTsdb, SCompactInfo *pInfo, STsdbCompactor *pCompactor) {
-  int32_t code = 0;
-  int32_t lino = 0;
-
-  pCompactor->pTsdb = pTsdb;
-  pCompactor->commitID = pInfo->commitID;
-  pCompactor->cmprAlg = pTsdb->pVnode->config.tsdbCfg.compression;
-  pCompactor->maxRows = pTsdb->pVnode->config.tsdbCfg.maxRows;
-  pCompactor->minRows = pTsdb->pVnode->config.tsdbCfg.minRows;
-  pCompactor->fid = INT32_MIN;
-
-  code = tsdbFSCopy(pTsdb, &pCompactor->fs);
-  TSDB_CHECK_CODE(code, lino, _exit);
-
-  /* tombstone */
-  if (pCompactor->fs.pDelFile) {
-    code = tsdbDelFReaderOpen(&pCompactor->pDelFReader, pCompactor->fs.pDelFile, pTsdb);
-    TSDB_CHECK_CODE(code, lino, _exit);
-
-    if ((pCompactor->aDelIdx = taosArrayInit(0, sizeof(SDelIdx))) == NULL) {
-      code = TSDB_CODE_OUT_OF_MEMORY;
-      TSDB_CHECK_CODE(code, lino, _exit);
-    }
-
-    if ((pCompactor->aDelData = taosArrayInit(0, sizeof(SDelData))) == NULL) {
-      code = TSDB_CODE_OUT_OF_MEMORY;
-      TSDB_CHECK_CODE(code, lino, _exit);
-    }
-
-    if ((pCompactor->aSkyLine = taosArrayInit(0, sizeof(TSDBKEY))) == NULL) {
-      code = TSDB_CODE_OUT_OF_MEMORY;
-      TSDB_CHECK_CODE(code, lino, _exit);
-    }
-
-    code = tsdbReadDelIdx(pCompactor->pDelFReader, pCompactor->aDelIdx);
-    TSDB_CHECK_CODE(code, lino, _exit);
-  }
-
-  /* reader */
-
-  /* writer */
-  code = tBlockDataCreate(&pCompactor->bData);
-  TSDB_CHECK_CODE(code, lino, _exit);
-
-  code = tBlockDataCreate(&pCompactor->sData);
-  TSDB_CHECK_CODE(code, lino, _exit);
-
-_exit:
-  if (code) {
-    tsdbError("vgId:%d %s failed at line %d since %s, commit ID:%" PRId64, TD_VID(pTsdb->pVnode), __func__, lino,
-              tstrerror(code), pCompactor->commitID);
-    tBlockDataDestroy(&pCompactor->sData);
-    tBlockDataDestroy(&pCompactor->bData);
-    if (pCompactor->fs.pDelFile) {
-      taosArrayDestroy(pCompactor->aSkyLine);
-      taosArrayDestroy(pCompactor->aDelData);
-      taosArrayDestroy(pCompactor->aDelIdx);
-      if (pCompactor->pDelFReader) tsdbDelFReaderClose(&pCompactor->pDelFReader);
-    }
-    tsdbFSDestroy(&pCompactor->fs);
-  } else {
-    tsdbInfo("vgId:%d %s done, commit ID:%" PRId64, TD_VID(pTsdb->pVnode), __func__, pCompactor->commitID);
-  }
-  return code;
-}
-
-int32_t tsdbCompact(STsdb *pTsdb, SCompactInfo *pInfo) {
-  int32_t code = 0;
-
-  STsdbCompactor *pCompactor = &(STsdbCompactor){0};
-
-  if ((code = tsdbBeginCompact(pTsdb, pInfo, pCompactor))) return code;
-
-  for (;;) {
-    SDFileSet *pSet = (SDFileSet *)taosArraySearch(pCompactor->fs.aDFileSet, &(SDFileSet){.fid = pCompactor->fid},
-                                                   tDFileSetCmprFn, TD_GT);
-    if (pSet == NULL) {
-      pCompactor->fid = INT32_MAX;
-      break;
-    }
-
-    if ((code = tsdbCompactFileSet(pCompactor, pSet))) goto _exit;
-  }
-
-  if ((code = tsdbFSUpsertDelFile(&pCompactor->fs, NULL))) goto _exit;
-
-_exit:
-  if (code) {
-    tsdbAbortCompact(pCompactor);
-  } else {
-    tsdbCommitCompact(pCompactor);
-  }
-  tsdbEndCompact(pCompactor);
-  return code;
-}

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

@@ -3512,6 +3512,7 @@ static int32_t checkForNeighborFileBlock(STsdbReader* pReader, STableBlockScanIn
                                          CHECK_FILEBLOCK_STATE* state) {
   SFileBlockDumpInfo* pDumpInfo = &pReader->status.fBlockDumpInfo;
   SBlockData*         pBlockData = &pReader->status.fileBlockData;
+  bool    asc = ASCENDING_TRAVERSE(pReader->order);
 
   *state = CHECK_FILEBLOCK_QUIT;
   int32_t step = ASCENDING_TRAVERSE(pReader->order) ? 1 : -1;
@@ -3522,7 +3523,7 @@ static int32_t checkForNeighborFileBlock(STsdbReader* pReader, STableBlockScanIn
   if (loadNeighbor && (code == TSDB_CODE_SUCCESS)) {
     pDumpInfo->rowIndex =
         doMergeRowsInFileBlockImpl(pBlockData, pDumpInfo->rowIndex, key, pMerger, &pReader->verRange, step);
-    if (pDumpInfo->rowIndex >= pDumpInfo->totalRows) {
+    if ((pDumpInfo->rowIndex >= pDumpInfo->totalRows && asc) || (pDumpInfo->rowIndex < 0 && !asc)) {
       *state = CHECK_FILEBLOCK_CONT;
     }
   }

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

@@ -15,7 +15,7 @@
 
 #include "tsdb.h"
 
-static bool tsdbShouldDoRetention(STsdb *pTsdb, int64_t now) {
+static bool tsdbShouldDoRetentionImpl(STsdb *pTsdb, int64_t now) {
   for (int32_t iSet = 0; iSet < taosArrayGetSize(pTsdb->fs.aDFileSet); iSet++) {
     SDFileSet *pSet = (SDFileSet *)taosArrayGet(pTsdb->fs.aDFileSet, iSet);
     int32_t    expLevel = tsdbFidLevel(pSet->fid, &pTsdb->keepCfg, now);
@@ -38,19 +38,21 @@ static bool tsdbShouldDoRetention(STsdb *pTsdb, int64_t now) {
 
   return false;
 }
+bool tsdbShouldDoRetention(STsdb *pTsdb, int64_t now) {
+  bool should;
+  taosThreadRwlockRdlock(&pTsdb->rwLock);
+  should = tsdbShouldDoRetentionImpl(pTsdb, now);
+  taosThreadRwlockUnlock(&pTsdb->rwLock);
+  return should;
+}
 
 int32_t tsdbDoRetention(STsdb *pTsdb, int64_t now) {
   int32_t code = 0;
-
+  int32_t lino = 0;
-  if (!tsdbShouldDoRetention(pTsdb, now)) {
-    return code;
-  }
-
-  // do retention
   STsdbFS fs = {0};
 
   code = tsdbFSCopy(pTsdb, &fs);
-  if (code) goto _err;
+  TSDB_CHECK_CODE(code, lino, _exit);
 
   for (int32_t iSet = 0; iSet < taosArrayGetSize(fs.aDFileSet); iSet++) {
     SDFileSet *pSet = (SDFileSet *)taosArrayGet(fs.aDFileSet, iSet);
@@ -60,8 +62,10 @@ int32_t tsdbDoRetention(STsdb *pTsdb, int64_t now) {
     if (expLevel < 0) {
       taosMemoryFree(pSet->pHeadF);
       taosMemoryFree(pSet->pDataF);
-      taosMemoryFree(pSet->aSttF[0]);
       taosMemoryFree(pSet->pSmaF);
+      for (int32_t iStt = 0; iStt < pSet->nSttF; iStt++) {
+        taosMemoryFree(pSet->aSttF[iStt]);
+      }
       taosArrayRemove(fs.aDFileSet, iSet);
       iSet--;
     } else {
@@ -78,35 +82,33 @@ int32_t tsdbDoRetention(STsdb *pTsdb, int64_t now) {
       fSet.diskId = did;
 
       code = tsdbDFileSetCopy(pTsdb, pSet, &fSet);
-      if (code) goto _err;
+      TSDB_CHECK_CODE(code, lino, _exit);
 
       code = tsdbFSUpsertFSet(&fs, &fSet);
-      if (code) goto _err;
+      TSDB_CHECK_CODE(code, lino, _exit);
     }
   }
 
   // do change fs
   code = tsdbFSPrepareCommit(pTsdb, &fs);
-  if (code) goto _err;
+  TSDB_CHECK_CODE(code, lino, _exit);
-
-  taosThreadRwlockWrlock(&pTsdb->rwLock);
-
-  code = tsdbFSCommit(pTsdb);
-  if (code) {
-    taosThreadRwlockUnlock(&pTsdb->rwLock);
-    goto _err;
-  }
-
-  taosThreadRwlockUnlock(&pTsdb->rwLock);
-
-  tsdbFSDestroy(&fs);
 
 _exit:
-  return code;
+  if (code) {
-
+    tsdbError("vgId:%d %s failed at line %d since %s", TD_VID(pTsdb->pVnode), __func__, lino, tstrerror(code));
-_err:
+  } else {
-  tsdbError("vgId:%d, tsdb do retention failed since %s", TD_VID(pTsdb->pVnode), tstrerror(code));
+    tsdbInfo("vgId:%d %s done", TD_VID(pTsdb->pVnode), __func__);
-  ASSERT(0);
+  }
-  // tsdbFSRollback(pTsdb->pFS);
+  tsdbFSDestroy(&fs);
   return code;
 }
+
+static int32_t tsdbCommitRetentionImpl(STsdb *pTsdb) { return tsdbFSCommit(pTsdb); }
+
+int32_t tsdbCommitRetention(STsdb *pTsdb) {
+  taosThreadRwlockWrlock(&pTsdb->rwLock);
+  tsdbCommitRetentionImpl(pTsdb);
+  taosThreadRwlockUnlock(&pTsdb->rwLock);
+  tsdbInfo("vgId:%d %s done", TD_VID(pTsdb->pVnode), __func__);
+  return 0;
+}

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

@@ -35,9 +35,7 @@ int tsdbInsertData(STsdb *pTsdb, int64_t version, SSubmitReq2 *pMsg, SSubmitRsp2
     return -1;
   }
 
-  if (pMsg) {
   arrSize = taosArrayGetSize(pMsg->aSubmitTbData);
-  }
 
   // scan and convert
   if (tsdbScanAndConvertSubmitMsg(pTsdb, pMsg) < 0) {

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

@@ -15,101 +15,116 @@
 
 #include "vnd.h"
 
-static int32_t vnodeCompactTask(void *param) {
+typedef struct {
-  int32_t code = 0;
+  SVnode    *pVnode;
-  int32_t lino = 0;
+  int64_t    now;
+  int64_t    commitID;
+  SVnodeInfo info;
+} SRetentionInfo;
 
-  SCompactInfo *pInfo = (SCompactInfo *)param;
+extern bool    tsdbShouldDoRetention(STsdb *pTsdb, int64_t now);
-  SVnode       *pVnode = pInfo->pVnode;
+extern int32_t tsdbDoRetention(STsdb *pTsdb, int64_t now);
+extern int32_t tsdbCommitRetention(STsdb *pTsdb);
 
-  // do compact
+static int32_t vnodePrepareRentention(SVnode *pVnode, SRetentionInfo *pInfo) {
-  code = tsdbCompact(pInfo->pVnode->pTsdb, pInfo);
-  TSDB_CHECK_CODE(code, lino, _exit);
-
-  // end compact
-  char dir[TSDB_FILENAME_LEN] = {0};
-  if (pVnode->pTfs) {
-    snprintf(dir, TSDB_FILENAME_LEN, "%s%s%s", tfsGetPrimaryPath(pVnode->pTfs), TD_DIRSEP, pVnode->path);
-  } else {
-    snprintf(dir, TSDB_FILENAME_LEN, "%s", pVnode->path);
-  }
-  vnodeCommitInfo(dir);
-
-_exit:
-  tsem_post(&pInfo->pVnode->canCommit);
-  taosMemoryFree(pInfo);
-  return code;
-}
-static int32_t vnodePrepareCompact(SVnode *pVnode, SCompactInfo *pInfo) {
   int32_t code = 0;
   int32_t lino = 0;
 
   tsem_wait(&pVnode->canCommit);
 
-  pInfo->pVnode = pVnode;
-  pInfo->flag = 0;
   pInfo->commitID = ++pVnode->state.commitID;
 
   char dir[TSDB_FILENAME_LEN] = {0};
-  SVnodeInfo info = {0};
-
   if (pVnode->pTfs) {
     snprintf(dir, TSDB_FILENAME_LEN, "%s%s%s", tfsGetPrimaryPath(pVnode->pTfs), TD_DIRSEP, pVnode->path);
   } else {
     snprintf(dir, TSDB_FILENAME_LEN, "%s", pVnode->path);
   }
 
-  if (vnodeLoadInfo(dir, &info) < 0) {
+  if (vnodeLoadInfo(dir, &pInfo->info) < 0) {
     code = terrno;
-    goto _exit;
-  }
-
-  info.state.commitID = pInfo->commitID;
-
-  if (vnodeSaveInfo(dir, &info) < 0) {
-    code = terrno;
-    goto _exit;
-  }
-
-_exit:
-  if (code) {
-    vError("vgId:%d %s failed at line %d since %s, commit ID:%" PRId64, TD_VID(pVnode), __func__, lino, tstrerror(code),
-           pVnode->state.commitID);
-  } else {
-    vDebug("vgId:%d %s done, commit ID:%" PRId64, TD_VID(pVnode), __func__, pVnode->state.commitID);
-  }
-  return code;
-}
-int32_t vnodeAsyncCompact(SVnode *pVnode) {
-  int32_t code = 0;
-  int32_t lino = 0;
-
-  SCompactInfo *pInfo = taosMemoryCalloc(1, sizeof(*pInfo));
-  if (pInfo == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
     TSDB_CHECK_CODE(code, lino, _exit);
   }
 
-  vnodeAsyncCommit(pVnode);
-
-  code = vnodePrepareCompact(pVnode, pInfo);
-  TSDB_CHECK_CODE(code, lino, _exit);
-
-  vnodeScheduleTask(vnodeCompactTask, pInfo);
-
 _exit:
   if (code) {
     vError("vgId:%d %s failed at line %d since %s", TD_VID(pVnode), __func__, lino, tstrerror(code));
-    if (pInfo) taosMemoryFree(pInfo);
+    tsem_post(&pVnode->canCommit);
   } else {
     vInfo("vgId:%d %s done", TD_VID(pVnode), __func__);
   }
   return code;
 }
 
-int32_t vnodeSyncCompact(SVnode *pVnode) {
+static int32_t vnodeRetentionTask(void *param) {
-  vnodeAsyncCompact(pVnode);
+  int32_t code = 0;
-  tsem_wait(&pVnode->canCommit);
+  int32_t lino = 0;
-  tsem_post(&pVnode->canCommit);
+
+  SRetentionInfo *pInfo = (SRetentionInfo *)param;
+  SVnode         *pVnode = pInfo->pVnode;
+  char            dir[TSDB_FILENAME_LEN] = {0};
+
+  if (pVnode->pTfs) {
+    snprintf(dir, TSDB_FILENAME_LEN, "%s%s%s", tfsGetPrimaryPath(pVnode->pTfs), TD_DIRSEP, pVnode->path);
+  } else {
+    snprintf(dir, TSDB_FILENAME_LEN, "%s", pVnode->path);
+  }
+
+  // save info
+  pInfo->info.state.commitID = pInfo->commitID;
+
+  if (vnodeSaveInfo(dir, &pInfo->info) < 0) {
+    code = terrno;
+    TSDB_CHECK_CODE(code, lino, _exit);
+  }
+
+  // do job
+  code = tsdbDoRetention(pInfo->pVnode->pTsdb, pInfo->now);
+  TSDB_CHECK_CODE(code, lino, _exit);
+
+  // commit info
+  vnodeCommitInfo(dir);
+
+  // commit sub-job
+  tsdbCommitRetention(pVnode->pTsdb);
+
+_exit:
+  if (code) {
+    vError("vgId:%d %s failed at line %d since %s", TD_VID(pInfo->pVnode), __func__, lino, tstrerror(code));
+  } else {
+    vInfo("vgId:%d %s done", TD_VID(pInfo->pVnode), __func__);
+  }
+  tsem_post(&pInfo->pVnode->canCommit);
+  taosMemoryFree(pInfo);
+  return code;
+}
+
+int32_t vnodeAsyncRentention(SVnode *pVnode, int64_t now) {
+  int32_t code = 0;
+  int32_t lino = 0;
+
+  if (!tsdbShouldDoRetention(pVnode->pTsdb, now)) return code;
+
+  SRetentionInfo *pInfo = (SRetentionInfo *)taosMemoryCalloc(1, sizeof(*pInfo));
+  if (pInfo == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    TSDB_CHECK_CODE(code, lino, _exit);
+  }
+
+  pInfo->pVnode = pVnode;
+  pInfo->now = now;
+
+  code = vnodePrepareRentention(pVnode, pInfo);
+  TSDB_CHECK_CODE(code, lino, _exit);
+
+  vnodeScheduleTask(vnodeRetentionTask, pInfo);
+
+_exit:
+  if (code) {
+    vError("vgId:%d %s failed at line %d since %s", TD_VID(pInfo->pVnode), __func__, lino, tstrerror(code));
+    if (pInfo) taosMemoryFree(pInfo);
+  } else {
+    vInfo("vgId:%d %s done", TD_VID(pInfo->pVnode), __func__);
+  }
   return 0;
 }

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

@@ -586,6 +586,7 @@ void vnodeUpdateMetaRsp(SVnode *pVnode, STableMetaRsp *pMetaRsp) {
   pMetaRsp->precision = pVnode->config.tsdbCfg.precision;
 }
 
+extern int32_t vnodeAsyncRentention(SVnode *pVnode, int64_t now);
 static int32_t vnodeProcessTrimReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp) {
   int32_t     code = 0;
   SVTrimDbReq trimReq = {0};
@@ -599,11 +600,15 @@ static int32_t vnodeProcessTrimReq(SVnode *pVnode, int64_t version, void *pReq,
   vInfo("vgId:%d, trim vnode request will be processed, time:%d", pVnode->config.vgId, trimReq.timestamp);
 
 // process
+#if 0
   code = tsdbDoRetention(pVnode->pTsdb, trimReq.timestamp);
   if (code) goto _exit;
 
   code = smaDoRetention(pVnode->pSma, trimReq.timestamp);
   if (code) goto _exit;
+#else
+  vnodeAsyncRentention(pVnode, trimReq.timestamp);
+#endif
 
 _exit:
   return code;
@@ -635,6 +640,10 @@ static int32_t vnodeProcessDropTtlTbReq(SVnode *pVnode, int64_t version, void *p
 
   ret = smaDoRetention(pVnode->pSma, ttlReq.timestamp);
   if (ret) goto end;
+#else
+  vnodeAsyncRentention(pVnode, ttlReq.timestamp);
+  tsem_wait(&pVnode->canCommit);
+  tsem_post(&pVnode->canCommit);
 #endif
 
 end:
@@ -1264,8 +1273,8 @@ static int32_t vnodeProcessSubmitReq(SVnode *pVnode, int64_t version, void *pReq
         goto _exit;
       }
 
-      for (int32_t i = 1; i < nColData; i++) {
+      for (int32_t j = 1; j < nColData; j++) {
-        if (aColData[i].nVal != aColData[0].nVal) {
+        if (aColData[j].nVal != aColData[0].nVal) {
           code = TSDB_CODE_INVALID_MSG;
           goto _exit;
         }
@@ -1299,8 +1308,8 @@ static int32_t vnodeProcessSubmitReq(SVnode *pVnode, int64_t version, void *pReq
       SVCreateTbRsp *pCreateTbRsp = taosArrayReserve(pSubmitRsp->aCreateTbRsp, 1);
 
       // create table
-      if (metaCreateTable(pVnode->pMeta, version, pSubmitTbData->pCreateTbReq, &pCreateTbRsp->pMeta) ==
+      if (metaCreateTable(pVnode->pMeta, version, pSubmitTbData->pCreateTbReq, &pCreateTbRsp->pMeta) == 0) {
-          0) {  // create table success
+        // create table success
 
         if (newTbUids == NULL &&
             (newTbUids = taosArrayInit(TARRAY_SIZE(pSubmitReq->aSubmitTbData), sizeof(int64_t))) == NULL) {
@@ -1330,7 +1339,7 @@ static int32_t vnodeProcessSubmitReq(SVnode *pVnode, int64_t version, void *pReq
     pSubmitRsp->affectedRows += affectedRows;
   }
 
-  // update table uid list
+  // update the affected table uid list
   if (taosArrayGetSize(newTbUids) > 0) {
     vDebug("vgId:%d, add %d table into query table list in handling submit", TD_VID(pVnode),
            (int32_t)taosArrayGetSize(newTbUids));
@@ -1632,17 +1641,13 @@ static int32_t vnodeProcessDropIndexReq(SVnode *pVnode, int64_t version, void *p
   return TSDB_CODE_SUCCESS;
 }
 
+extern int32_t vnodeProcessCompactVnodeReqImpl(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp);
+
 static int32_t vnodeProcessCompactVnodeReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp) {
-  SCompactVnodeReq req = {0};
+  return vnodeProcessCompactVnodeReqImpl(pVnode, version, pReq, len, pRsp);
-  if (tDeserializeSCompactVnodeReq(pReq, len, &req) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
-    return TSDB_CODE_INVALID_MSG;
 }
-  vInfo("vgId:%d, compact msg will be processed, db:%s dbUid:%" PRId64 " compactStartTime:%" PRId64, TD_VID(pVnode),
-        req.db, req.dbUid, req.compactStartTime);
 
-  vnodeAsyncCompact(pVnode);
-  vnodeBegin(pVnode);
 
-  return 0;
+#ifndef TD_ENTERPRISE
-}
+int32_t vnodeProcessCompactVnodeReqImpl(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp) { return 0; }
+#endif

source/libs/command/src/command.c

@@ -248,13 +248,13 @@ static const char* cacheModelStr(int8_t cacheModel) {
   return TSDB_CACHE_MODEL_NONE_STR;
 }
 
-static void setCreateDBResultIntoDataBlock(SSDataBlock* pBlock, char* dbFName, SDbCfgInfo* pCfg) {
+static void setCreateDBResultIntoDataBlock(SSDataBlock* pBlock, char* dbName, char* dbFName, SDbCfgInfo* pCfg) {
   blockDataEnsureCapacity(pBlock, 1);
   pBlock->info.rows = 1;
 
   SColumnInfoData* pCol1 = taosArrayGet(pBlock->pDataBlock, 0);
   char             buf1[SHOW_CREATE_DB_RESULT_FIELD1_LEN] = {0};
-  STR_TO_VARSTR(buf1, dbFName);
+  STR_TO_VARSTR(buf1, dbName);
   colDataSetVal(pCol1, 0, buf1, false);
 
   SColumnInfoData* pCol2 = taosArrayGet(pBlock->pDataBlock, 1);
@@ -277,16 +277,20 @@ static void setCreateDBResultIntoDataBlock(SSDataBlock* pBlock, char* dbFName, S
   }
 
   char* retentions = buildRetension(pCfg->pRetensions);
+  int32_t dbFNameLen = strlen(dbFName);
+  int32_t hashPrefix = (pCfg->hashPrefix > (dbFNameLen + 1)) ? (pCfg->hashPrefix - dbFNameLen - 1) : 0;
 
   len += sprintf(
       buf2 + VARSTR_HEADER_SIZE,
       "CREATE DATABASE `%s` BUFFER %d CACHESIZE %d CACHEMODEL '%s' COMP %d DURATION %dm "
       "WAL_FSYNC_PERIOD %d MAXROWS %d MINROWS %d STT_TRIGGER %d KEEP %dm,%dm,%dm PAGES %d PAGESIZE %d PRECISION '%s' REPLICA %d "
-      "WAL_LEVEL %d VGROUPS %d SINGLE_STABLE %d",
+      "WAL_LEVEL %d VGROUPS %d SINGLE_STABLE %d TABLE_PREFIX %d TABLE_SUFFIX %d TSDB_PAGESIZE %d "
-      dbFName, pCfg->buffer, pCfg->cacheSize, cacheModelStr(pCfg->cacheLast), pCfg->compression, pCfg->daysPerFile,
+      "WAL_RETENTION_PERIOD %d WAL_RETENTION_SIZE %" PRId64 " WAL_ROLL_PERIOD %d WAL_SEGMENT_SIZE %" PRId64,
+      dbName, pCfg->buffer, pCfg->cacheSize, cacheModelStr(pCfg->cacheLast), pCfg->compression, pCfg->daysPerFile,
       pCfg->walFsyncPeriod, pCfg->maxRows, pCfg->minRows,  pCfg->sstTrigger, pCfg->daysToKeep0, pCfg->daysToKeep1, pCfg->daysToKeep2,
       pCfg->pages, pCfg->pageSize, prec, pCfg->replications, pCfg->walLevel, pCfg->numOfVgroups,
-      1 == pCfg->numOfStables);
+      1 == pCfg->numOfStables, hashPrefix, pCfg->hashSuffix, pCfg->tsdbPageSize, pCfg->walRetentionPeriod,
+      pCfg->walRetentionSize, pCfg->walRollPeriod, pCfg->walSegmentSize);
 
   if (retentions) {
     len += sprintf(buf2 + VARSTR_HEADER_SIZE + len, " RETENTIONS %s", retentions);
@@ -404,7 +408,7 @@ static int32_t execShowCreateDatabase(SShowCreateDatabaseStmt* pStmt, SRetrieveT
   SSDataBlock* pBlock = NULL;
   int32_t      code = buildCreateDBResultDataBlock(&pBlock);
   if (TSDB_CODE_SUCCESS == code) {
-    setCreateDBResultIntoDataBlock(pBlock, pStmt->dbName, pStmt->pCfg);
+    setCreateDBResultIntoDataBlock(pBlock, pStmt->dbName, pStmt->dbFName, pStmt->pCfg);
   }
   if (TSDB_CODE_SUCCESS == code) {
     code = buildRetrieveTableRsp(pBlock, SHOW_CREATE_DB_RESULT_COLS, pRsp);

source/libs/executor/inc/executorimpl.h

@@ -134,7 +134,6 @@ typedef struct {
   // const SSubmitReq* pReq;
 
   SPackedData         submit;
-
   SSchemaWrapper*     schema;
   char                tbName[TSDB_TABLE_NAME_LEN];
   int8_t              recoverStep;
@@ -733,7 +732,7 @@ void    updateLoadRemoteInfo(SLoadRemoteDataInfo* pInfo, int64_t numOfRows, int3
 
 STimeWindow getFirstQualifiedTimeWindow(int64_t ts, STimeWindow* pWindow, SInterval* pInterval, int32_t order);
 
-int32_t getTableScanInfo(SOperatorInfo* pOperator, int32_t* order, int32_t* scanFlag);
+int32_t getTableScanInfo(SOperatorInfo* pOperator, int32_t* order, int32_t* scanFlag, bool inheritUsOrder);
 int32_t getBufferPgSize(int32_t rowSize, uint32_t* defaultPgsz, uint32_t* defaultBufsz);
 
 extern void doDestroyExchangeOperatorInfo(void* param);

source/libs/executor/src/executil.c

@@ -850,8 +850,7 @@ static SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTa
         tagVal.cid = pColInfo->info.colId;
         if (p1->pTagVal == NULL) {
           colDataSetNULL(pColInfo, i);
-        }
+        } else {
-
           const char* p = metaGetTableTagVal(p1->pTagVal, pColInfo->info.type, &tagVal);
 
           if (p == NULL || (pColInfo->info.type == TSDB_DATA_TYPE_JSON && ((STag*)p)->nTag == 0)) {
@@ -880,6 +879,7 @@ static SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTa
         }
       }
     }
+  }
 
   return pResBlock;
 }

source/libs/executor/src/executor.c

@@ -1035,8 +1035,9 @@ int32_t qStreamScanMemData(qTaskInfo_t tinfo, const SSubmitReq* pReq, int64_t sc
 
 int32_t qStreamSetScanMemData(qTaskInfo_t tinfo, SPackedData submit) {
   SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo;
-  ASSERT(pTaskInfo->execModel == OPTR_EXEC_MODEL_QUEUE);
+  ASSERT((pTaskInfo->execModel == OPTR_EXEC_MODEL_QUEUE )&& (pTaskInfo->streamInfo.submit.msgStr == NULL));
-  ASSERT(pTaskInfo->streamInfo.submit.msgStr == NULL);
+  qDebug("set the submit block for future scan");
+
   pTaskInfo->streamInfo.submit = submit;
   return 0;
 }
@@ -1047,14 +1048,16 @@ int32_t qStreamPrepareScan(qTaskInfo_t tinfo, STqOffsetVal* pOffset, int8_t subT
   ASSERT(pTaskInfo->execModel == OPTR_EXEC_MODEL_QUEUE);
   pTaskInfo->streamInfo.prepareStatus = *pOffset;
   pTaskInfo->streamInfo.returned = 0;
+
   if (tOffsetEqual(pOffset, &pTaskInfo->streamInfo.lastStatus)) {
     return 0;
   }
+
   if (subType == TOPIC_SUB_TYPE__COLUMN) {
-    uint16_t type = pOperator->operatorType;
     pOperator->status = OP_OPENED;
+
     // TODO add more check
-    if (type != QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN) {
+    if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN) {
       ASSERT(pOperator->numOfDownstream == 1);
       pOperator = pOperator->pDownstream[0];
     }
@@ -1064,11 +1067,13 @@ int32_t qStreamPrepareScan(qTaskInfo_t tinfo, STqOffsetVal* pOffset, int8_t subT
       STableScanInfo* pTSInfo = pInfo->pTableScanOp->info;
       tsdbReaderClose(pTSInfo->base.dataReader);
       pTSInfo->base.dataReader = NULL;
+      // let's seek to the next version in wal file
       if (tqSeekVer(pInfo->tqReader, pOffset->version + 1) < 0) {
         return -1;
       }
     } else if (pOffset->type == TMQ_OFFSET__SNAPSHOT_DATA) {
-      /*pInfo->blockType = STREAM_INPUT__TABLE_SCAN;*/
+      // iterate all tables from tableInfoList, and retrieve rows from each table one-by-one
+      // those data are from the snapshot in tsdb, besides the data in the wal file.
       int64_t uid = pOffset->uid;
       int64_t ts = pOffset->ts;
 
@@ -1127,7 +1132,6 @@ int32_t qStreamPrepareScan(qTaskInfo_t tinfo, STqOffsetVal* pOffset, int8_t subT
 
       qDebug("tsdb reader offset seek to uid %" PRId64 " ts %" PRId64 ", table cur set to %d , all table num %d", uid,
              ts, pTableScanInfo->currentTable, numOfTables);
-      /*}*/
     } else {
       ASSERT(0);
     }
@@ -1170,7 +1174,7 @@ int32_t qStreamPrepareScan(qTaskInfo_t tinfo, STqOffsetVal* pOffset, int8_t subT
     tDeleteSSchemaWrapper(pTaskInfo->streamInfo.schema);
     pTaskInfo->streamInfo.schema = mtInfo.schema;
 
-    qDebug("tmqsnap qStreamPrepareScan snapshot data uid %" PRId64 " ts %" PRId64, mtInfo.uid, pOffset->ts);
+    qDebug("tmqsnap qStreamPrepareScan snapshot data uid:%" PRId64 " ts %" PRId64, mtInfo.uid, pOffset->ts);
   } else if (pOffset->type == TMQ_OFFSET__SNAPSHOT_META) {
     SStreamRawScanInfo* pInfo = pOperator->info;
     SSnapContext*       sContext = pInfo->sContext;
@@ -1178,7 +1182,7 @@ int32_t qStreamPrepareScan(qTaskInfo_t tinfo, STqOffsetVal* pOffset, int8_t subT
       qError("setForSnapShot error. uid:%" PRIu64 " ,version:%" PRId64, pOffset->uid, pOffset->version);
       return -1;
     }
-    qDebug("tmqsnap qStreamPrepareScan snapshot meta uid %" PRId64 " ts %" PRId64, pOffset->uid, pOffset->ts);
+    qDebug("tmqsnap qStreamPrepareScan snapshot meta uid:%" PRId64 " ts %" PRId64, pOffset->uid, pOffset->ts);
   } else if (pOffset->type == TMQ_OFFSET__LOG) {
     SStreamRawScanInfo* pInfo = pOperator->info;
     tsdbReaderClose(pInfo->dataReader);

source/libs/executor/src/executorimpl.c

@@ -1197,16 +1197,11 @@ int32_t doCopyToSDataBlock(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprS
     }
 
     if (pBlock->info.rows + pRow->numOfRows > pBlock->info.capacity) {
-      // expand the result datablock capacity
+      blockDataEnsureCapacity(pBlock, pBlock->info.rows + pRow->numOfRows);
-      if (pRow->numOfRows > pBlock->info.capacity) {
+      qDebug("datablock capacity not sufficient, expand to required:%d, current capacity:%d, %s",
-        blockDataEnsureCapacity(pBlock, pRow->numOfRows);
+             (pRow->numOfRows+pBlock->info.rows),
-        qDebug("datablock capacity not sufficient, expand to requried:%d, current capacity:%d, %s", pRow->numOfRows,
              pBlock->info.capacity, GET_TASKID(pTaskInfo));
         // todo set the pOperator->resultInfo size
-      } else {
-        releaseBufPage(pBuf, page);
-        break;
-      }
     }
 
     pGroupResInfo->index += 1;
@@ -1449,16 +1444,21 @@ int32_t appendDownstream(SOperatorInfo* p, SOperatorInfo** pDownstream, int32_t
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t getTableScanInfo(SOperatorInfo* pOperator, int32_t* order, int32_t* scanFlag) {
+int32_t getTableScanInfo(SOperatorInfo* pOperator, int32_t* order, int32_t* scanFlag, bool inheritUsOrder) {
   // todo add more information about exchange operation
   int32_t type = pOperator->operatorType;
-  if (type == QUERY_NODE_PHYSICAL_PLAN_EXCHANGE || type == QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN ||
+  if (type == QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN || type == QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN ||
-      type == QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN || type == QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN ||
+      type == QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN || type == QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN ||
-      type == QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN || type == QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN ||
+      type == QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN || type == QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN) {
-      type == QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN) {
     *order = TSDB_ORDER_ASC;
     *scanFlag = MAIN_SCAN;
     return TSDB_CODE_SUCCESS;
+  } else if (type == QUERY_NODE_PHYSICAL_PLAN_EXCHANGE) {
+    if (!inheritUsOrder) {
+      *order = TSDB_ORDER_ASC;
+    }
+    *scanFlag = MAIN_SCAN;
+    return TSDB_CODE_SUCCESS;
   } else if (type == QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN) {
     STableScanInfo* pTableScanInfo = pOperator->info;
     *order = pTableScanInfo->base.cond.order;
@@ -1473,7 +1473,7 @@ int32_t getTableScanInfo(SOperatorInfo* pOperator, int32_t* order, int32_t* scan
     if (pOperator->pDownstream == NULL || pOperator->pDownstream[0] == NULL) {
       return TSDB_CODE_INVALID_PARA;
     } else {
-      return getTableScanInfo(pOperator->pDownstream[0], order, scanFlag);
+      return getTableScanInfo(pOperator->pDownstream[0], order, scanFlag, inheritUsOrder);
     }
   }
 }
@@ -1589,7 +1589,7 @@ static int32_t doOpenAggregateOptr(SOperatorInfo* pOperator) {
     }
     hasValidBlock = true;
 
-    int32_t code = getTableScanInfo(pOperator, &order, &scanFlag);
+    int32_t code = getTableScanInfo(pOperator, &order, &scanFlag, false);
     if (code != TSDB_CODE_SUCCESS) {
       destroyDataBlockForEmptyInput(blockAllocated, &pBlock);
       T_LONG_JMP(pTaskInfo->env, code);

source/libs/executor/src/filloperator.c

@@ -69,7 +69,7 @@ static void doHandleRemainBlockForNewGroupImpl(SOperatorInfo* pOperator, SFillOp
 
   int32_t order = TSDB_ORDER_ASC;
   int32_t scanFlag = MAIN_SCAN;
-  getTableScanInfo(pOperator, &order, &scanFlag);
+  getTableScanInfo(pOperator, &order, &scanFlag, false);
 
   int64_t ekey = pInfo->existNewGroupBlock->info.window.ekey;
   taosResetFillInfo(pInfo->pFillInfo, getFillInfoStart(pInfo->pFillInfo));
@@ -128,7 +128,7 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) {
 
   int32_t order = TSDB_ORDER_ASC;
   int32_t scanFlag = MAIN_SCAN;
-  getTableScanInfo(pOperator, &order, &scanFlag);
+  getTableScanInfo(pOperator, &order, &scanFlag, false);
 
   doHandleRemainBlockFromNewGroup(pOperator, pInfo, pResultInfo, pTaskInfo);
   if (pResBlock->info.rows > 0) {

source/libs/executor/src/groupoperator.c

@@ -383,7 +383,7 @@ static SSDataBlock* hashGroupbyAggregate(SOperatorInfo* pOperator) {
       break;
     }
 
-    int32_t code = getTableScanInfo(pOperator, &order, &scanFlag);
+    int32_t code = getTableScanInfo(pOperator, &order, &scanFlag, false);
     if (code != TSDB_CODE_SUCCESS) {
       T_LONG_JMP(pTaskInfo->env, code);
     }

source/libs/executor/src/projectoperator.c

@@ -289,7 +289,7 @@ SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) {
       }
 
       // the pDataBlock are always the same one, no need to call this again
-      int32_t code = getTableScanInfo(downstream, &order, &scanFlag);
+      int32_t code = getTableScanInfo(downstream, &order, &scanFlag, false);
       if (code != TSDB_CODE_SUCCESS) {
         T_LONG_JMP(pTaskInfo->env, code);
       }
@@ -441,7 +441,7 @@ static void doHandleDataBlock(SOperatorInfo* pOperator, SSDataBlock* pBlock, SOp
   SExprSupp*          pSup = &pOperator->exprSupp;
 
   // the pDataBlock are always the same one, no need to call this again
-  int32_t code = getTableScanInfo(downstream, &order, &scanFlag);
+  int32_t code = getTableScanInfo(downstream, &order, &scanFlag, false);
   if (code != TSDB_CODE_SUCCESS) {
     T_LONG_JMP(pTaskInfo->env, code);
   }

source/libs/executor/src/scanoperator.c

@@ -1562,7 +1562,7 @@ static SSDataBlock* doQueueScan(SOperatorInfo* pOperator) {
   SExecTaskInfo*   pTaskInfo = pOperator->pTaskInfo;
   SStreamScanInfo* pInfo = pOperator->info;
 
-  qDebug("queue scan called");
+  qDebug("start to exec queue scan");
 
   if (pTaskInfo->streamInfo.submit.msgStr != NULL) {
     if (pInfo->tqReader->msg2.msgStr == NULL) {
@@ -1587,7 +1587,6 @@ static SSDataBlock* doQueueScan(SOperatorInfo* pOperator) {
       SSDataBlock block = {0};
 
       int32_t code = tqRetrieveDataBlock2(&block, pInfo->tqReader, NULL);
-
       if (code != TSDB_CODE_SUCCESS || block.info.rows == 0) {
         continue;
       }
@@ -1652,8 +1651,6 @@ static SSDataBlock* doQueueScan(SOperatorInfo* pOperator) {
       } else if (ret.fetchType == FETCH_TYPE__NONE ||
                  (ret.fetchType == FETCH_TYPE__SEP && pOperator->status == OP_EXEC_RECV)) {
         pTaskInfo->streamInfo.lastStatus = ret.offset;
-        ASSERT(pTaskInfo->streamInfo.lastStatus.version >= pTaskInfo->streamInfo.prepareStatus.version);
-        ASSERT(pTaskInfo->streamInfo.lastStatus.version + 1 == pInfo->tqReader->pWalReader->curVersion);
         char formatBuf[80];
         tFormatOffset(formatBuf, 80, &ret.offset);
         qDebug("queue scan log return null, offset %s", formatBuf);
@@ -1661,16 +1658,6 @@ static SSDataBlock* doQueueScan(SOperatorInfo* pOperator) {
         return NULL;
       }
     }
-#if 0
-    } else if (pTaskInfo->streamInfo.prepareStatus.type == TMQ_OFFSET__SNAPSHOT_DATA) {
-    SSDataBlock* pResult = doTableScan(pInfo->pTableScanOp);
-    if (pResult && pResult->info.rows > 0) {
-      qDebug("stream scan tsdb return %d rows", pResult->info.rows);
-      return pResult;
-    }
-    qDebug("stream scan tsdb return null");
-    return NULL;
-#endif
   } else {
     qError("unexpected streamInfo prepare type: %d", pTaskInfo->streamInfo.prepareStatus.type);
     return NULL;

source/libs/executor/src/sortoperator.c

@@ -672,7 +672,9 @@ SSDataBlock* getMultiwaySortedBlockData(SSortHandle* pHandle, SSDataBlock* pData
     }
 
     bool limitReached = applyLimitOffset(&pInfo->limitInfo, p, pTaskInfo);
-    if (limitReached) {
+    // if limit is reached within a group, do not clear limiInfo otherwise the next block
+    // will be processed.
+    if (newgroup && limitReached) {
       resetLimitInfoForNextGroup(&pInfo->limitInfo);
     }
 

source/libs/executor/src/timewindowoperator.c

@@ -1072,7 +1072,7 @@ static int32_t doOpenIntervalAgg(SOperatorInfo* pOperator) {
       break;
     }
 
-    getTableScanInfo(pOperator, &pInfo->inputOrder, &scanFlag);
+    getTableScanInfo(pOperator, &pInfo->inputOrder, &scanFlag, true);
 
     if (pInfo->scalarSupp.pExprInfo != NULL) {
       SExprSupp* pExprSup = &pInfo->scalarSupp;
@@ -4294,7 +4294,7 @@ static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) {
       }
     }
 
-    getTableScanInfo(pOperator, &pIaInfo->inputOrder, &scanFlag);
+    getTableScanInfo(pOperator, &pIaInfo->inputOrder, &scanFlag, false);
     setInputDataBlock(pSup, pBlock, pIaInfo->inputOrder, scanFlag, true);
     doMergeAlignedIntervalAggImpl(pOperator, &pIaInfo->binfo.resultRowInfo, pBlock, pRes);
 
@@ -4621,7 +4621,7 @@ static SSDataBlock* doMergeIntervalAgg(SOperatorInfo* pOperator) {
         break;
       }
 
-      getTableScanInfo(pOperator, &iaInfo->inputOrder, &scanFlag);
+      getTableScanInfo(pOperator, &iaInfo->inputOrder, &scanFlag, false);
       setInputDataBlock(pExpSupp, pBlock, iaInfo->inputOrder, scanFlag, true);
       doMergeIntervalAggImpl(pOperator, &iaInfo->binfo.resultRowInfo, pBlock, scanFlag, pRes);
 

source/libs/function/src/builtinsimpl.c

@@ -5438,8 +5438,6 @@ int32_t blockDistFunction(SqlFunctionCtx* pCtx) {
   if (pDistInfo->maxRows < p1.maxRows) {
     pDistInfo->maxRows = p1.maxRows;
   }
-  pDistInfo->numOfVgroups += (p1.numOfTables != 0 ? 1 : 0);
-
   pDistInfo->numOfVgroups += (p1.numOfTables != 0 ? 1 : 0);
   for (int32_t i = 0; i < tListLen(pDistInfo->blockRowsHisto); ++i) {
     pDistInfo->blockRowsHisto[i] += p1.blockRowsHisto[i];

source/libs/function/src/udfd.c

@@ -606,9 +606,8 @@ int32_t udfdLoadUdf(char *udfName, SUdf *udf) {
 }
 static bool udfdRpcRfp(int32_t code, tmsg_t msgType) {
   if (code == TSDB_CODE_RPC_NETWORK_UNAVAIL || code == TSDB_CODE_RPC_BROKEN_LINK || code == TSDB_CODE_SYN_NOT_LEADER ||
-      code == TSDB_CODE_RPC_SOMENODE_NOT_CONNECTED ||
+      code == TSDB_CODE_RPC_SOMENODE_NOT_CONNECTED || code == TSDB_CODE_SYN_RESTORING ||
-      code == TSDB_CODE_SYN_RESTORING || code == TSDB_CODE_MNODE_NOT_FOUND || code == TSDB_CODE_APP_IS_STARTING ||
+      code == TSDB_CODE_MNODE_NOT_FOUND || code == TSDB_CODE_APP_IS_STARTING || code == TSDB_CODE_APP_IS_STOPPING) {
-      code == TSDB_CODE_APP_IS_STOPPING) {
     if (msgType == TDMT_SCH_QUERY || msgType == TDMT_SCH_MERGE_QUERY || msgType == TDMT_SCH_FETCH ||
         msgType == TDMT_SCH_MERGE_FETCH) {
       return false;
@@ -673,6 +672,12 @@ int32_t udfdOpenClientRpc() {
   rpcInit.rfp = udfdRpcRfp;
   rpcInit.compressSize = tsCompressMsgSize;
 
+  int32_t connLimitNum = tsNumOfRpcSessions / (tsNumOfRpcThreads * 3);
+  connLimitNum = TMAX(connLimitNum, 10);
+  connLimitNum = TMIN(connLimitNum, 500);
+  rpcInit.connLimitNum = connLimitNum;
+  rpcInit.timeToGetConn = tsTimeToGetAvailableConn;
+
   global.clientRpc = rpcOpen(&rpcInit);
   if (global.clientRpc == NULL) {
     fnError("failed to init dnode rpc client");

source/libs/index/src/indexFstFile.c

@@ -18,6 +18,7 @@
 #include "indexInt.h"
 #include "indexUtil.h"
 #include "os.h"
+#include "osDef.h"
 #include "tutil.h"
 
 static int32_t kBlockSize = 4096;
@@ -172,7 +173,8 @@ static FORCE_INLINE int idxFileCtxDoFlush(IFileCtx* ctx) {
       int32_t nw = taosWriteFile(ctx->file.pFile, ctx->file.wBuf, ctx->file.wBufOffset);
       ctx->file.wBufOffset = 0;
     }
-    taosFsyncFile(ctx->file.pFile);
+    int ret = taosFsyncFile(ctx->file.pFile);
+    UNUSED(ret);
   } else {
     // do nothing
   }
@@ -180,11 +182,11 @@ static FORCE_INLINE int idxFileCtxDoFlush(IFileCtx* ctx) {
 }
 
 IFileCtx* idxFileCtxCreate(WriterType type, const char* path, bool readOnly, int32_t capacity) {
+  int       code = 0;
   IFileCtx* ctx = taosMemoryCalloc(1, sizeof(IFileCtx));
   if (ctx == NULL) {
     return NULL;
   }
-
   ctx->type = type;
   if (ctx->type == TFILE) {
     // ugly code, refactor later
@@ -192,15 +194,21 @@ IFileCtx* idxFileCtxCreate(WriterType type, const char* path, bool readOnly, int
     memcpy(ctx->file.buf, path, strlen(path));
     if (readOnly == false) {
       ctx->file.pFile = taosOpenFile(path, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND);
-      taosFtruncateFile(ctx->file.pFile, 0);
+
-      taosStatFile(path, &ctx->file.size, NULL);
+      code = taosFtruncateFile(ctx->file.pFile, 0);
+      UNUSED(code);
+
+      code = taosStatFile(path, &ctx->file.size, NULL);
+      UNUSED(code);
 
       ctx->file.wBufOffset = 0;
       ctx->file.wBufCap = kBlockSize * 4;
       ctx->file.wBuf = taosMemoryCalloc(1, ctx->file.wBufCap);
     } else {
       ctx->file.pFile = taosOpenFile(path, TD_FILE_READ);
-      taosFStatFile(ctx->file.pFile, &ctx->file.size, NULL);
+      code = taosFStatFile(ctx->file.pFile, &ctx->file.size, NULL);
+      UNUSED(code);
+
       ctx->file.wBufOffset = 0;
 
 #ifdef USE_MMAP

source/libs/nodes/src/nodesCloneFuncs.c

@@ -158,7 +158,7 @@ static int32_t valueNodeCopy(const SValueNode* pSrc, SValueNode* pDst) {
     case TSDB_DATA_TYPE_NCHAR:
     case TSDB_DATA_TYPE_VARCHAR:
     case TSDB_DATA_TYPE_VARBINARY: {
-      int32_t len = varDataTLen(pSrc->datum.p) + 1;
+      int32_t len = pSrc->node.resType.bytes + 1;
       pDst->datum.p = taosMemoryCalloc(1, len);
       if (NULL == pDst->datum.p) {
         return TSDB_CODE_OUT_OF_MEMORY;

source/libs/nodes/src/nodesCodeFuncs.c

@@ -3269,7 +3269,7 @@ static int32_t jsonToDatum(const SJson* pJson, void* pObj) {
     case TSDB_DATA_TYPE_NCHAR:
     case TSDB_DATA_TYPE_VARCHAR:
     case TSDB_DATA_TYPE_VARBINARY: {
-      pNode->datum.p = taosMemoryCalloc(1, pNode->node.resType.bytes + VARSTR_HEADER_SIZE + 1);
+      pNode->datum.p = taosMemoryCalloc(1, pNode->node.resType.bytes + 1);
       if (NULL == pNode->datum.p) {
         code = TSDB_CODE_OUT_OF_MEMORY;
         break;

source/libs/nodes/src/nodesMsgFuncs.c

@@ -928,7 +928,7 @@ static int32_t msgToDatum(STlv* pTlv, void* pObj) {
         code = TSDB_CODE_FAILED;
         break;
       }
-      pNode->datum.p = taosMemoryCalloc(1, pNode->node.resType.bytes + VARSTR_HEADER_SIZE + 1);
+      pNode->datum.p = taosMemoryCalloc(1, pNode->node.resType.bytes + 1);
       if (NULL == pNode->datum.p) {
         code = TSDB_CODE_OUT_OF_MEMORY;
         break;

source/libs/nodes/src/nodesUtilFuncs.c

@@ -963,8 +963,6 @@ void nodesDestroyNode(SNode* pNode) {
     case QUERY_NODE_SHOW_USERS_STMT:
     case QUERY_NODE_SHOW_LICENCES_STMT:
     case QUERY_NODE_SHOW_VGROUPS_STMT:
-    case QUERY_NODE_SHOW_DB_ALIVE_STMT:
-    case QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT:
     case QUERY_NODE_SHOW_TOPICS_STMT:
     case QUERY_NODE_SHOW_CONSUMERS_STMT:
     case QUERY_NODE_SHOW_CONNECTIONS_STMT:
@@ -2101,9 +2099,9 @@ void nodesValueNodeToVariant(const SValueNode* pNode, SVariant* pVal) {
     case TSDB_DATA_TYPE_NCHAR:
     case TSDB_DATA_TYPE_VARCHAR:
     case TSDB_DATA_TYPE_VARBINARY:
-      pVal->pz = taosMemoryMalloc(pVal->nLen + VARSTR_HEADER_SIZE + 1);
+      pVal->pz = taosMemoryMalloc(pVal->nLen + 1);
-      memcpy(pVal->pz, pNode->datum.p, pVal->nLen + VARSTR_HEADER_SIZE);
+      memcpy(pVal->pz, pNode->datum.p, pVal->nLen);
-      pVal->pz[pVal->nLen + VARSTR_HEADER_SIZE] = 0;
+      pVal->pz[pVal->nLen] = 0;
       break;
     case TSDB_DATA_TYPE_JSON:
       pVal->nLen = getJsonValueLen(pNode->datum.p);

source/libs/parser/src/parAstCreater.c

@@ -1810,7 +1810,7 @@ SNode* createStreamOptions(SAstCreateContext* pCxt) {
   CHECK_PARSER_STATUS(pCxt);
   SStreamOptions* pOptions = (SStreamOptions*)nodesMakeNode(QUERY_NODE_STREAM_OPTIONS);
   CHECK_OUT_OF_MEM(pOptions);
-  pOptions->triggerType = STREAM_TRIGGER_AT_ONCE;
+  pOptions->triggerType = STREAM_TRIGGER_WINDOW_CLOSE;
   pOptions->fillHistory = STREAM_DEFAULT_FILL_HISTORY;
   pOptions->ignoreExpired = STREAM_DEFAULT_IGNORE_EXPIRED;
   pOptions->ignoreUpdate = STREAM_DEFAULT_IGNORE_UPDATE;

source/libs/parser/src/parCalcConst.c

@@ -320,6 +320,79 @@ static int32_t calcConstInsert(SCalcConstContext* pCxt, SInsertStmt* pInsert) {
   return code;
 }
 
+static SNodeList* getChildProjection(SNode* pStmt) {
+  switch (nodeType(pStmt)) {
+    case QUERY_NODE_SELECT_STMT:
+      return ((SSelectStmt*)pStmt)->pProjectionList;
+    case QUERY_NODE_SET_OPERATOR:
+      return ((SSetOperator*)pStmt)->pProjectionList;
+    default:
+      break;
+  }
+  return NULL;
+}
+
+static void eraseSetOpChildProjection(SSetOperator* pSetOp, int32_t index) {
+  SNodeList* pLeftProjs = getChildProjection(pSetOp->pLeft);
+  nodesListErase(pLeftProjs, nodesListGetCell(pLeftProjs, index));
+  SNodeList* pRightProjs = getChildProjection(pSetOp->pRight);
+  nodesListErase(pRightProjs, nodesListGetCell(pRightProjs, index));
+}
+
+typedef struct SNotRefByOrderByCxt {
+  SColumnNode* pCol;
+  bool         hasThisCol;
+} SNotRefByOrderByCxt;
+
+static EDealRes notRefByOrderByImpl(SNode* pNode, void* pContext) {
+  if (QUERY_NODE_COLUMN == nodeType(pNode)) {
+    SNotRefByOrderByCxt* pCxt = (SNotRefByOrderByCxt*)pContext;
+    if (nodesEqualNode((SNode*)pCxt->pCol, pNode)) {
+      pCxt->hasThisCol = true;
+      return DEAL_RES_END;
+    }
+  }
+  return DEAL_RES_CONTINUE;
+}
+
+static bool notRefByOrderBy(SColumnNode* pCol, SNodeList* pOrderByList) {
+  SNotRefByOrderByCxt cxt = {.pCol = pCol, .hasThisCol = false};
+  nodesWalkExprs(pOrderByList, notRefByOrderByImpl, &cxt);
+  return !cxt.hasThisCol;
+}
+
+static int32_t calcConstSetOpProjections(SCalcConstContext* pCxt, SSetOperator* pSetOp, bool subquery) {
+  int32_t index = 0;
+  SNode*  pProj = NULL;
+  WHERE_EACH(pProj, pSetOp->pProjectionList) {
+    if (subquery && notRefByOrderBy((SColumnNode*)pProj, pSetOp->pOrderByList) && isUselessCol((SExprNode*)pProj)) {
+      ERASE_NODE(pSetOp->pProjectionList);
+      eraseSetOpChildProjection(pSetOp, index);
+      continue;
+    }
+    ++index;
+    WHERE_NEXT;
+  }
+  if (0 == LIST_LENGTH(pSetOp->pProjectionList)) {
+    return nodesListStrictAppend(pSetOp->pProjectionList, createConstantValue());
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t calcConstSetOperator(SCalcConstContext* pCxt, SSetOperator* pSetOp, bool subquery) {
+  int32_t code = calcConstSetOpProjections(pCxt, pSetOp, subquery);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = calcConstQuery(pCxt, pSetOp->pLeft, false);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = calcConstQuery(pCxt, pSetOp->pRight, false);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = calcConstList(pSetOp->pOrderByList);
+  }
+  return code;
+}
+
 static int32_t calcConstQuery(SCalcConstContext* pCxt, SNode* pStmt, bool subquery) {
   int32_t code = TSDB_CODE_SUCCESS;
   switch (nodeType(pStmt)) {
@@ -330,11 +403,7 @@ static int32_t calcConstQuery(SCalcConstContext* pCxt, SNode* pStmt, bool subque
       code = calcConstQuery(pCxt, ((SExplainStmt*)pStmt)->pQuery, subquery);
       break;
     case QUERY_NODE_SET_OPERATOR: {
-      SSetOperator* pSetOp = (SSetOperator*)pStmt;
+      code = calcConstSetOperator(pCxt, (SSetOperator*)pStmt, subquery);
-      code = calcConstQuery(pCxt, pSetOp->pLeft, false);
-      if (TSDB_CODE_SUCCESS == code) {
-        code = calcConstQuery(pCxt, pSetOp->pRight, false);
-      }
       break;
     }
     case QUERY_NODE_DELETE_STMT:

source/libs/parser/src/parTranslater.c

@@ -3342,6 +3342,9 @@ static int32_t translateWhere(STranslateContext* pCxt, SSelectStmt* pSelect) {
   if (TSDB_CODE_SUCCESS == code) {
     code = getQueryTimeRange(pCxt, pSelect->pWhere, &pSelect->timeRange);
   }
+  if (TSDB_CODE_SUCCESS == code && pSelect->timeRange.skey > pSelect->timeRange.ekey) {
+    pSelect->isEmptyResult = true;
+  }
   return code;
 }
 
@@ -6474,6 +6477,11 @@ static int32_t translateShowCreateDatabase(STranslateContext* pCxt, SShowCreateD
   if (NULL == pStmt->pCfg) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }
+  
+  SName name;
+  tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->dbName, strlen(pStmt->dbName));
+  tNameGetFullDbName(&name, pStmt->dbFName);
+  
   return getDBCfg(pCxt, pStmt->dbName, (SDbCfgInfo*)pStmt->pCfg);
 }
 

source/libs/parser/test/parInitialCTest.cpp

@@ -781,16 +781,10 @@ TEST_F(ParserInitialCTest, createStream) {
     snprintf(expect.targetStbFullName, sizeof(expect.targetStbFullName), "0.test.%s", pDstStb);
     expect.igExists = igExists;
     expect.sql = taosStrdup(pSql);
-    expect.createStb = STREAM_CREATE_STABLE_TRUE;
-    expect.triggerType = STREAM_TRIGGER_AT_ONCE;
-    expect.maxDelay = 0;
-    expect.watermark = 0;
-    expect.fillHistory = STREAM_DEFAULT_FILL_HISTORY;
-    expect.igExpired = STREAM_DEFAULT_IGNORE_EXPIRED;
   };
 
   auto setStreamOptions =
-      [&](int8_t createStb = STREAM_CREATE_STABLE_TRUE, int8_t triggerType = STREAM_TRIGGER_AT_ONCE,
+      [&](int8_t createStb = STREAM_CREATE_STABLE_TRUE, int8_t triggerType = STREAM_TRIGGER_WINDOW_CLOSE,
           int64_t maxDelay = 0, int64_t watermark = 0, int8_t igExpired = STREAM_DEFAULT_IGNORE_EXPIRED,
           int8_t fillHistory = STREAM_DEFAULT_FILL_HISTORY, int8_t igUpdate = STREAM_DEFAULT_IGNORE_UPDATE) {
         expect.createStb = createStb;
@@ -852,6 +846,7 @@ TEST_F(ParserInitialCTest, createStream) {
   });
 
   setCreateStreamReq("s1", "test", "create stream s1 into st3 as select count(*) from t1 interval(10s)", "st3");
+  setStreamOptions();
   run("CREATE STREAM s1 INTO st3 AS SELECT COUNT(*) FROM t1 INTERVAL(10S)");
   clearCreateStreamReq();
 
@@ -872,6 +867,7 @@ TEST_F(ParserInitialCTest, createStream) {
                      "st3");
   addTag("tname", TSDB_DATA_TYPE_VARCHAR, 10 + VARSTR_HEADER_SIZE);
   addTag("id", TSDB_DATA_TYPE_INT);
+  setStreamOptions();
   run("CREATE STREAM s1 INTO st3 TAGS(tname VARCHAR(10), id INT) SUBTABLE(CONCAT('new-', tname)) "
       "AS SELECT _WSTART wstart, COUNT(*) cnt FROM st1 PARTITION BY TBNAME tname, tag1 id INTERVAL(10S)");
   clearCreateStreamReq();

source/libs/scalar/src/filter.c

@@ -1631,12 +1631,7 @@ void filterDumpInfoToString(SFilterInfo *info, const char *msg, int32_t options)
 
           SValueNode *var = (SValueNode *)field->desc;
           SDataType  *dType = &var->node.resType;
-          // if (dType->type == TSDB_DATA_TYPE_VALUE_ARRAY) {
-          //   qDebug("VAL%d => [type:TS][val:[%" PRIi64 "] - [%" PRId64 "]]", i, *(int64_t *)field->data,
-          //          *(((int64_t *)field->data) + 1));
-          // } else {
           qDebug("VAL%d => [type:%d][val:%" PRIx64 "]", i, dType->type, var->datum.i);  // TODO
-          //}
         } else if (field->data) {
           qDebug("VAL%d => [type:NIL][val:NIL]", i);  // TODO
         }
@@ -1955,20 +1950,9 @@ int32_t fltInitValFieldData(SFilterInfo *info) {
       bytes = (len + 1) * TSDB_NCHAR_SIZE + VARSTR_HEADER_SIZE;
 
       fi->data = taosMemoryCalloc(1, bytes);
-    } else {
-      if (dType->type == TSDB_DATA_TYPE_VALUE_ARRAY) {  // TIME RANGE
-        /*
-                fi->data = taosMemoryCalloc(dType->bytes, tDataTypes[type].bytes);
-                for (int32_t a = 0; a < dType->bytes; ++a) {
-                  int64_t *v = taosArrayGet(var->arr, a);
-                  assignVal((char *)fi->data + a * tDataTypes[type].bytes, (char *)v, 0, type);
-                }
-        */
-        continue;
     } else {
       fi->data = taosMemoryCalloc(1, sizeof(int64_t));
     }
-    }
 
     if (dType->type == type) {
       assignVal(fi->data, nodesGetValueFromNode(var), dType->bytes, type);

source/libs/stream/src/streamDispatch.c

@@ -278,6 +278,7 @@ int32_t streamDispatchOneRecoverFinishReq(SStreamTask* pTask, const SStreamRecov
   msg.contLen = tlen + sizeof(SMsgHead);
   msg.pCont = buf;
   msg.msgType = TDMT_STREAM_RECOVER_FINISH;
+  msg.info.noResp = 1;
 
   tmsgSendReq(pEpSet, &msg);
 
@@ -522,4 +523,3 @@ FREE:
   taosFreeQitem(pBlock);
   return code;
 }
-

source/libs/transport/inc/transComm.h

@@ -148,6 +148,7 @@ typedef struct {
   int8_t  epsetRetryCnt;
   int32_t retryCode;
 
+  void* task;
   int   hThrdIdx;
 } STransConnCtx;
 

source/libs/transport/inc/transportInt.h

@@ -68,7 +68,7 @@ typedef struct {
   int8_t        connLimitLock;  // 0: no lock. 1. lock
   int8_t        supportBatch;   // 0: no batch, 1: support batch
   int32_t       batchSize;
-
+  int32_t       timeToGetConn;
   int           index;
   void*         parent;
   void*         tcphandle;  // returned handle from TCP initialization

source/libs/transport/src/thttp.c

@@ -26,6 +26,8 @@
 
 #define HTTP_RECV_BUF_SIZE 1024
 
+static int32_t httpRefMgt = 0;
+static int64_t httpRef = -1;
 typedef struct SHttpModule {
   uv_loop_t*  loop;
   SAsyncPool* asyncPool;
@@ -41,7 +43,6 @@ typedef struct SHttpMsg {
   int32_t       len;
   EHttpCompFlag flag;
   int8_t        quit;
-  SHttpModule*  http;
 
 } SHttpMsg;
 
@@ -57,7 +58,6 @@ typedef struct SHttpClient {
 } SHttpClient;
 
 static TdThreadOnce transHttpInit = PTHREAD_ONCE_INIT;
-static SHttpModule* thttp = NULL;
 static void         transHttpEnvInit();
 
 static void    httpHandleReq(SHttpMsg* msg);
@@ -280,24 +280,27 @@ static void clientConnCb(uv_connect_t* req, int32_t status) {
 }
 
 int32_t httpSendQuit() {
+  SHttpModule* http = taosAcquireRef(httpRefMgt, httpRef);
+  if (http == NULL) return 0;
+
   SHttpMsg* msg = taosMemoryCalloc(1, sizeof(SHttpMsg));
   msg->quit = 1;
 
-  SHttpModule* load = atomic_load_ptr(&thttp);
+  transAsyncSend(http->asyncPool, &(msg->q));
-  if (load == NULL) {
+  taosReleaseRef(httpRefMgt, httpRef);
-    httpDestroyMsg(msg);
-    tError("http-report already released");
-    return -1;
-  } else {
-    msg->http = load;
-  }
-  transAsyncSend(load->asyncPool, &(msg->q));
   return 0;
 }
 
 static int32_t taosSendHttpReportImpl(const char* server, const char* uri, uint16_t port, char* pCont, int32_t contLen,
                                       EHttpCompFlag flag) {
+  SHttpModule* load = taosAcquireRef(httpRefMgt, httpRef);
+  if (load == NULL) {
+    tError("http-report already released");
+    return -1;
+  }
+
   SHttpMsg* msg = taosMemoryMalloc(sizeof(SHttpMsg));
+
   msg->server = taosStrdup(server);
   msg->uri = taosStrdup(uri);
   msg->port = port;
@@ -307,15 +310,9 @@ static int32_t taosSendHttpReportImpl(const char* server, const char* uri, uint1
   msg->flag = flag;
   msg->quit = 0;
 
-  SHttpModule* load = atomic_load_ptr(&thttp);
+  int ret = transAsyncSend(load->asyncPool, &(msg->q));
-  if (load == NULL) {
+  taosReleaseRef(httpRefMgt, httpRef);
-    httpDestroyMsg(msg);
+  return ret;
-    tError("http-report already released");
-    return -1;
-  }
-  
-  msg->http = load;
-  return transAsyncSend(load->asyncPool, &(msg->q));
 }
 
 static void httpDestroyClientCb(uv_handle_t* handle) {
@@ -335,13 +332,19 @@ static void httpWalkCb(uv_handle_t* handle, void* arg) {
   return;
 }
 static void httpHandleQuit(SHttpMsg* msg) {
-  SHttpModule* http = msg->http;
   taosMemoryFree(msg);
 
+  SHttpModule* http = taosAcquireRef(httpRefMgt, httpRef);
+  if (http == NULL) return;
+
   uv_walk(http->loop, httpWalkCb, NULL);
+  taosReleaseRef(httpRefMgt, httpRef);
 }
 static void httpHandleReq(SHttpMsg* msg) {
-  SHttpModule* http = msg->http;
+  SHttpModule* http = taosAcquireRef(httpRefMgt, httpRef);
+  if (http == NULL) {
+    goto END;
+  }
 
   struct sockaddr_in dest = {0};
   if (taosBuildDstAddr(msg->server, msg->port, &dest) < 0) {
@@ -391,6 +394,7 @@ static void httpHandleReq(SHttpMsg* msg) {
   int     ret = uv_tcp_open((uv_tcp_t*)&cli->tcp, fd);
   if (ret != 0) {
     tError("http-report failed to open socket, reason:%s, dst:%s:%d", uv_strerror(ret), cli->addr, cli->port);
+    taosReleaseRef(httpRefMgt, httpRef);
     destroyHttpClient(cli);
     return;
   }
@@ -401,21 +405,26 @@ static void httpHandleReq(SHttpMsg* msg) {
            cli->port);
     destroyHttpClient(cli);
   }
+  taosReleaseRef(httpRefMgt, httpRef);
   return;
 
 END:
   tError("http-report failed to report, reason: %s, addr: %s:%d", terrstr(), msg->server, msg->port);
   httpDestroyMsg(msg);
+  taosReleaseRef(httpRefMgt, httpRef);
 }
 
-int32_t taosSendHttpReport(const char* server, const char* uri, uint16_t port, char* pCont, int32_t contLen, EHttpCompFlag flag) {
+int32_t taosSendHttpReport(const char* server, const char* uri, uint16_t port, char* pCont, int32_t contLen,
+                           EHttpCompFlag flag) {
   taosThreadOnce(&transHttpInit, transHttpEnvInit);
   return taosSendHttpReportImpl(server, uri, port, pCont, contLen, flag);
 }
 
+static void transHttpDestroyHandle(void* handle) { taosMemoryFree(handle); }
 static void transHttpEnvInit() {
-  SHttpModule* http = taosMemoryMalloc(sizeof(SHttpModule));
+  httpRefMgt = taosOpenRef(1, transHttpDestroyHandle);
 
+  SHttpModule* http = taosMemoryMalloc(sizeof(SHttpModule));
   http->loop = taosMemoryMalloc(sizeof(uv_loop_t));
   uv_loop_init(http->loop);
 
@@ -433,14 +442,15 @@ static void transHttpEnvInit() {
     taosMemoryFree(http);
     http = NULL;
   }
-  atomic_store_ptr(&thttp, http);
+  httpRef = taosAddRef(httpRefMgt, http);
 }
 
 void transHttpEnvDestroy() {
-  SHttpModule* load = atomic_load_ptr(&thttp);
+  // remove http
-  if (load == NULL) {
+  if (httpRef == -1) {
     return;
   }
+  SHttpModule* load = taosAcquireRef(httpRefMgt, httpRef);
   httpSendQuit();
   taosThreadJoin(load->thread, NULL);
 
@@ -448,7 +458,7 @@ void transHttpEnvDestroy() {
   transAsyncPoolDestroy(load->asyncPool);
   uv_loop_close(load->loop);
   taosMemoryFree(load->loop);
-  taosMemoryFree(load);
 
-  atomic_store_ptr(&thttp, NULL);
+  taosReleaseRef(httpRefMgt, httpRef);
+  taosRemoveRef(httpRefMgt, httpRef);
 }

source/libs/transport/src/trans.c

@@ -66,6 +66,10 @@ void* rpcOpen(const SRpcInit* pInit) {
   pRpc->destroyFp = pInit->dfp;
   pRpc->failFastFp = pInit->ffp;
   pRpc->connLimitNum = pInit->connLimitNum;
+  if (pRpc->connLimitNum == 0) {
+    pRpc->connLimitNum = 20;
+  }
+
   pRpc->connLimitLock = pInit->connLimitLock;
   pRpc->supportBatch = pInit->supportBatch;
   pRpc->batchSize = pInit->batchSize;
@@ -90,7 +94,10 @@ void* rpcOpen(const SRpcInit* pInit) {
   if (pInit->user) {
     tstrncpy(pRpc->user, pInit->user, sizeof(pRpc->user));
   }
-
+  pRpc->timeToGetConn = pInit->timeToGetConn;
+  if (pRpc->timeToGetConn == 0) {
+    pRpc->timeToGetConn = 10 * 1000;
+  }
   pRpc->tcphandle =
       (*taosInitHandle[pRpc->connType])(ip, pInit->localPort, pRpc->label, pRpc->numOfThreads, NULL, pRpc);
 

source/libs/transport/src/transCli.c

@@ -11,11 +11,19 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
+
 #include "transComm.h"
+#include "tutil.h"
+
+typedef struct {
+  int32_t numOfConn;
+  queue   msgQ;
+} SMsgList;
 
 typedef struct SConnList {
   queue     conns;
   int32_t   size;
+  SMsgList* list;
 } SConnList;
 
 typedef struct {
@@ -64,15 +72,13 @@ typedef struct SCliConn {
 
   SCliBatch* pBatch;
 
-  int64_t refId;
-  char*   ip;
-
   SDelayTask* task;
 
-  // debug and log info
+  char* ip;
   char  src[32];
   char  dst[32];
 
+  int64_t refId;
 } SCliConn;
 
 typedef struct SCliMsg {
@@ -100,6 +106,7 @@ typedef struct SCliThrd {
   TdThreadMutex msgMtx;
   SDelayQueue*  delayQueue;
   SDelayQueue*  timeoutQueue;
+  SDelayQueue*  waitConnQueue;
   uint64_t      nextTimeout;  // next timeout
   void*         pTransInst;   //
 
@@ -109,7 +116,6 @@ typedef struct SCliThrd {
   SCvtAddr  cvtAddr;
 
   SHashObj* failFastCache;
-  SHashObj* connLimitCache;
   SHashObj* batchCache;
 
   SCliMsg* stopMsg;
@@ -131,11 +137,12 @@ typedef struct {
   int32_t threshold;
   int64_t interval;
 } SFailFastItem;
+
 // conn pool
 // add expire timeout and capacity limit
 static void*     createConnPool(int size);
-static void*     destroyConnPool(void* pool);
+static void*     destroyConnPool(SCliThrd* thread);
-static SCliConn* getConnFromPool(void* pool, char* ip, uint32_t port);
+static SCliConn* getConnFromPool(SCliThrd* thread, char* key, bool* exceed);
 static void      addConnToPool(void* pool, SCliConn* conn);
 static void      doCloseIdleConn(void* param);
 
@@ -175,7 +182,8 @@ static void      cliSend(SCliConn* pConn);
 static void      cliSendBatch(SCliConn* pConn);
 static void      cliDestroyConnMsgs(SCliConn* conn, bool destroy);
 
-static int32_t cliPreCheckSessionLimit(SCliThrd* pThrd, char* ip, uint16_t port);
+static void    doFreeTimeoutMsg(void* param);
+static int32_t cliPreCheckSessionLimitForMsg(SCliThrd* pThrd, char* addr, SCliMsg** pMsg);
 
 // cli util func
 static FORCE_INLINE bool cliIsEpsetUpdated(int32_t code, STransConnCtx* pCtx);
@@ -193,6 +201,7 @@ static void cliHandleExcept(SCliConn* conn);
 static void cliReleaseUnfinishedMsg(SCliConn* conn);
 static void cliHandleFastFail(SCliConn* pConn, int status);
 
+static void doNotifyApp(SCliMsg* pMsg, SCliThrd* pThrd);
 // handle req from app
 static void cliHandleReq(SCliMsg* pMsg, SCliThrd* pThrd);
 static void cliHandleQuit(SCliMsg* pMsg, SCliThrd* pThrd);
@@ -225,11 +234,11 @@ static void cliWalkCb(uv_handle_t* handle, void* arg);
 // snprintf may cause performance problem
 #define CONN_CONSTRUCT_HASH_KEY(key, ip, port) \
   do {                                         \
-    char*   p = key;                           \
+    char*   t = key;                           \
-    int32_t len = strlen(ip);                  \
+    int16_t len = strlen(ip);                  \
-    if (p != NULL) memcpy(p, ip, len);         \
+    if (ip != NULL) memcpy(t, ip, len);        \
-    p[len] = ':';                              \
+    t[len] = ':';                              \
-    titoa(port, 10, &p[len + 1]);              \
+    titoa(port, 10, &t[len + 1]);              \
   } while (0)
 
 #define CONN_PERSIST_TIME(para)   ((para) <= 90000 ? 90000 : (para))
@@ -333,13 +342,9 @@ bool cliMaySendCachedMsg(SCliConn* conn) {
   if (!transQueueEmpty(&conn->cliMsgs)) {
     SCliMsg* pCliMsg = NULL;
     CONN_GET_NEXT_SENDMSG(conn);
-    if (pCliMsg == NULL)
-      return false;
-    else {
     cliSend(conn);
     return true;
   }
-  }
   return false;
 _RETURN:
   return false;
@@ -362,6 +367,7 @@ void cliHandleResp(SCliConn* conn) {
 
   int32_t msgLen = transDumpFromBuffer(&conn->readBuf, (char**)&pHead);
   if (msgLen <= 0) {
+    taosMemoryFree(pHead);
     tDebug("%s conn %p recv invalid packet ", CONN_GET_INST_LABEL(conn), conn);
     return;
   }
@@ -545,7 +551,8 @@ void* createConnPool(int size) {
   // thread local, no lock
   return taosHashInit(size, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
 }
-void* destroyConnPool(void* pool) {
+void* destroyConnPool(SCliThrd* pThrd) {
+  void*      pool = pThrd->pool;
   SConnList* connList = taosHashIterate((SHashObj*)pool, NULL);
   while (connList != NULL) {
     while (!QUEUE_IS_EMPTY(&connList->conns)) {
@@ -553,34 +560,130 @@ void* destroyConnPool(void* pool) {
       SCliConn* c = QUEUE_DATA(h, SCliConn, q);
       cliDestroyConn(c, true);
     }
+
+    SMsgList* msglist = connList->list;
+    while (!QUEUE_IS_EMPTY(&msglist->msgQ)) {
+      queue* h = QUEUE_HEAD(&msglist->msgQ);
+      QUEUE_REMOVE(h);
+
+      SCliMsg* pMsg = QUEUE_DATA(h, SCliMsg, q);
+
+      transDQCancel(pThrd->waitConnQueue, pMsg->ctx->task);
+      pMsg->ctx->task = NULL;
+
+      doNotifyApp(pMsg, pThrd);
+    }
+    taosMemoryFree(msglist);
+
     connList = taosHashIterate((SHashObj*)pool, connList);
   }
   taosHashCleanup(pool);
   return NULL;
 }
 
-static SCliConn* getConnFromPool(void* pool, char* ip, uint32_t port) {
+static SCliConn* getConnFromPool(SCliThrd* pThrd, char* key, bool* exceed) {
-  char key[TSDB_FQDN_LEN + 64] = {0};
+  void*      pool = pThrd->pool;
-  CONN_CONSTRUCT_HASH_KEY(key, ip, port);
+  SConnList* plist = taosHashGet((SHashObj*)pool, key, strlen(key));
+  STrans*    pTranInst = pThrd->pTransInst;
+  if (plist == NULL) {
+    SConnList list = {0};
+    taosHashPut((SHashObj*)pool, key, strlen(key), (void*)&list, sizeof(list));
+    plist = taosHashGet(pool, key, strlen(key));
 
+    SMsgList* nList = taosMemoryCalloc(1, sizeof(SMsgList));
+    QUEUE_INIT(&nList->msgQ);
+    nList->numOfConn++;
+
+    QUEUE_INIT(&plist->conns);
+    plist->list = nList;
+  }
+
+  if (QUEUE_IS_EMPTY(&plist->conns)) {
+    if (plist->list->numOfConn >= pTranInst->connLimitNum) {
+      *exceed = true;
+    }
+    return NULL;
+  }
+
+  queue* h = QUEUE_TAIL(&plist->conns);
+  QUEUE_REMOVE(h);
+  plist->size -= 1;
+
+  SCliConn* conn = QUEUE_DATA(h, SCliConn, q);
+  conn->status = ConnNormal;
+  QUEUE_INIT(&conn->q);
+
+  if (conn->task != NULL) {
+    transDQCancel(((SCliThrd*)conn->hostThrd)->timeoutQueue, conn->task);
+    conn->task = NULL;
+  }
+  return conn;
+}
+
+static SCliConn* getConnFromPool2(SCliThrd* pThrd, char* key, SCliMsg** pMsg) {
+  void*      pool = pThrd->pool;
+  STrans*    pTransInst = pThrd->pTransInst;
   SConnList* plist = taosHashGet((SHashObj*)pool, key, strlen(key));
   if (plist == NULL) {
     SConnList list = {0};
     taosHashPut((SHashObj*)pool, key, strlen(key), (void*)&list, sizeof(list));
-    plist = taosHashGet((SHashObj*)pool, key, strlen(key));
+    plist = taosHashGet(pool, key, strlen(key));
-    if (plist == NULL) return NULL;
+
+    SMsgList* nList = taosMemoryCalloc(1, sizeof(SMsgList));
+    QUEUE_INIT(&nList->msgQ);
+    nList->numOfConn++;
+
     QUEUE_INIT(&plist->conns);
+    plist->list = nList;
   }
 
+  STraceId* trace = &(*pMsg)->msg.info.traceId;
+  // no avaliable conn in pool
   if (QUEUE_IS_EMPTY(&plist->conns)) {
+    SMsgList* list = plist->list;
+    if ((list)->numOfConn >= pTransInst->connLimitNum) {
+      STraceId* trace = &(*pMsg)->msg.info.traceId;
+      STaskArg* arg = taosMemoryMalloc(sizeof(STaskArg));
+      arg->param1 = *pMsg;
+      arg->param2 = pThrd;
+      (*pMsg)->ctx->task = transDQSched(pThrd->waitConnQueue, doFreeTimeoutMsg, arg, pTransInst->timeToGetConn);
+
+      tGTrace("%s msg %s delay to send, wait for avaiable connect", pTransInst->label, TMSG_INFO((*pMsg)->msg.msgType));
+
+      QUEUE_PUSH(&(list)->msgQ, &(*pMsg)->q);
+      *pMsg = NULL;
+    } else {
+      // send msg in delay queue
+      if (!(QUEUE_IS_EMPTY(&(list)->msgQ))) {
+        STaskArg* arg = taosMemoryMalloc(sizeof(STaskArg));
+        arg->param1 = *pMsg;
+        arg->param2 = pThrd;
+        (*pMsg)->ctx->task = transDQSched(pThrd->waitConnQueue, doFreeTimeoutMsg, arg, pTransInst->timeToGetConn);
+        tGTrace("%s msg %s delay to send, wait for avaiable connect", pTransInst->label,
+                TMSG_INFO((*pMsg)->msg.msgType));
+
+        QUEUE_PUSH(&(list)->msgQ, &(*pMsg)->q);
+        queue* h = QUEUE_HEAD(&(list)->msgQ);
+        QUEUE_REMOVE(h);
+        SCliMsg* ans = QUEUE_DATA(h, SCliMsg, q);
+
+        *pMsg = ans;
+
+        trace = &(*pMsg)->msg.info.traceId;
+        tGTrace("%s msg %s pop from delay queue, start to send", pTransInst->label, TMSG_INFO((*pMsg)->msg.msgType));
+        transDQCancel(pThrd->waitConnQueue, ans->ctx->task);
+      }
+      list->numOfConn++;
+    }
     return NULL;
   }
 
+  queue* h = QUEUE_TAIL(&plist->conns);
   plist->size -= 1;
-  queue*    h = QUEUE_HEAD(&plist->conns);
+  QUEUE_REMOVE(h);
+
   SCliConn* conn = QUEUE_DATA(h, SCliConn, q);
   conn->status = ConnNormal;
-  QUEUE_REMOVE(&conn->q);
   QUEUE_INIT(&conn->q);
 
   if (conn->task != NULL) {
@@ -608,18 +711,34 @@ static void addConnToPool(void* pool, SCliConn* conn) {
 
   cliDestroyConnMsgs(conn, false);
 
-  conn->status = ConnInPool;
-
   if (conn->list == NULL) {
-    tTrace("%s conn %p added to conn pool, read buf cap:%d", CONN_GET_INST_LABEL(conn), conn, conn->readBuf.cap);
     conn->list = taosHashGet((SHashObj*)pool, conn->ip, strlen(conn->ip));
-  } else {
-    tTrace("%s conn %p added to conn pool, read buf cap:%d", CONN_GET_INST_LABEL(conn), conn, conn->readBuf.cap);
   }
+
+  SConnList* pList = conn->list;
+  SMsgList*  msgList = pList->list;
+  if (!QUEUE_IS_EMPTY(&msgList->msgQ)) {
+    queue* h = QUEUE_HEAD(&(msgList)->msgQ);
+    QUEUE_REMOVE(h);
+
+    SCliMsg* pMsg = QUEUE_DATA(h, SCliMsg, q);
+
+    transDQCancel(thrd->waitConnQueue, pMsg->ctx->task);
+    pMsg->ctx->task = NULL;
+
+    transCtxMerge(&conn->ctx, &pMsg->ctx->appCtx);
+    transQueuePush(&conn->cliMsgs, pMsg);
+
+    conn->status = ConnNormal;
+    cliSend(conn);
+    return;
+  }
+
+  conn->status = ConnInPool;
   QUEUE_PUSH(&conn->list->conns, &conn->q);
   conn->list->size += 1;
 
-  if (conn->list->size >= 250) {
+  if (conn->list->size >= 20) {
     STaskArg* arg = taosMemoryCalloc(1, sizeof(STaskArg));
     arg->param1 = conn;
     arg->param2 = thrd;
@@ -741,8 +860,20 @@ static SCliConn* cliCreateConn(SCliThrd* pThrd) {
 static void cliDestroyConn(SCliConn* conn, bool clear) {
   SCliThrd* pThrd = conn->hostThrd;
   tTrace("%s conn %p remove from conn pool", CONN_GET_INST_LABEL(conn), conn);
+
   QUEUE_REMOVE(&conn->q);
   QUEUE_INIT(&conn->q);
+
+  if (conn->list != NULL) {
+    SConnList* connList = conn->list;
+    connList->list->numOfConn--;
+    connList->size--;
+  } else {
+    SConnList* connList = taosHashGet((SHashObj*)pThrd->pool, conn->ip, strlen(conn->ip));
+    connList->list->numOfConn--;
+  }
+  conn->list = NULL;
+
   transReleaseExHandle(transGetRefMgt(), conn->refId);
   transRemoveExHandle(transGetRefMgt(), conn->refId);
   conn->refId = -1;
@@ -777,9 +908,6 @@ static void cliDestroy(uv_handle_t* handle) {
     conn->timer->data = NULL;
     conn->timer = NULL;
   }
-  int32_t* oVal = taosHashGet(pThrd->connLimitCache, conn->ip, strlen(conn->ip));
-  int32_t  nVal = oVal == NULL ? 0 : (*oVal) - 1;
-  taosHashPut(pThrd->connLimitCache, conn->ip, strlen(conn->ip), &nVal, sizeof(nVal));
 
   atomic_sub_fetch_32(&pThrd->connCount, 1);
 
@@ -1012,11 +1140,15 @@ static void cliHandleBatchReq(SCliBatch* pBatch, SCliThrd* pThrd) {
   STrans*        pTransInst = pThrd->pTransInst;
   SCliBatchList* pList = pBatch->pList;
 
-  SCliConn* conn = getConnFromPool(pThrd->pool, pList->ip, pList->port);
+  char key[TSDB_FQDN_LEN + 64] = {0};
+  CONN_CONSTRUCT_HASH_KEY(key, pList->ip, pList->port);
 
-  if (conn == NULL && 0 != cliPreCheckSessionLimit(pThrd, pList->ip, pList->port)) {
+  bool      exceed = false;
-    tError("%s failed to send batch msg, batch size:%d, msgLen: %d", pTransInst->label, pBatch->wLen,
+  SCliConn* conn = getConnFromPool(pThrd, key, &exceed);
-           pBatch->batchSize);
+
+  if (conn == NULL && exceed) {
+    tError("%s failed to send batch msg, batch size:%d, msgLen: %d, conn limit:%d", pTransInst->label, pBatch->wLen,
+           pBatch->batchSize, pTransInst->connLimitNum);
     cliDestroyBatch(pBatch);
     return;
   }
@@ -1041,7 +1173,7 @@ static void cliHandleBatchReq(SCliBatch* pBatch, SCliThrd* pThrd) {
     addr.sin_port = (uint16_t)htons(pList->port);
 
     tTrace("%s conn %p try to connect to %s", pTransInst->label, conn, pList->dst);
-    int32_t fd = taosCreateSocketWithTimeout(TRANS_CONN_TIMEOUT * 4);
+    int32_t fd = taosCreateSocketWithTimeout(TRANS_CONN_TIMEOUT * 10);
     if (fd == -1) {
       tError("%s conn %p failed to create socket, reason:%s", transLabel(pTransInst), conn,
              tstrerror(TAOS_SYSTEM_ERROR(errno)));
@@ -1176,10 +1308,6 @@ void cliConnCb(uv_connect_t* req, int status) {
     return;
   }
 
-  int32_t* oVal = taosHashGet(pThrd->connLimitCache, pConn->ip, strlen(pConn->ip));
-  int32_t  nVal = oVal == NULL ? 0 : (*oVal) + 1;
-  taosHashPut(pThrd->connLimitCache, pConn->ip, strlen(pConn->ip), &nVal, sizeof(nVal));
-
   struct sockaddr peername, sockname;
   int             addrlen = sizeof(peername);
   uv_tcp_getpeername((uv_tcp_t*)pConn->stream, &peername, &addrlen);
@@ -1197,6 +1325,29 @@ void cliConnCb(uv_connect_t* req, int status) {
   }
 }
 
+static void doNotifyApp(SCliMsg* pMsg, SCliThrd* pThrd) {
+  STransConnCtx* pCtx = pMsg->ctx;
+  STrans*        pTransInst = pThrd->pTransInst;
+
+  STransMsg transMsg = {0};
+  transMsg.contLen = 0;
+  transMsg.pCont = NULL;
+  transMsg.code = TSDB_CODE_RPC_MAX_SESSIONS;
+  transMsg.msgType = pMsg->msg.msgType + 1;
+  transMsg.info.ahandle = pMsg->ctx->ahandle;
+  transMsg.info.traceId = pMsg->msg.info.traceId;
+  transMsg.info.hasEpSet = false;
+  if (pCtx->pSem != NULL) {
+    if (pCtx->pRsp == NULL) {
+    } else {
+      memcpy((char*)pCtx->pRsp, (char*)&transMsg, sizeof(transMsg));
+    }
+  } else {
+    pTransInst->cfp(pTransInst->parent, &transMsg, NULL);
+  }
+
+  destroyCmsg(pMsg);
+}
 static void cliHandleQuit(SCliMsg* pMsg, SCliThrd* pThrd) {
   if (!transAsyncPoolIsEmpty(pThrd->asyncPool)) {
     pThrd->stopMsg = pMsg;
@@ -1206,7 +1357,8 @@ static void cliHandleQuit(SCliMsg* pMsg, SCliThrd* pThrd) {
   pThrd->quit = true;
   tDebug("cli work thread %p start to quit", pThrd);
   destroyCmsg(pMsg);
-  destroyConnPool(pThrd->pool);
+
+  destroyConnPool(pThrd);
   uv_walk(pThrd->loop, cliWalkCb, NULL);
 }
 static void cliHandleRelease(SCliMsg* pMsg, SCliThrd* pThrd) {
@@ -1239,11 +1391,11 @@ static void cliHandleUpdate(SCliMsg* pMsg, SCliThrd* pThrd) {
   destroyCmsg(pMsg);
 }
 
-SCliConn* cliGetConn(SCliMsg* pMsg, SCliThrd* pThrd, bool* ignore) {
+SCliConn* cliGetConn(SCliMsg** pMsg, SCliThrd* pThrd, bool* ignore, char* addr) {
-  STransConnCtx* pCtx = pMsg->ctx;
+  STransConnCtx* pCtx = (*pMsg)->ctx;
   SCliConn*      conn = NULL;
 
-  int64_t refId = (int64_t)(pMsg->msg.info.handle);
+  int64_t refId = (int64_t)((*pMsg)->msg.info.handle);
   if (refId != 0) {
     SExHandle* exh = transAcquireExHandle(transGetRefMgt(), refId);
     if (exh == NULL) {
@@ -1253,7 +1405,7 @@ SCliConn* cliGetConn(SCliMsg* pMsg, SCliThrd* pThrd, bool* ignore) {
     } else {
       conn = exh->handle;
       if (conn == NULL) {
-        conn = getConnFromPool(pThrd->pool, EPSET_GET_INUSE_IP(&pCtx->epSet), EPSET_GET_INUSE_PORT(&pCtx->epSet));
+        conn = getConnFromPool2(pThrd, addr, pMsg);
         if (conn != NULL) specifyConnRef(conn, true, refId);
       }
       transReleaseExHandle(transGetRefMgt(), refId);
@@ -1261,7 +1413,7 @@ SCliConn* cliGetConn(SCliMsg* pMsg, SCliThrd* pThrd, bool* ignore) {
     return conn;
   };
 
-  conn = getConnFromPool(pThrd->pool, EPSET_GET_INUSE_IP(&pCtx->epSet), EPSET_GET_INUSE_PORT(&pCtx->epSet));
+  conn = getConnFromPool2(pThrd, addr, pMsg);
   if (conn != NULL) {
     tTrace("%s conn %p get from conn pool:%p", CONN_GET_INST_LABEL(conn), conn, pThrd->pool);
   } else {
@@ -1319,57 +1471,34 @@ static FORCE_INLINE void cliUpdateFqdnCache(SHashObj* cache, char* fqdn) {
   return;
 }
 
-static int32_t cliPreCheckSessionLimit(SCliThrd* pThrd, char* ip, uint16_t port) {
+static void doFreeTimeoutMsg(void* param) {
+  STaskArg* arg = param;
+  SCliMsg*  pMsg = arg->param1;
+  SCliThrd* pThrd = arg->param2;
   STrans*   pTransInst = pThrd->pTransInst;
 
-  // STransConnCtx* pCtx = pMsg->ctx;
+  QUEUE_REMOVE(&pMsg->q);
-  // char*          ip = EPSET_GET_INUSE_IP(&pCtx->epSet);
+  STraceId* trace = &pMsg->msg.info.traceId;
-  // int32_t        port = EPSET_GET_INUSE_PORT(&pCtx->epSet);
+  tGTrace("%s msg %s cannot get available conn after timeout", pTransInst->label, TMSG_INFO(pMsg->msg.msgType));
-
+  doNotifyApp(pMsg, pThrd);
-  char key[TSDB_FQDN_LEN + 64] = {0};
+  taosMemoryFree(arg);
-  CONN_CONSTRUCT_HASH_KEY(key, ip, port);
-
-  int32_t* val = taosHashGet(pThrd->connLimitCache, key, strlen(key));
-  if (val == NULL) return 0;
-
-  if (*val >= pTransInst->connLimitNum) {
-    return -1;
-  }
-  return 0;
 }
 void cliHandleReq(SCliMsg* pMsg, SCliThrd* pThrd) {
   STrans* pTransInst = pThrd->pTransInst;
-  STransConnCtx* pCtx = pMsg->ctx;
 
-  cliMayCvtFqdnToIp(&pCtx->epSet, &pThrd->cvtAddr);
+  cliMayCvtFqdnToIp(&pMsg->ctx->epSet, &pThrd->cvtAddr);
-  STraceId* trace = &pMsg->msg.info.traceId;
+  if (!EPSET_IS_VALID(&pMsg->ctx->epSet)) {
-  char*     ip = EPSET_GET_INUSE_IP(&pCtx->epSet);
-  uint16_t  port = EPSET_GET_INUSE_PORT(&pCtx->epSet);
-
-  if (!EPSET_IS_VALID(&pCtx->epSet)) {
-    tGError("%s, msg %s sent with invalid epset", pTransInst->label, TMSG_INFO(pMsg->msg.msgType));
     destroyCmsg(pMsg);
     return;
   }
 
-  if (REQUEST_NO_RESP(&pMsg->msg) && (pTransInst->failFastFp != NULL && pTransInst->failFastFp(pMsg->msg.msgType))) {
+  char*    fqdn = EPSET_GET_INUSE_IP(&pMsg->ctx->epSet);
-    char key[TSDB_FQDN_LEN + 64] = {0};
+  uint16_t port = EPSET_GET_INUSE_PORT(&pMsg->ctx->epSet);
-    CONN_CONSTRUCT_HASH_KEY(key, ip, port);
+  char     addr[TSDB_FQDN_LEN + 64] = {0};
-
+  CONN_CONSTRUCT_HASH_KEY(addr, fqdn, port);
-    SFailFastItem* item = taosHashGet(pThrd->failFastCache, key, strlen(key));
-    if (item != NULL) {
-      int32_t elapse = (int32_t)(taosGetTimestampMs() - item->timestamp);
-      if (item->count >= pTransInst->failFastThreshold && (elapse >= 0 && elapse <= pTransInst->failFastInterval)) {
-        tGTrace("%s, msg %s cancel to send, reason: failed to connect %s:%d: count: %d, at %d", pTransInst->label,
-                TMSG_INFO(pMsg->msg.msgType), ip, port, item->count, elapse);
-        destroyCmsg(pMsg);
-        return;
-      }
-    }
-  }
 
   bool      ignore = false;
-  SCliConn* conn = cliGetConn(pMsg, pThrd, &ignore);
+  SCliConn* conn = cliGetConn(&pMsg, pThrd, &ignore, addr);
   if (ignore == true) {
     // persist conn already release by server
     STransMsg resp;
@@ -1380,16 +1509,13 @@ void cliHandleReq(SCliMsg* pMsg, SCliThrd* pThrd) {
     destroyCmsg(pMsg);
     return;
   }
-
+  if (conn == NULL && pMsg == NULL) {
-  if (conn == NULL && REQUEST_NO_RESP(&pMsg->msg) && 0 != cliPreCheckSessionLimit(pThrd, ip, port)) {
-    tGTrace("%s, msg %s cancel to send, reason: %s", pTransInst->label, TMSG_INFO(pMsg->msg.msgType),
-            tstrerror(TSDB_CODE_RPC_MAX_SESSIONS));
-    destroyCmsg(pMsg);
     return;
   }
+  STraceId* trace = &pMsg->msg.info.traceId;
 
   if (conn != NULL) {
-    transCtxMerge(&conn->ctx, &pCtx->appCtx);
+    transCtxMerge(&conn->ctx, &pMsg->ctx->appCtx);
     transQueuePush(&conn->cliMsgs, pMsg);
     cliSend(conn);
   } else {
@@ -1398,15 +1524,10 @@ void cliHandleReq(SCliMsg* pMsg, SCliThrd* pThrd) {
     int64_t refId = (int64_t)pMsg->msg.info.handle;
     if (refId != 0) specifyConnRef(conn, true, refId);
 
-    transCtxMerge(&conn->ctx, &pCtx->appCtx);
+    transCtxMerge(&conn->ctx, &pMsg->ctx->appCtx);
     transQueuePush(&conn->cliMsgs, pMsg);
 
-    char     key[TSDB_FQDN_LEN + 64] = {0};
+    conn->ip = taosStrdup(addr);
-    char*    fqdn = EPSET_GET_INUSE_IP(&pCtx->epSet);
-    uint16_t port = EPSET_GET_INUSE_PORT(&pCtx->epSet);
-    CONN_CONSTRUCT_HASH_KEY(key, fqdn, port);
-
-    conn->ip = taosStrdup(key);
 
     uint32_t ipaddr = cliGetIpFromFqdnCache(pThrd->fqdn2ipCache, fqdn);
     if (ipaddr == 0xffffffff) {
@@ -1730,17 +1851,23 @@ void* transInitClient(uint32_t ip, uint32_t port, char* label, int numOfThreads,
   for (int i = 0; i < cli->numOfThreads; i++) {
     SCliThrd* pThrd = createThrdObj(shandle);
     if (pThrd == NULL) {
-      return NULL;
+      goto _err;
     }
 
     int err = taosThreadCreate(&pThrd->thread, NULL, cliWorkThread, (void*)(pThrd));
-    if (err == 0) {
+    if (err != 0) {
+      goto _err;
+    } else {
       tDebug("success to create tranport-cli thread:%d", i);
     }
     cli->pThreadObj[i] = pThrd;
   }
-
   return cli;
+
+_err:
+  taosMemoryFree(cli->pThreadObj);
+  taosMemoryFree(cli);
+  return NULL;
 }
 
 static FORCE_INLINE void destroyUserdata(STransMsg* userdata) {
@@ -1830,14 +1957,14 @@ static SCliThrd* createThrdObj(void* trans) {
 
   transDQCreate(pThrd->loop, &pThrd->timeoutQueue);
 
+  transDQCreate(pThrd->loop, &pThrd->waitConnQueue);
+
   pThrd->nextTimeout = taosGetTimestampMs() + CONN_PERSIST_TIME(pTransInst->idleTime);
   pThrd->pTransInst = trans;
 
   pThrd->destroyAhandleFp = pTransInst->destroyFp;
   pThrd->fqdn2ipCache = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
   pThrd->failFastCache = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
-  pThrd->connLimitCache = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true,
-                                       pTransInst->connLimitLock == 0 ? HASH_NO_LOCK : HASH_ENTRY_LOCK);
 
   pThrd->batchCache = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
 
@@ -1857,6 +1984,7 @@ static void destroyThrdObj(SCliThrd* pThrd) {
 
   transDQDestroy(pThrd->delayQueue, destroyCmsgAndAhandle);
   transDQDestroy(pThrd->timeoutQueue, NULL);
+  transDQDestroy(pThrd->waitConnQueue, NULL);
 
   tDebug("thread destroy %" PRId64, pThrd->pid);
   for (int i = 0; i < taosArrayGetSize(pThrd->timerList); i++) {
@@ -1868,7 +1996,6 @@ static void destroyThrdObj(SCliThrd* pThrd) {
   taosMemoryFree(pThrd->loop);
   taosHashCleanup(pThrd->fqdn2ipCache);
   taosHashCleanup(pThrd->failFastCache);
-  taosHashCleanup(pThrd->connLimitCache);
 
   void** pIter = taosHashIterate(pThrd->batchCache, NULL);
   while (pIter != NULL) {

source/libs/wal/src/walRead.c

@@ -200,6 +200,7 @@ int32_t walReadSeekVerImpl(SWalReader *pReader, int64_t ver) {
          pReader->curVersion, pReader->curInvalid, ver);
 
   pReader->curVersion = ver;
+  pReader->curInvalid = 0;
   return 0;
 }
 
@@ -210,8 +211,8 @@ int32_t walReadSeekVer(SWalReader *pReader, int64_t ver) {
     return 0;
   }
 
-  pReader->curInvalid = 1;
+//  pReader->curInvalid = 1;
-  pReader->curVersion = ver;
+//  pReader->curVersion = ver;
 
   if (ver > pWal->vers.lastVer || ver < pWal->vers.firstVer) {
     wDebug("vgId:%d, invalid index:%" PRId64 ", first index:%" PRId64 ", last index:%" PRId64, pReader->pWal->cfg.vgId,
@@ -219,8 +220,8 @@ int32_t walReadSeekVer(SWalReader *pReader, int64_t ver) {
     terrno = TSDB_CODE_WAL_LOG_NOT_EXIST;
     return -1;
   }
-  if (ver < pWal->vers.snapshotVer) {
+//  if (ver < pWal->vers.snapshotVer) {
-  }
+//  }
 
   if (walReadSeekVerImpl(pReader, ver) < 0) {
     return -1;
@@ -239,8 +240,8 @@ static int32_t walFetchHeadNew(SWalReader *pRead, int64_t fetchVer) {
 
   if (pRead->curInvalid || pRead->curVersion != fetchVer) {
     if (walReadSeekVer(pRead, fetchVer) < 0) {
-      pRead->curVersion = fetchVer;
+//      pRead->curVersion = fetchVer;
-      pRead->curInvalid = 1;
+//      pRead->curInvalid = 1;
       return -1;
     }
     seeked = true;
@@ -259,11 +260,11 @@ static int32_t walFetchHeadNew(SWalReader *pRead, int64_t fetchVer) {
       } else {
         terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
       }
-      pRead->curInvalid = 1;
+//      pRead->curInvalid = 1;
       return -1;
     }
   }
-  pRead->curInvalid = 0;
+//  pRead->curInvalid = 0;
   return 0;
 }
 
@@ -295,13 +296,14 @@ static int32_t walFetchBodyNew(SWalReader *pReader) {
              pReader->pWal->cfg.vgId, pReader->pHead->head.version, ver);
       terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
     }
-    pReader->curInvalid = 1;
+//    pRead->curInvalid = 1;
     return -1;
   }
 
   if (walValidBodyCksum(pReader->pHead) != 0) {
     wError("vgId:%d, wal fetch body error:%" PRId64 ", since body checksum not passed", pReader->pWal->cfg.vgId, ver);
-    pReader->curInvalid = 1;
+//    pRead->curInvalid = 1;
+
     terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
     return -1;
   }
@@ -317,7 +319,7 @@ static int32_t walSkipFetchBodyNew(SWalReader *pRead) {
   code = taosLSeekFile(pRead->pLogFile, pRead->pHead->head.bodyLen, SEEK_CUR);
   if (code < 0) {
     terrno = TAOS_SYSTEM_ERROR(errno);
-    pRead->curInvalid = 1;
+//    pRead->curInvalid = 1;
     return -1;
   }
 
@@ -345,8 +347,8 @@ int32_t walFetchHead(SWalReader *pRead, int64_t ver, SWalCkHead *pHead) {
   if (pRead->curInvalid || pRead->curVersion != ver) {
     code = walReadSeekVer(pRead, ver);
     if (code < 0) {
-      pRead->curVersion = ver;
+//      pRead->curVersion = ver;
-      pRead->curInvalid = 1;
+//      pRead->curInvalid = 1;
       return -1;
     }
     seeked = true;
@@ -366,7 +368,7 @@ int32_t walFetchHead(SWalReader *pRead, int64_t ver, SWalCkHead *pHead) {
       } else {
         terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
       }
-      pRead->curInvalid = 1;
+//      pRead->curInvalid = 1;
       return -1;
     }
   }
@@ -379,7 +381,7 @@ int32_t walFetchHead(SWalReader *pRead, int64_t ver, SWalCkHead *pHead) {
     return -1;
   }
 
-  pRead->curInvalid = 0;
+//  pRead->curInvalid = 0;
   return 0;
 }
 
@@ -394,7 +396,7 @@ int32_t walSkipFetchBody(SWalReader *pRead, const SWalCkHead *pHead) {
   code = taosLSeekFile(pRead->pLogFile, pHead->head.bodyLen, SEEK_CUR);
   if (code < 0) {
     terrno = TAOS_SYSTEM_ERROR(errno);
-    pRead->curInvalid = 1;
+//    pRead->curInvalid = 1;
     return -1;
   }
 
@@ -433,14 +435,14 @@ int32_t walFetchBody(SWalReader *pRead, SWalCkHead **ppHead) {
              pRead->pWal->cfg.vgId, pReadHead->version, ver);
       terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
     }
-    pRead->curInvalid = 1;
+//    pRead->curInvalid = 1;
     return -1;
   }
 
   if (pReadHead->version != ver) {
     wError("vgId:%d, wal fetch body error, index:%" PRId64 ", read request index:%" PRId64, pRead->pWal->cfg.vgId,
            pReadHead->version, ver);
-    pRead->curInvalid = 1;
+//    pRead->curInvalid = 1;
     terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
     return -1;
   }
@@ -448,7 +450,7 @@ int32_t walFetchBody(SWalReader *pRead, SWalCkHead **ppHead) {
   if (walValidBodyCksum(*ppHead) != 0) {
     wError("vgId:%d, wal fetch body error, index:%" PRId64 ", since body checksum not passed", pRead->pWal->cfg.vgId,
            ver);
-    pRead->curInvalid = 1;
+//    pRead->curInvalid = 1;
     terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
     return -1;
   }
@@ -544,7 +546,7 @@ int32_t walReadVer(SWalReader *pReader, int64_t ver) {
   if (pReader->pHead->head.version != ver) {
     wError("vgId:%d, unexpected wal log, index:%" PRId64 ", read request index:%" PRId64, pReader->pWal->cfg.vgId,
            pReader->pHead->head.version, ver);
-    pReader->curInvalid = 1;
+//    pReader->curInvalid = 1;
     terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
     taosThreadMutexUnlock(&pReader->mutex);
     return -1;
@@ -557,7 +559,7 @@ int32_t walReadVer(SWalReader *pReader, int64_t ver) {
     uint32_t readCkSum = walCalcBodyCksum(pReader->pHead->head.body, pReader->pHead->head.bodyLen);
     uint32_t logCkSum = pReader->pHead->cksumBody;
     wError("checksum written into log:%u, checksum calculated:%u", logCkSum, readCkSum);
-    pReader->curInvalid = 1;
+//    pReader->curInvalid = 1;
     terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
     taosThreadMutexUnlock(&pReader->mutex);
     return -1;
@@ -575,5 +577,6 @@ void walReadReset(SWalReader *pReader) {
   taosCloseFile(&pReader->pLogFile);
   pReader->curInvalid = 1;
   pReader->curFileFirstVer = -1;
+  pReader->curVersion = -1;
   taosThreadMutexUnlock(&pReader->mutex);
 }

source/util/src/terror.c

@@ -94,6 +94,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_NO_AVAIL_DISK,                "No available disk")
 TAOS_DEFINE_ERROR(TSDB_CODE_NOT_FOUND,                    "Not found")
 TAOS_DEFINE_ERROR(TSDB_CODE_NO_DISKSPACE,                 "Out of disk space")
 TAOS_DEFINE_ERROR(TSDB_CODE_TIMEOUT_ERROR,                "Operation timeout")
+TAOS_DEFINE_ERROR(TSDB_CODE_NO_ENOUGH_DISKSPACE,          "No enough disk space")
 
 TAOS_DEFINE_ERROR(TSDB_CODE_APP_IS_STARTING,              "Database is starting up")
 TAOS_DEFINE_ERROR(TSDB_CODE_APP_IS_STOPPING,              "Database is closing down")

source/util/src/thashutil.c

@@ -50,11 +50,6 @@ uint32_t taosDJB2Hash(const char *key, uint32_t len) {
   return hash;
 }
 
-uint32_t xxHash(const char *key, uint32_t len) {
-  int32_t seed = 0xcc9e2d51;
-  return XXH32(key, len, seed);
-}
-
 uint32_t MurmurHash3_32(const char *key, uint32_t len) {
   const uint8_t *data = (const uint8_t *)key;
   const int32_t  nblocks = len >> 2u;

source/util/src/tutil.c

@@ -468,7 +468,7 @@ size_t tstrncspn(const char *str, size_t size, const char *reject, size_t rsize)
     c3 = p[s[j + 3]];
 
     if ((c0 | c1 | c2 | c3) != 0) {
-      size_t count = ((i + 1) >> 2);
+      size_t count = i * 4;
       return (c0 | c1) != 0 ? count - c0 + 1 : count - c2 + 3;
     }
   }

source/util/test/utilTests.cpp

@@ -294,6 +294,10 @@ TEST(utilTest, tstrncspn) {
   const char* reject5 = "911";
   v = tstrncspn(p2, strlen(p2), reject5, 0);
   ASSERT_EQ(v, 14);
+
+  const char* reject6 = "Kk";
+  v = tstrncspn(p2, strlen(p2), reject6, 2);
+  ASSERT_EQ(v, 10);
 }
 
 TEST(utilTest, intToHextStr) {

tests/develop-test/2-query/show_create_db.py

@@ -42,17 +42,17 @@ class TDTestCase:
         tdSql.query('show create database scd;')
         tdSql.checkRows(1)
         tdSql.checkData(0, 0, 'scd')
-        tdSql.checkData(0, 1, "CREATE DATABASE `scd` BUFFER 256 CACHESIZE 1 CACHEMODEL 'none' COMP 2 DURATION 14400m WAL_FSYNC_PERIOD 3000 MAXROWS 4096 MINROWS 100 STT_TRIGGER 1 KEEP 5256000m,5256000m,5256000m PAGES 256 PAGESIZE 4 PRECISION 'ms' REPLICA 1 WAL_LEVEL 1 VGROUPS 2 SINGLE_STABLE 0")
+        tdSql.checkData(0, 1, "CREATE DATABASE `scd` BUFFER 256 CACHESIZE 1 CACHEMODEL 'none' COMP 2 DURATION 14400m WAL_FSYNC_PERIOD 3000 MAXROWS 4096 MINROWS 100 STT_TRIGGER 1 KEEP 5256000m,5256000m,5256000m PAGES 256 PAGESIZE 4 PRECISION 'ms' REPLICA 1 WAL_LEVEL 1 VGROUPS 2 SINGLE_STABLE 0 TABLE_PREFIX 0 TABLE_SUFFIX 0 TSDB_PAGESIZE 4 WAL_RETENTION_PERIOD 0 WAL_RETENTION_SIZE 0 WAL_ROLL_PERIOD 0 WAL_SEGMENT_SIZE 0")
 
         tdSql.query('show create database scd2;')
         tdSql.checkRows(1)
         tdSql.checkData(0, 0, 'scd2')
-        tdSql.checkData(0, 1, "CREATE DATABASE `scd2` BUFFER 256 CACHESIZE 1 CACHEMODEL 'none' COMP 2 DURATION 14400m WAL_FSYNC_PERIOD 3000 MAXROWS 4096 MINROWS 100 STT_TRIGGER 3 KEEP 5256000m,5256000m,5256000m PAGES 256 PAGESIZE 4 PRECISION 'ms' REPLICA 1 WAL_LEVEL 1 VGROUPS 2 SINGLE_STABLE 0")
+        tdSql.checkData(0, 1, "CREATE DATABASE `scd2` BUFFER 256 CACHESIZE 1 CACHEMODEL 'none' COMP 2 DURATION 14400m WAL_FSYNC_PERIOD 3000 MAXROWS 4096 MINROWS 100 STT_TRIGGER 3 KEEP 5256000m,5256000m,5256000m PAGES 256 PAGESIZE 4 PRECISION 'ms' REPLICA 1 WAL_LEVEL 1 VGROUPS 2 SINGLE_STABLE 0 TABLE_PREFIX 0 TABLE_SUFFIX 0 TSDB_PAGESIZE 4 WAL_RETENTION_PERIOD 0 WAL_RETENTION_SIZE 0 WAL_ROLL_PERIOD 0 WAL_SEGMENT_SIZE 0")
 
         tdSql.query('show create database scd4')
         tdSql.checkRows(1)
         tdSql.checkData(0, 0, 'scd4')
-        tdSql.checkData(0, 1, "CREATE DATABASE `scd4` BUFFER 256 CACHESIZE 1 CACHEMODEL 'none' COMP 2 DURATION 14400m WAL_FSYNC_PERIOD 3000 MAXROWS 4096 MINROWS 100 STT_TRIGGER 13 KEEP 5256000m,5256000m,5256000m PAGES 256 PAGESIZE 4 PRECISION 'ms' REPLICA 1 WAL_LEVEL 1 VGROUPS 2 SINGLE_STABLE 0")
+        tdSql.checkData(0, 1, "CREATE DATABASE `scd4` BUFFER 256 CACHESIZE 1 CACHEMODEL 'none' COMP 2 DURATION 14400m WAL_FSYNC_PERIOD 3000 MAXROWS 4096 MINROWS 100 STT_TRIGGER 13 KEEP 5256000m,5256000m,5256000m PAGES 256 PAGESIZE 4 PRECISION 'ms' REPLICA 1 WAL_LEVEL 1 VGROUPS 2 SINGLE_STABLE 0 TABLE_PREFIX 0 TABLE_SUFFIX 0 TSDB_PAGESIZE 4 WAL_RETENTION_PERIOD 0 WAL_RETENTION_SIZE 0 WAL_ROLL_PERIOD 0 WAL_SEGMENT_SIZE 0")
 
 
         self.restartTaosd(1, dbname='scd')
@@ -60,17 +60,17 @@ class TDTestCase:
         tdSql.query('show create database scd;')
         tdSql.checkRows(1)
         tdSql.checkData(0, 0, 'scd')
-        tdSql.checkData(0, 1, "CREATE DATABASE `scd` BUFFER 256 CACHESIZE 1 CACHEMODEL 'none' COMP 2 DURATION 14400m WAL_FSYNC_PERIOD 3000 MAXROWS 4096 MINROWS 100 STT_TRIGGER 1 KEEP 5256000m,5256000m,5256000m PAGES 256 PAGESIZE 4 PRECISION 'ms' REPLICA 1 WAL_LEVEL 1 VGROUPS 2 SINGLE_STABLE 0")
+        tdSql.checkData(0, 1, "CREATE DATABASE `scd` BUFFER 256 CACHESIZE 1 CACHEMODEL 'none' COMP 2 DURATION 14400m WAL_FSYNC_PERIOD 3000 MAXROWS 4096 MINROWS 100 STT_TRIGGER 1 KEEP 5256000m,5256000m,5256000m PAGES 256 PAGESIZE 4 PRECISION 'ms' REPLICA 1 WAL_LEVEL 1 VGROUPS 2 SINGLE_STABLE 0 TABLE_PREFIX 0 TABLE_SUFFIX 0 TSDB_PAGESIZE 4 WAL_RETENTION_PERIOD 0 WAL_RETENTION_SIZE 0 WAL_ROLL_PERIOD 0 WAL_SEGMENT_SIZE 0")
 
         tdSql.query('show create database scd2;')
         tdSql.checkRows(1)
         tdSql.checkData(0, 0, 'scd2')
-        tdSql.checkData(0, 1, "CREATE DATABASE `scd2` BUFFER 256 CACHESIZE 1 CACHEMODEL 'none' COMP 2 DURATION 14400m WAL_FSYNC_PERIOD 3000 MAXROWS 4096 MINROWS 100 STT_TRIGGER 3 KEEP 5256000m,5256000m,5256000m PAGES 256 PAGESIZE 4 PRECISION 'ms' REPLICA 1 WAL_LEVEL 1 VGROUPS 2 SINGLE_STABLE 0")
+        tdSql.checkData(0, 1, "CREATE DATABASE `scd2` BUFFER 256 CACHESIZE 1 CACHEMODEL 'none' COMP 2 DURATION 14400m WAL_FSYNC_PERIOD 3000 MAXROWS 4096 MINROWS 100 STT_TRIGGER 3 KEEP 5256000m,5256000m,5256000m PAGES 256 PAGESIZE 4 PRECISION 'ms' REPLICA 1 WAL_LEVEL 1 VGROUPS 2 SINGLE_STABLE 0 TABLE_PREFIX 0 TABLE_SUFFIX 0 TSDB_PAGESIZE 4 WAL_RETENTION_PERIOD 0 WAL_RETENTION_SIZE 0 WAL_ROLL_PERIOD 0 WAL_SEGMENT_SIZE 0")
 
         tdSql.query('show create database scd4')
         tdSql.checkRows(1)
         tdSql.checkData(0, 0, 'scd4')
-        tdSql.checkData(0, 1, "CREATE DATABASE `scd4` BUFFER 256 CACHESIZE 1 CACHEMODEL 'none' COMP 2 DURATION 14400m WAL_FSYNC_PERIOD 3000 MAXROWS 4096 MINROWS 100 STT_TRIGGER 13 KEEP 5256000m,5256000m,5256000m PAGES 256 PAGESIZE 4 PRECISION 'ms' REPLICA 1 WAL_LEVEL 1 VGROUPS 2 SINGLE_STABLE 0")
+        tdSql.checkData(0, 1, "CREATE DATABASE `scd4` BUFFER 256 CACHESIZE 1 CACHEMODEL 'none' COMP 2 DURATION 14400m WAL_FSYNC_PERIOD 3000 MAXROWS 4096 MINROWS 100 STT_TRIGGER 13 KEEP 5256000m,5256000m,5256000m PAGES 256 PAGESIZE 4 PRECISION 'ms' REPLICA 1 WAL_LEVEL 1 VGROUPS 2 SINGLE_STABLE 0 TABLE_PREFIX 0 TABLE_SUFFIX 0 TSDB_PAGESIZE 4 WAL_RETENTION_PERIOD 0 WAL_RETENTION_SIZE 0 WAL_ROLL_PERIOD 0 WAL_SEGMENT_SIZE 0")
 
 
         tdSql.execute('drop database scd')

tests/develop-test/test.py

@@ -343,7 +343,7 @@ if __name__ == "__main__":
                 for i in range(cursor.rowcount):
                     if res[i][0] == "queryPolicy":
                         if int(res[i][1]) == int(queryPolicy):
-                            tdLog.success(
+                            tdLog.info(
                                 f"alter queryPolicy to {queryPolicy} successfully"
                             )
                         else:
@@ -402,7 +402,7 @@ if __name__ == "__main__":
                 for i in range(cursor.rowcount):
                     if res[i][0] == "queryPolicy":
                         if int(res[i][1]) == int(queryPolicy):
-                            tdLog.success(
+                            tdLog.info(
                                 f"alter queryPolicy to {queryPolicy} successfully"
                             )
                         else:
@@ -471,7 +471,7 @@ if __name__ == "__main__":
                 # for i in range(tdSql.queryRows):
                 #     if tdSql.queryResult[i][0] == "queryPolicy" :
                 #         if int(tdSql.queryResult[i][1]) == int(queryPolicy):
-                #             tdLog.success('alter queryPolicy to %d successfully'%queryPolicy)
+                #             tdLog.info('alter queryPolicy to %d successfully'%queryPolicy)
                 #         else :
                 #             tdLog.debug(tdSql.queryResult)
                 #             tdLog.exit("alter queryPolicy to  %d failed"%queryPolicy)
@@ -484,7 +484,7 @@ if __name__ == "__main__":
                 for i in range(cursor.rowcount):
                     if res[i][0] == "queryPolicy":
                         if int(res[i][1]) == int(queryPolicy):
-                            tdLog.success(
+                            tdLog.info(
                                 f"alter queryPolicy to {queryPolicy} successfully"
                             )
                         else:
@@ -545,7 +545,7 @@ if __name__ == "__main__":
                 for i in range(cursor.rowcount):
                     if res[i][0] == "queryPolicy":
                         if int(res[i][1]) == int(queryPolicy):
-                            tdLog.success(
+                            tdLog.info(
                                 f"alter queryPolicy to {queryPolicy} successfully"
                             )
                         else: