Merge branch 'main' into feature/stream

cmake/cmake.define

@@ -123,21 +123,37 @@ ELSE ()
         SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wno-literal-suffix -Werror=return-type -fPIC -gdwarf-2 -g3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
     ENDIF ()
 
-    IF (TD_INTEL_64 OR TD_INTEL_32)
+    INCLUDE(CheckCCompilerFlag)
-        ADD_DEFINITIONS("-msse4.2")
+    IF (("${CMAKE_C_COMPILER_ID}" MATCHES "Clang") OR ("${CMAKE_C_COMPILER_ID}" MATCHES "AppleClang"))
-        IF("${FMA_SUPPORT}" MATCHES "true")
+        SET(COMPILER_SUPPORT_SSE42 true)
-            MESSAGE(STATUS "fma function supported")
+        MESSAGE(STATUS "Always enable sse4.2 for Clang/AppleClang")
-            ADD_DEFINITIONS("-mfma")
     ELSE()
-            MESSAGE(STATUS "fma function NOT supported")
+        CHECK_C_COMPILER_FLAG("-msse4.2" COMPILER_SUPPORT_SSE42)
+    ENDIF()
+
+    CHECK_C_COMPILER_FLAG("-mfma" COMPILER_SUPPORT_FMA)
+    CHECK_C_COMPILER_FLAG("-mavx" COMPILER_SUPPORT_AVX)
+    CHECK_C_COMPILER_FLAG("-mavx2" COMPILER_SUPPORT_AVX2)
+
+    IF (COMPILER_SUPPORT_SSE42)
+        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -msse4.2")
+        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse4.2")
+    ENDIF()
+    IF (COMPILER_SUPPORT_FMA)
+        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfma")
+        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfma")
     ENDIF()
 
     IF ("${SIMD_SUPPORT}" MATCHES "true")
-            ADD_DEFINITIONS("-mavx -mavx2")
+        IF (COMPILER_SUPPORT_AVX)
-            MESSAGE(STATUS "SIMD instructions (AVX/AVX2) is ACTIVATED")
+            SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mavx")
-        ELSE()
+            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx")
-            MESSAGE(STATUS "SIMD instruction (AVX/AVX2)is NOT ACTIVATED")
         ENDIF()
+        IF (COMPILER_SUPPORT_AVX2)
+            SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mavx2")
+            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx2")
+        ENDIF()
+        MESSAGE(STATUS "SIMD instructions (AVX/AVX2) is ACTIVATED")
     ENDIF()
 
 ENDIF ()

cmake/cmake.platform

@@ -147,7 +147,7 @@ ELSE ()
   ENDIF ()
 ENDIF ()
 
-MESSAGE(STATUS "platform arch:" ${PLATFORM_ARCH_STR})
+MESSAGE(STATUS "Platform arch:" ${PLATFORM_ARCH_STR})
 
 MESSAGE("C Compiler: ${CMAKE_C_COMPILER} (${CMAKE_C_COMPILER_ID}, ${CMAKE_C_COMPILER_VERSION})")
 MESSAGE("CXX Compiler: ${CMAKE_CXX_COMPILER} (${CMAKE_C_COMPILER_ID}, ${CMAKE_CXX_COMPILER_VERSION})")

cmake/cmake.version

@@ -2,7 +2,7 @@
 IF (DEFINED VERNUMBER)
   SET(TD_VER_NUMBER ${VERNUMBER})
 ELSE ()
-  SET(TD_VER_NUMBER "3.0.1.8")
+  SET(TD_VER_NUMBER "3.0.2.0")
 ENDIF ()
 
 IF (DEFINED VERCOMPATIBLE)

cmake/taosadapter_CMakeLists.txt.in

@@ -2,7 +2,7 @@
 # taosadapter
 ExternalProject_Add(taosadapter
         GIT_REPOSITORY https://github.com/taosdata/taosadapter.git
-        GIT_TAG 0dfad5b
+        GIT_TAG 566540d
         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 ac69142
+        GIT_TAG 4a4027c
         SOURCE_DIR "${TD_SOURCE_DIR}/tools/taos-tools"
         BINARY_DIR ""
         #BUILD_IN_SOURCE TRUE

docs/en/20-third-party/11-kafka.md

@@ -76,7 +76,7 @@ Development: false
 ### Install from source code
 
 ```
-git clone https://github.com:taosdata/kafka-connect-tdengine.git
+git clone https://github.com/taosdata/kafka-connect-tdengine.git
 cd kafka-connect-tdengine
 mvn clean package
 unzip -d $CONFLUENT_HOME/share/java/ target/components/packages/taosdata-kafka-connect-tdengine-*.zip

docs/zh/20-third-party/11-kafka.md

@@ -79,7 +79,7 @@ Development: false
 ### 从源码安装
 
 ```
-git clone https://github.com:taosdata/kafka-connect-tdengine.git
+git clone https://github.com/taosdata/kafka-connect-tdengine.git
 cd kafka-connect-tdengine
 mvn clean package
 unzip -d $CONFLUENT_HOME/share/java/ target/components/packages/taosdata-kafka-connect-tdengine-*.zip

examples/c/CMakeLists.txt

@@ -3,19 +3,13 @@ PROJECT(TDengine)
 IF (TD_LINUX)
   INCLUDE_DIRECTORIES(. ${TD_SOURCE_DIR}/src/inc ${TD_SOURCE_DIR}/src/client/inc  ${TD_SOURCE_DIR}/inc)
   AUX_SOURCE_DIRECTORY(. SRC)
-  #  ADD_EXECUTABLE(demo apitest.c)
-  #TARGET_LINK_LIBRARIES(demo taos_static trpc tutil pthread )
-  #ADD_EXECUTABLE(sml schemaless.c)
-  #TARGET_LINK_LIBRARIES(sml taos_static trpc tutil pthread )
-  #ADD_EXECUTABLE(subscribe subscribe.c)
-  #TARGET_LINK_LIBRARIES(subscribe taos_static trpc tutil pthread )
-  #ADD_EXECUTABLE(epoll epoll.c)
-  #TARGET_LINK_LIBRARIES(epoll taos_static trpc tutil pthread lua)
 
   add_executable(tmq "")
   add_executable(stream_demo "")
-  add_executable(demoapi "")
+  add_executable(schemaless "")
-  add_executable(api_reqid "")
+  add_executable(prepare "")
+  add_executable(demo "")
+  add_executable(asyncdemo "")
 
   target_sources(tmq
       PRIVATE
@@ -27,16 +21,25 @@ IF (TD_LINUX)
       "stream_demo.c"
       )
 
-  target_sources(demoapi
+  target_sources(schemaless
       PRIVATE
-      "demoapi.c"
+      "schemaless.c"
       )
 
-  target_sources(api_reqid
+  target_sources(prepare
     PRIVATE 
-    "api_with_reqid_test.c"
+    "prepare.c"
     )
     
+  target_sources(demo
+    PRIVATE 
+    "demo.c"
+    )
+
+  target_sources(asyncdemo
+    PRIVATE 
+    "asyncdemo.c"
+    )
 
   target_link_libraries(tmq
       taos_static
@@ -46,46 +49,30 @@ IF (TD_LINUX)
       taos_static
       )
 
-  target_link_libraries(demoapi
+  target_link_libraries(schemaless
       taos_static
       )
 
-  target_link_libraries(api_reqid
+  target_link_libraries(prepare
       taos_static
       )
   
-
+  target_link_libraries(demo
-  target_include_directories(tmq
+      taos_static
-      PUBLIC "${TD_SOURCE_DIR}/include/os"
-      PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
       )
 
-  target_include_directories(stream_demo
+  target_link_libraries(asyncdemo
-      PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+      taos_static
-      )
-
-  target_include_directories(demoapi
-      PUBLIC "${TD_SOURCE_DIR}/include/client"
-      PUBLIC "${TD_SOURCE_DIR}/include/os"
-      PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
-      )
-
-  target_include_directories(api_reqid
-      PUBLIC "${TD_SOURCE_DIR}/include/client"
-      PUBLIC "${TD_SOURCE_DIR}/include/os"
-      PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
       )
 
   SET_TARGET_PROPERTIES(tmq PROPERTIES OUTPUT_NAME tmq)
   SET_TARGET_PROPERTIES(stream_demo PROPERTIES OUTPUT_NAME stream_demo)
-  SET_TARGET_PROPERTIES(demoapi PROPERTIES OUTPUT_NAME demoapi)
+  SET_TARGET_PROPERTIES(schemaless PROPERTIES OUTPUT_NAME schemaless)
-  SET_TARGET_PROPERTIES(api_reqid PROPERTIES OUTPUT_NAME api_reqid)
+  SET_TARGET_PROPERTIES(prepare PROPERTIES OUTPUT_NAME prepare)
+  SET_TARGET_PROPERTIES(demo PROPERTIES OUTPUT_NAME demo)
+  SET_TARGET_PROPERTIES(asyncdemo PROPERTIES OUTPUT_NAME asyncdemo)
 ENDIF ()
 IF (TD_DARWIN)
   INCLUDE_DIRECTORIES(. ${TD_SOURCE_DIR}/src/inc ${TD_SOURCE_DIR}/src/client/inc  ${TD_SOURCE_DIR}/inc)
   AUX_SOURCE_DIRECTORY(. SRC)
-  #ADD_EXECUTABLE(demo demo.c)
-  #TARGET_LINK_LIBRARIES(demo taos_static trpc tutil pthread lua)
-  #ADD_EXECUTABLE(epoll epoll.c)
-  #TARGET_LINK_LIBRARIES(epoll taos_static trpc tutil pthread lua)
 ENDIF ()

examples/c/asyncdemo.c

@@ -23,8 +23,8 @@
 #include <sys/time.h>
 #include <unistd.h>
 #include <string.h>
-
+#include <inttypes.h>
-#include "../../../include/client/taos.h"
+#include "taos.h"
 
 int     points = 5;
 int     numOfTables = 3;
@@ -230,7 +230,7 @@ void taos_insert_call_back(void *param, TAOS_RES *tres, int code)
     if (tablesInsertProcessed >= numOfTables) {
       gettimeofday(&systemTime, NULL);
       et = systemTime.tv_sec * 1000000 + systemTime.tv_usec;
-      printf("%lld mseconds to insert %d data points\n", (et - st) / 1000, points*numOfTables);
+      printf("%" PRId64 " mseconds to insert %d data points\n", (et - st) / 1000, points*numOfTables);
     }
   }
   
@@ -267,7 +267,7 @@ void taos_retrieve_call_back(void *param, TAOS_RES *tres, int numOfRows)
     if (tablesSelectProcessed >= numOfTables) {
       gettimeofday(&systemTime, NULL);
       et = systemTime.tv_sec * 1000000 + systemTime.tv_usec;
-      printf("%lld mseconds to query %d data rows\n", (et - st) / 1000, points * numOfTables);
+      printf("%" PRId64 " mseconds to query %d data rows\n", (et - st) / 1000, points * numOfTables);
     }
 
     taos_free_result(tres);

examples/c/demo.c

@@ -20,7 +20,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include "../../../include/client/taos.h"  // TAOS header file
+#include "taos.h"  // TAOS header file
 
 static void queryDB(TAOS *taos, char *command) {
   int i;

examples/c/epoll.c

@@ -1,304 +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/>.
- */
-
-// how to use to do a pressure-test upon eok
-// tester:               cat /dev/urandom | nc -c <ip> <port>
-// testee:               ./debug/build/bin/epoll -l <port> > /dev/null
-// compare against:      nc -l <port> > /dev/null
-// monitor and compare : glances
-
-#ifdef __APPLE__
-#include "osEok.h"
-#else // __APPLE__
-#include <sys/epoll.h>
-#endif // __APPLE__
-#include <sys/types.h>
-#include <sys/time.h>
-#include <sys/socket.h>
-#include <pthread.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <string.h>
-#include <arpa/inet.h>
-#include <libgen.h>
-#include <locale.h>
-#include <netdb.h>
-
-#define D(fmt, ...) fprintf(stderr, "%s[%d]%s(): " fmt "\n", basename(__FILE__), __LINE__, __func__, ##__VA_ARGS__)
-#define A(statement, fmt, ...) do {                                     \
-  if (statement) break;                                                 \
-  fprintf(stderr, "%s[%d]%s(): assert [%s] failed: %d[%s]: " fmt "\n",  \
-          basename(__FILE__), __LINE__, __func__,                       \
-          #statement, errno, strerror(errno),                           \
-          ##__VA_ARGS__);                                               \
-  abort();                                                              \
-} while (0)
-
-#define E(fmt, ...) do {                                                \
-  fprintf(stderr, "%s[%d]%s(): %d[%s]: " fmt "\n",                      \
-          basename(__FILE__), __LINE__, __func__,                       \
-          errno, strerror(errno),                                       \
-          ##__VA_ARGS__);                                               \
-} while (0)
-
-#include "os.h"
-
-typedef struct ep_s            ep_t;
-struct ep_s {
-  int                    ep;
-
-  pthread_mutex_t        lock;
-  int                    sv[2];  // 0 for read, 1 for write;
-  pthread_t              thread;
-
-  volatile unsigned int  stopping:1;
-  volatile unsigned int  waiting:1;
-  volatile unsigned int  wakenup:1;
-};
-
-static int ep_dummy = 0;
-
-static ep_t* ep_create(void);
-static void  ep_destroy(ep_t *ep);
-static void* routine(void* arg);
-static int open_listen(unsigned short port);
-
-typedef struct fde_s          fde_t;
-struct fde_s {
-  int                          skt;
-  void (*on_event)(ep_t *ep, struct epoll_event *events, fde_t *client);
-};
-
-static void listen_event(ep_t *ep, struct epoll_event *ev, fde_t *client);
-static void null_event(ep_t *ep, struct epoll_event *ev, fde_t *client);
-
-#define usage(arg0, fmt, ...)       do {                                               \
-  if (fmt[0]) {                                                                        \
-    fprintf(stderr, "" fmt "\n", ##__VA_ARGS__);                                       \
-  }                                                                                    \
-  fprintf(stderr, "usage:\n");                                                         \
-  fprintf(stderr, "  %s -l <port>             : specify listenning port\n", arg0);     \
-} while (0)
-
-int main(int argc, char *argv[]) {
-  char *prg = basename(argv[0]);
-  if (argc==1) {
-    usage(prg, "");
-    return 0;
-  }
-  ep_t* ep = ep_create();
-  A(ep, "failed");
-  for (int i=1; i<argc; ++i) {
-    const char *arg = argv[i];
-    if (0==strcmp(arg, "-l")) {
-      ++i;
-      if (i>=argc) {
-        usage(prg, "expecting <port> after -l, but got nothing");
-        return 1; // confirmed potential leakage
-      }
-      arg = argv[i];
-      int port = atoi(arg);
-      int skt = open_listen(port);
-      if (skt==-1) continue;
-      fde_t *client = (fde_t*)calloc(1, sizeof(*client));
-      if (!client) {
-        E("out of memory");
-        close(skt);
-        continue;
-      }
-      client->skt = skt;
-      client->on_event = listen_event;
-      struct epoll_event ev = {0};
-      ev.events   = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLRDHUP;
-      ev.data.ptr = client;
-      A(0==epoll_ctl(ep->ep, EPOLL_CTL_ADD, skt, &ev), "");
-      continue;
-    }
-    usage(prg, "unknown argument: [%s]", arg);
-    return 1;
-  }
-  char *line = NULL;
-  size_t linecap = 0;
-  ssize_t linelen;
-  while ((linelen = getline(&line, &linecap, stdin)) > 0) {
-    line[strlen(line)-1] = '\0';
-    if (0==strcmp(line, "exit")) break;
-    if (0==strcmp(line, "quit")) break;
-    if (line==strstr(line, "close")) {
-      int fd = 0;
-      sscanf(line, "close %d", &fd);
-      if (fd<=2) {
-        fprintf(stderr, "fd [%d] invalid\n", fd);
-        continue;
-      }
-      A(0==epoll_ctl(ep->ep, EPOLL_CTL_DEL, fd, NULL), "");
-      continue;
-    }
-    if (strlen(line)==0) continue;
-    fprintf(stderr, "unknown cmd:[%s]\n", line);
-  }
-  ep_destroy(ep);
-  D("");
-  return 0;
-}
-
-ep_t* ep_create(void) {
-  ep_t *ep = (ep_t*)calloc(1, sizeof(*ep));
-  A(ep, "out of memory");
-  A(-1!=(ep->ep = epoll_create(1)), "");
-  ep->sv[0] = -1;
-  ep->sv[1] = -1;
-  A(0==socketpair(AF_LOCAL, SOCK_STREAM, 0, ep->sv), "");
-  A(0==pthread_mutex_init(&ep->lock, NULL), "");
-  A(0==pthread_mutex_lock(&ep->lock), "");
-  struct epoll_event ev = {0};
-  ev.events   = EPOLLIN;
-  ev.data.ptr = &ep_dummy;
-  A(0==epoll_ctl(ep->ep, EPOLL_CTL_ADD, ep->sv[0], &ev), "");
-  A(0==pthread_create(&ep->thread, NULL, routine, ep), "");
-  A(0==pthread_mutex_unlock(&ep->lock), "");
-  return ep;
-}
-
-static void ep_destroy(ep_t *ep) {
-  A(ep, "invalid argument");
-  ep->stopping = 1;
-  A(1==send(ep->sv[1], "1", 1, 0), "");
-  A(0==pthread_join(ep->thread, NULL), "");
-  A(0==pthread_mutex_destroy(&ep->lock), "");
-  A(0==close(ep->sv[0]), "");
-  A(0==close(ep->sv[1]), "");
-  A(0==close(ep->ep), "");
-  free(ep);
-}
-
-static void* routine(void* arg) {
-  A(arg, "invalid argument");
-  ep_t *ep = (ep_t*)arg;
-
-  while (!ep->stopping) {
-    struct epoll_event evs[10];
-    memset(evs, 0, sizeof(evs));
-
-    A(0==pthread_mutex_lock(&ep->lock), "");
-    A(ep->waiting==0, "internal logic error");
-    ep->waiting = 1;
-    A(0==pthread_mutex_unlock(&ep->lock), "");
-
-    int r = epoll_wait(ep->ep, evs, sizeof(evs)/sizeof(evs[0]), -1);
-    A(r>0, "indefinite epoll_wait shall not timeout:[%d]", r);
-
-    A(0==pthread_mutex_lock(&ep->lock), "");
-    A(ep->waiting==1, "internal logic error");
-    ep->waiting = 0;
-    A(0==pthread_mutex_unlock(&ep->lock), "");
-
-    for (int i=0; i<r; ++i) {
-      struct epoll_event *ev = evs + i;
-      if (ev->data.ptr == &ep_dummy) {
-        char c = '\0';
-        A(1==recv(ep->sv[0], &c, 1, 0), "internal logic error");
-        A(0==pthread_mutex_lock(&ep->lock), "");
-        ep->wakenup = 0;
-        A(0==pthread_mutex_unlock(&ep->lock), "");
-        continue;
-      }
-      A(ev->data.ptr, "internal logic error");
-      fde_t *client = (fde_t*)ev->data.ptr;
-      client->on_event(ep, ev, client);
-      continue;
-    }
-  }
-  return NULL;
-}
-
-static int open_listen(unsigned short port) {
-  int r = 0;
-  int skt = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-  if (skt==-1) {
-    E("socket() failed");
-    return -1;
-  }
-  do {
-    struct sockaddr_in si = {0};
-    si.sin_family = AF_INET;
-    si.sin_addr.s_addr = inet_addr("0.0.0.0");
-    si.sin_port = htons(port);
-    r = bind(skt, (struct sockaddr*)&si, sizeof(si));
-    if (r) {
-      E("bind(%u) failed", port);
-      break;
-    }
-    r = listen(skt, 100);
-    if (r) {
-      E("listen() failed");
-      break;
-    }
-    memset(&si, 0, sizeof(si));
-    socklen_t len = sizeof(si);
-    r = getsockname(skt, (struct sockaddr *)&si, &len);
-    if (r) {
-      E("getsockname() failed");
-    }
-    A(len==sizeof(si), "internal logic error");
-    D("listenning at: %d", ntohs(si.sin_port));
-    return skt;
-  } while (0);
-  close(skt);
-  return -1;
-}
-
-static void listen_event(ep_t *ep, struct epoll_event *ev, fde_t *client) {
-  A(ev->events & EPOLLIN, "internal logic error");
-  struct sockaddr_in si = {0};
-  socklen_t silen = sizeof(si);
-  int skt = accept(client->skt, (struct sockaddr*)&si, &silen);
-  A(skt!=-1, "internal logic error");
-  fde_t *server = (fde_t*)calloc(1, sizeof(*server));
-  if (!server) {
-    close(skt);
-    return;
-  }
-  server->skt = skt;
-  server->on_event = null_event;
-  struct epoll_event ee = {0};
-  ee.events   = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLRDHUP;
-  ee.data.ptr = server;
-  A(0==epoll_ctl(ep->ep, EPOLL_CTL_ADD, skt, &ee), "");
-}
-
-static void null_event(ep_t *ep, struct epoll_event *ev, fde_t *client) {
-  if (ev->events & EPOLLIN) {
-    char buf[8192];
-    int n = recv(client->skt, buf, sizeof(buf), 0);
-    A(n>=0 && n<=sizeof(buf), "internal logic error:[%d]", n);
-    A(n==fwrite(buf, 1, n, stdout), "internal logic error");
-  }
-  if (ev->events & (EPOLLERR | EPOLLHUP | EPOLLRDHUP)) {
-    A(0==pthread_mutex_lock(&ep->lock), "");
-    A(0==epoll_ctl(ep->ep, EPOLL_CTL_DEL, client->skt, NULL), "");
-    A(0==pthread_mutex_unlock(&ep->lock), "");
-    close(client->skt);
-    client->skt = -1;
-    client->on_event = NULL;
-    free(client);
-  }
-}
-

examples/c/makefile

@@ -7,22 +7,21 @@ LFLAGS = '-Wl,-rpath,/usr/local/taos/driver/' -ltaos -lpthread -lm -lrt
 CFLAGS = -O3 -g -Wall -Wno-deprecated -fPIC -Wno-unused-result -Wconversion \
 	-Wno-char-subscripts -D_REENTRANT -Wno-format -D_REENTRANT -DLINUX \
 	-Wno-unused-function -D_M_X64 -I/usr/local/taos/include -std=gnu99 \
-	-I../../../deps/cJson/inc
+	-I/usr/local/include/cjson
 all: $(TARGET)
 
 exe:
 	gcc $(CFLAGS) ./asyncdemo.c -o $(ROOT)asyncdemo $(LFLAGS)
 	gcc $(CFLAGS) ./demo.c -o $(ROOT)demo $(LFLAGS)
 	gcc $(CFLAGS) ./prepare.c -o $(ROOT)prepare $(LFLAGS)
-	gcc $(CFLAGS) ./stream.c -o $(ROOT)stream $(LFLAGS)
+	gcc $(CFLAGS) ./stream_demo.c -o $(ROOT)stream_demo $(LFLAGS)
-	gcc $(CFLAGS) ./subscribe.c -o $(ROOT)subscribe $(LFLAGS)
+	gcc $(CFLAGS) ./tmq.c -o $(ROOT)tmq $(LFLAGS)
-	gcc $(CFLAGS) ./apitest.c -o $(ROOT)apitest $(LFLAGS)
+	gcc $(CFLAGS) ./schemaless.c -o $(ROOT)schemaless $(LFLAGS)
 
 clean:
 	rm $(ROOT)asyncdemo
 	rm $(ROOT)demo
 	rm $(ROOT)prepare
-	rm $(ROOT)batchprepare
+	rm $(ROOT)stream_demo
-	rm $(ROOT)stream
+	rm $(ROOT)tmq
-	rm $(ROOT)subscribe
+	rm $(ROOT)schemaless
-	rm $(ROOT)apitest

examples/c/prepare.c

@@ -4,7 +4,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include "../../../include/client/taos.h"
+#include "taos.h"
 
 void taosMsleep(int mseconds);
 
@@ -70,70 +70,89 @@ int main(int argc, char *argv[])
       char blob[80];
   } v = {0};
 
+  int32_t boolLen = sizeof(int8_t);
+  int32_t sintLen = sizeof(int16_t);
+  int32_t intLen = sizeof(int32_t);
+  int32_t bintLen = sizeof(int64_t);
+  int32_t floatLen = sizeof(float);
+  int32_t doubleLen = sizeof(double);
+  int32_t binLen = sizeof(v.bin);
+  int32_t ncharLen = 30;
+
   stmt = taos_stmt_init(taos);
-  TAOS_BIND params[10];
+  TAOS_MULTI_BIND params[10];
   params[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
   params[0].buffer_length = sizeof(v.ts);
   params[0].buffer = &v.ts;
-  params[0].length = &params[0].buffer_length;
+  params[0].length = &bintLen;
   params[0].is_null = NULL;
+  params[0].num = 1;
 
   params[1].buffer_type = TSDB_DATA_TYPE_BOOL;
   params[1].buffer_length = sizeof(v.b);
   params[1].buffer = &v.b;
-  params[1].length = &params[1].buffer_length;
+  params[1].length = &boolLen;
   params[1].is_null = NULL;
+  params[1].num = 1;
 
   params[2].buffer_type = TSDB_DATA_TYPE_TINYINT;
   params[2].buffer_length = sizeof(v.v1);
   params[2].buffer = &v.v1;
-  params[2].length = &params[2].buffer_length;
+  params[2].length = &boolLen;
   params[2].is_null = NULL;
+  params[2].num = 1;
 
   params[3].buffer_type = TSDB_DATA_TYPE_SMALLINT;
   params[3].buffer_length = sizeof(v.v2);
   params[3].buffer = &v.v2;
-  params[3].length = &params[3].buffer_length;
+  params[3].length = &sintLen;
   params[3].is_null = NULL;
+  params[3].num = 1;
 
   params[4].buffer_type = TSDB_DATA_TYPE_INT;
   params[4].buffer_length = sizeof(v.v4);
   params[4].buffer = &v.v4;
-  params[4].length = &params[4].buffer_length;
+  params[4].length = &intLen;
   params[4].is_null = NULL;
+  params[4].num = 1;
 
   params[5].buffer_type = TSDB_DATA_TYPE_BIGINT;
   params[5].buffer_length = sizeof(v.v8);
   params[5].buffer = &v.v8;
-  params[5].length = &params[5].buffer_length;
+  params[5].length = &bintLen;
   params[5].is_null = NULL;
+  params[5].num = 1;
 
   params[6].buffer_type = TSDB_DATA_TYPE_FLOAT;
   params[6].buffer_length = sizeof(v.f4);
   params[6].buffer = &v.f4;
-  params[6].length = &params[6].buffer_length;
+  params[6].length = &floatLen;
   params[6].is_null = NULL;
+  params[6].num = 1;
 
   params[7].buffer_type = TSDB_DATA_TYPE_DOUBLE;
   params[7].buffer_length = sizeof(v.f8);
   params[7].buffer = &v.f8;
-  params[7].length = &params[7].buffer_length;
+  params[7].length = &doubleLen;
   params[7].is_null = NULL;
+  params[7].num = 1;
 
   params[8].buffer_type = TSDB_DATA_TYPE_BINARY;
   params[8].buffer_length = sizeof(v.bin);
   params[8].buffer = v.bin;
-  params[8].length = &params[8].buffer_length;
+  params[8].length = &binLen;
   params[8].is_null = NULL;
+  params[8].num = 1;
 
   strcpy(v.blob, "一二三四五六七八九十");
   params[9].buffer_type = TSDB_DATA_TYPE_NCHAR;
-  params[9].buffer_length = strlen(v.blob);
+  params[9].buffer_length = sizeof(v.blob);
   params[9].buffer = v.blob;
-  params[9].length = &params[9].buffer_length;
+  params[9].length = &ncharLen;
   params[9].is_null = NULL;
+  params[9].num = 1;
 
-  int is_null = 1;
+  char is_null = 1;
 
   sql = "insert into m1 values(?,?,?,?,?,?,?,?,?,?)";
   code = taos_stmt_prepare(stmt, sql, 0);
@@ -153,7 +172,7 @@ int main(int argc, char *argv[])
     v.v8 = (int64_t)(i * 8);
     v.f4 = (float)(i * 40);
     v.f8 = (double)(i * 80);
-    for (int j = 0; j < sizeof(v.bin) - 1; ++j) {
+    for (int j = 0; j < sizeof(v.bin); ++j) {
       v.bin[j] = (char)(i + '0');
     }
 

examples/c/schemaless.c

@@ -1,32 +1,17 @@
-#include "../../../include/client/taos.h"
+#include "taos.h"
-#include "os.h"
-#include "taoserror.h"
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/time.h>
 #include <time.h>
 #include <unistd.h>
+#include <inttypes.h>
+#include <string.h>
+
 
 int numSuperTables = 8;
 int numChildTables = 4;
 int numRowsPerChildTable = 2048;
 
-void shuffle(char**lines, size_t n)
-{
-  if (n > 1)
-  {
-    size_t i;
-    for (i = 0; i < n - 1; i++)
-    {
-      size_t j = i + taosRand() / (RAND_MAX / (n - i) + 1);
-      char* t = lines[j];
-      lines[j] = lines[i];
-      lines[i] = t;
-    }
-  }
-}
-
 static int64_t getTimeInUs() {
   struct timeval systemTime;
   gettimeofday(&systemTime, NULL);
@@ -46,7 +31,7 @@ int main(int argc, char* argv[]) {
     exit(1);
   }
 
-  char* info = taos_get_server_info(taos);
+  const char* info = taos_get_server_info(taos);
   printf("server info: %s\n", info);
   info = taos_get_client_info(taos);
   printf("client info: %s\n", info);
@@ -61,9 +46,10 @@ int main(int argc, char* argv[]) {
 
   time_t ct = time(0);
   int64_t ts = ct * 1000;
-  char* lineFormat = "sta%d,t0=true,t1=127i8,t2=32767i16,t3=%di32,t4=9223372036854775807i64,t9=11.12345f32,t10=22.123456789f64,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c0=true,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=254u8,c6=32770u16,c7=2147483699u32,c8=9223372036854775899u64,c9=11.12345f32,c10=22.123456789f64,c11=\"binaryValue\",c12=L\"ncharValue\" %lldms";
+  char* lineFormat = "sta%d,t0=true,t1=127i8,t2=32767i16,t3=%di32,t4=9223372036854775807i64,t9=11.12345f32,t10=22.123456789f64,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c0=true,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=254u8,c6=32770u16,c7=2147483699u32,c8=9223372036854775899u64,c9=11.12345f32,c10=22.123456789f64,c11=\"binaryValue\",c12=L\"ncharValue\" %" PRId64;
 
-  char** lines = calloc(numSuperTables * numChildTables * numRowsPerChildTable, sizeof(char*));
+  int lineNum = numSuperTables * numChildTables * numRowsPerChildTable;
+  char** lines = calloc((size_t)lineNum, sizeof(char*));
   int l = 0;
   for (int i = 0; i < numSuperTables; ++i) {
     for (int j = 0; j < numChildTables; ++j) {
@@ -75,13 +61,13 @@ int main(int argc, char* argv[]) {
       }
     }
   }
-  //shuffle(lines, numSuperTables * numChildTables * numRowsPerChildTable);
 
   printf("%s\n", "begin taos_insert_lines");
   int64_t  begin = getTimeInUs();
-  int32_t code = taos_insert_lines(taos, lines, numSuperTables * numChildTables * numRowsPerChildTable);
+  TAOS_RES *res = taos_schemaless_insert(taos, lines, lineNum, TSDB_SML_LINE_PROTOCOL, TSDB_SML_TIMESTAMP_MILLI_SECONDS);
   int64_t end = getTimeInUs();
-  printf("code: %d, %s. time used: %"PRId64"\n", code, tstrerror(code), end-begin);
+  printf("code: %s. time used: %" PRId64 "\n", taos_errstr(res), end-begin);
+  taos_free_result(res);
 
   return 0;
 }

examples/c/stream_demo.c

@@ -108,10 +108,13 @@ int32_t create_stream() {
 }
 
 int main(int argc, char* argv[]) {
-  int code;
   if (argc > 1) {
     printf("env init\n");
-    code = init_env();
+    int code = init_env();
+    if (code) {
+       return code;
+    }
+
   }
   create_stream();
 }

examples/c/tmq.c

@@ -21,9 +21,6 @@
 #include "taos.h"
 
 static int  running = 1;
-static char dbName[64] = "tmqdb";
-static char stbName[64] = "stb";
-static char topicName[64] = "topicname";
 
 static int32_t msg_process(TAOS_RES* msg) {
   char    buf[1024];
@@ -43,7 +40,7 @@ static int32_t msg_process(TAOS_RES* msg) {
 
     TAOS_FIELD* fields = taos_fetch_fields(msg);
     int32_t     numOfFields = taos_field_count(msg);
-    int32_t*    length = taos_fetch_lengths(msg);
+    //int32_t*    length = taos_fetch_lengths(msg);
     int32_t     precision = taos_result_precision(msg);
     rows++;
     taos_print_row(buf, row, fields, numOfFields);
@@ -62,6 +59,13 @@ static int32_t init_env() {
   TAOS_RES* pRes;
   // drop database if exists
   printf("create database\n");
+  pRes = taos_query(pConn, "drop topic topicname");
+  if (taos_errno(pRes) != 0) {
+    printf("error in drop tmqdb, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
   pRes = taos_query(pConn, "drop database if exists tmqdb");
   if (taos_errno(pRes) != 0) {
     printf("error in drop tmqdb, reason:%s\n", taos_errstr(pRes));
@@ -249,7 +253,7 @@ int main(int argc, char* argv[]) {
 
   tmq_t* tmq = build_consumer();
   if (NULL == tmq) {
-    fprintf(stderr, "%% build_consumer() fail!\n");
+    fprintf(stderr, "build_consumer() fail!\n");
     return -1;
   }
 
@@ -259,7 +263,7 @@ int main(int argc, char* argv[]) {
   }
 
   if ((code = tmq_subscribe(tmq, topic_list))) {
-    fprintf(stderr, "%% Failed to tmq_subscribe(): %s\n", tmq_err2str(code));
+    fprintf(stderr, "Failed to tmq_subscribe(): %s\n", tmq_err2str(code));
   }
   tmq_list_destroy(topic_list);
 
@@ -267,9 +271,9 @@ int main(int argc, char* argv[]) {
 
   code = tmq_consumer_close(tmq);
   if (code) {
-    fprintf(stderr, "%% Failed to close consumer: %s\n", tmq_err2str(code));
+    fprintf(stderr, "Failed to close consumer: %s\n", tmq_err2str(code));
   } else {
-    fprintf(stderr, "%% Consumer closed\n");
+    fprintf(stderr, "Consumer closed\n");
   }
 
   return 0;

include/client/taos.h

@@ -149,7 +149,7 @@ DLL_EXPORT TAOS      *taos_connect(const char *ip, const char *user, const char
 DLL_EXPORT TAOS *taos_connect_auth(const char *ip, const char *user, const char *auth, const char *db, uint16_t port);
 DLL_EXPORT void  taos_close(TAOS *taos);
 
-const char *taos_data_type(int type);
+DLL_EXPORT const char *taos_data_type(int type);
 
 DLL_EXPORT TAOS_STMT *taos_stmt_init(TAOS *taos);
 DLL_EXPORT TAOS_STMT *taos_stmt_init_with_reqid(TAOS *taos, int64_t reqid);

include/common/tcommon.h

@@ -195,6 +195,7 @@ typedef struct SDataBlockInfo {
   uint32_t    capacity;
   SBlockID    id;
   int16_t     hasVarCol;
+  int16_t     dataLoad;   // denote if the data is loaded or not
 
   // TODO: optimize and remove following
   int64_t     version;    // used for stream, and need serialization

include/common/ttokendef.h

@@ -94,242 +94,242 @@
 #define TK_TSDB_PAGESIZE        76
 #define TK_PRECISION            77
 #define TK_REPLICA              78
-#define TK_STRICT               79
+#define TK_VGROUPS              79
-#define TK_VGROUPS              80
+#define TK_SINGLE_STABLE        80
-#define TK_SINGLE_STABLE        81
+#define TK_RETENTIONS           81
-#define TK_RETENTIONS           82
+#define TK_SCHEMALESS           82
-#define TK_SCHEMALESS           83
+#define TK_WAL_LEVEL            83
-#define TK_WAL_LEVEL            84
+#define TK_WAL_FSYNC_PERIOD     84
-#define TK_WAL_FSYNC_PERIOD     85
+#define TK_WAL_RETENTION_PERIOD 85
-#define TK_WAL_RETENTION_PERIOD 86
+#define TK_WAL_RETENTION_SIZE   86
-#define TK_WAL_RETENTION_SIZE   87
+#define TK_WAL_ROLL_PERIOD      87
-#define TK_WAL_ROLL_PERIOD      88
+#define TK_WAL_SEGMENT_SIZE     88
-#define TK_WAL_SEGMENT_SIZE     89
+#define TK_STT_TRIGGER          89
-#define TK_STT_TRIGGER          90
+#define TK_TABLE_PREFIX         90
-#define TK_TABLE_PREFIX         91
+#define TK_TABLE_SUFFIX         91
-#define TK_TABLE_SUFFIX         92
+#define TK_NK_COLON             92
-#define TK_NK_COLON             93
+#define TK_MAX_SPEED            93
-#define TK_MAX_SPEED            94
+#define TK_TABLE                94
-#define TK_TABLE                95
+#define TK_NK_LP                95
-#define TK_NK_LP                96
+#define TK_NK_RP                96
-#define TK_NK_RP                97
+#define TK_STABLE               97
-#define TK_STABLE               98
+#define TK_ADD                  98
-#define TK_ADD                  99
+#define TK_COLUMN               99
-#define TK_COLUMN               100
+#define TK_MODIFY               100
-#define TK_MODIFY               101
+#define TK_RENAME               101
-#define TK_RENAME               102
+#define TK_TAG                  102
-#define TK_TAG                  103
+#define TK_SET                  103
-#define TK_SET                  104
+#define TK_NK_EQ                104
-#define TK_NK_EQ                105
+#define TK_USING                105
-#define TK_USING                106
+#define TK_TAGS                 106
-#define TK_TAGS                 107
+#define TK_COMMENT              107
-#define TK_COMMENT              108
+#define TK_BOOL                 108
-#define TK_BOOL                 109
+#define TK_TINYINT              109
-#define TK_TINYINT              110
+#define TK_SMALLINT             110
-#define TK_SMALLINT             111
+#define TK_INT                  111
-#define TK_INT                  112
+#define TK_INTEGER              112
-#define TK_INTEGER              113
+#define TK_BIGINT               113
-#define TK_BIGINT               114
+#define TK_FLOAT                114
-#define TK_FLOAT                115
+#define TK_DOUBLE               115
-#define TK_DOUBLE               116
+#define TK_BINARY               116
-#define TK_BINARY               117
+#define TK_TIMESTAMP            117
-#define TK_TIMESTAMP            118
+#define TK_NCHAR                118
-#define TK_NCHAR                119
+#define TK_UNSIGNED             119
-#define TK_UNSIGNED             120
+#define TK_JSON                 120
-#define TK_JSON                 121
+#define TK_VARCHAR              121
-#define TK_VARCHAR              122
+#define TK_MEDIUMBLOB           122
-#define TK_MEDIUMBLOB           123
+#define TK_BLOB                 123
-#define TK_BLOB                 124
+#define TK_VARBINARY            124
-#define TK_VARBINARY            125
+#define TK_DECIMAL              125
-#define TK_DECIMAL              126
+#define TK_MAX_DELAY            126
-#define TK_MAX_DELAY            127
+#define TK_WATERMARK            127
-#define TK_WATERMARK            128
+#define TK_ROLLUP               128
-#define TK_ROLLUP               129
+#define TK_TTL                  129
-#define TK_TTL                  130
+#define TK_SMA                  130
-#define TK_SMA                  131
+#define TK_DELETE_MARK          131
-#define TK_DELETE_MARK          132
+#define TK_FIRST                132
-#define TK_FIRST                133
+#define TK_LAST                 133
-#define TK_LAST                 134
+#define TK_SHOW                 134
-#define TK_SHOW                 135
+#define TK_PRIVILEGES           135
-#define TK_PRIVILEGES           136
+#define TK_DATABASES            136
-#define TK_DATABASES            137
+#define TK_TABLES               137
-#define TK_TABLES               138
+#define TK_STABLES              138
-#define TK_STABLES              139
+#define TK_MNODES               139
-#define TK_MNODES               140
+#define TK_QNODES               140
-#define TK_QNODES               141
+#define TK_FUNCTIONS            141
-#define TK_FUNCTIONS            142
+#define TK_INDEXES              142
-#define TK_INDEXES              143
+#define TK_ACCOUNTS             143
-#define TK_ACCOUNTS             144
+#define TK_APPS                 144
-#define TK_APPS                 145
+#define TK_CONNECTIONS          145
-#define TK_CONNECTIONS          146
+#define TK_LICENCES             146
-#define TK_LICENCES             147
+#define TK_GRANTS               147
-#define TK_GRANTS               148
+#define TK_QUERIES              148
-#define TK_QUERIES              149
+#define TK_SCORES               149
-#define TK_SCORES               150
+#define TK_TOPICS               150
-#define TK_TOPICS               151
+#define TK_VARIABLES            151
-#define TK_VARIABLES            152
+#define TK_CLUSTER              152
-#define TK_CLUSTER              153
+#define TK_BNODES               153
-#define TK_BNODES               154
+#define TK_SNODES               154
-#define TK_SNODES               155
+#define TK_TRANSACTIONS         155
-#define TK_TRANSACTIONS         156
+#define TK_DISTRIBUTED          156
-#define TK_DISTRIBUTED          157
+#define TK_CONSUMERS            157
-#define TK_CONSUMERS            158
+#define TK_SUBSCRIPTIONS        158
-#define TK_SUBSCRIPTIONS        159
+#define TK_VNODES               159
-#define TK_VNODES               160
+#define TK_LIKE                 160
-#define TK_LIKE                 161
+#define TK_TBNAME               161
-#define TK_TBNAME               162
+#define TK_QTAGS                162
-#define TK_QTAGS                163
+#define TK_AS                   163
-#define TK_AS                   164
+#define TK_INDEX                164
-#define TK_INDEX                165
+#define TK_FUNCTION             165
-#define TK_FUNCTION             166
+#define TK_INTERVAL             166
-#define TK_INTERVAL             167
+#define TK_TOPIC                167
-#define TK_TOPIC                168
+#define TK_WITH                 168
-#define TK_WITH                 169
+#define TK_META                 169
-#define TK_META                 170
+#define TK_CONSUMER             170
-#define TK_CONSUMER             171
+#define TK_GROUP                171
-#define TK_GROUP                172
+#define TK_DESC                 172
-#define TK_DESC                 173
+#define TK_DESCRIBE             173
-#define TK_DESCRIBE             174
+#define TK_RESET                174
-#define TK_RESET                175
+#define TK_QUERY                175
-#define TK_QUERY                176
+#define TK_CACHE                176
-#define TK_CACHE                177
+#define TK_EXPLAIN              177
-#define TK_EXPLAIN              178
+#define TK_ANALYZE              178
-#define TK_ANALYZE              179
+#define TK_VERBOSE              179
-#define TK_VERBOSE              180
+#define TK_NK_BOOL              180
-#define TK_NK_BOOL              181
+#define TK_RATIO                181
-#define TK_RATIO                182
+#define TK_NK_FLOAT             182
-#define TK_NK_FLOAT             183
+#define TK_OUTPUTTYPE           183
-#define TK_OUTPUTTYPE           184
+#define TK_AGGREGATE            184
-#define TK_AGGREGATE            185
+#define TK_BUFSIZE              185
-#define TK_BUFSIZE              186
+#define TK_STREAM               186
-#define TK_STREAM               187
+#define TK_INTO                 187
-#define TK_INTO                 188
+#define TK_TRIGGER              188
-#define TK_TRIGGER              189
+#define TK_AT_ONCE              189
-#define TK_AT_ONCE              190
+#define TK_WINDOW_CLOSE         190
-#define TK_WINDOW_CLOSE         191
+#define TK_IGNORE               191
-#define TK_IGNORE               192
+#define TK_EXPIRED              192
-#define TK_EXPIRED              193
+#define TK_FILL_HISTORY         193
-#define TK_FILL_HISTORY         194
+#define TK_SUBTABLE             194
-#define TK_SUBTABLE             195
+#define TK_KILL                 195
-#define TK_KILL                 196
+#define TK_CONNECTION           196
-#define TK_CONNECTION           197
+#define TK_TRANSACTION          197
-#define TK_TRANSACTION          198
+#define TK_BALANCE              198
-#define TK_BALANCE              199
+#define TK_VGROUP               199
-#define TK_VGROUP               200
+#define TK_MERGE                200
-#define TK_MERGE                201
+#define TK_REDISTRIBUTE         201
-#define TK_REDISTRIBUTE         202
+#define TK_SPLIT                202
-#define TK_SPLIT                203
+#define TK_DELETE               203
-#define TK_DELETE               204
+#define TK_INSERT               204
-#define TK_INSERT               205
+#define TK_NULL                 205
-#define TK_NULL                 206
+#define TK_NK_QUESTION          206
-#define TK_NK_QUESTION          207
+#define TK_NK_ARROW             207
-#define TK_NK_ARROW             208
+#define TK_ROWTS                208
-#define TK_ROWTS                209
+#define TK_QSTART               209
-#define TK_QSTART               210
+#define TK_QEND                 210
-#define TK_QEND                 211
+#define TK_QDURATION            211
-#define TK_QDURATION            212
+#define TK_WSTART               212
-#define TK_WSTART               213
+#define TK_WEND                 213
-#define TK_WEND                 214
+#define TK_WDURATION            214
-#define TK_WDURATION            215
+#define TK_IROWTS               215
-#define TK_IROWTS               216
+#define TK_CAST                 216
-#define TK_CAST                 217
+#define TK_NOW                  217
-#define TK_NOW                  218
+#define TK_TODAY                218
-#define TK_TODAY                219
+#define TK_TIMEZONE             219
-#define TK_TIMEZONE             220
+#define TK_CLIENT_VERSION       220
-#define TK_CLIENT_VERSION       221
+#define TK_SERVER_VERSION       221
-#define TK_SERVER_VERSION       222
+#define TK_SERVER_STATUS        222
-#define TK_SERVER_STATUS        223
+#define TK_CURRENT_USER         223
-#define TK_CURRENT_USER         224
+#define TK_COUNT                224
-#define TK_COUNT                225
+#define TK_LAST_ROW             225
-#define TK_LAST_ROW             226
+#define TK_CASE                 226
-#define TK_CASE                 227
+#define TK_END                  227
-#define TK_END                  228
+#define TK_WHEN                 228
-#define TK_WHEN                 229
+#define TK_THEN                 229
-#define TK_THEN                 230
+#define TK_ELSE                 230
-#define TK_ELSE                 231
+#define TK_BETWEEN              231
-#define TK_BETWEEN              232
+#define TK_IS                   232
-#define TK_IS                   233
+#define TK_NK_LT                233
-#define TK_NK_LT                234
+#define TK_NK_GT                234
-#define TK_NK_GT                235
+#define TK_NK_LE                235
-#define TK_NK_LE                236
+#define TK_NK_GE                236
-#define TK_NK_GE                237
+#define TK_NK_NE                237
-#define TK_NK_NE                238
+#define TK_MATCH                238
-#define TK_MATCH                239
+#define TK_NMATCH               239
-#define TK_NMATCH               240
+#define TK_CONTAINS             240
-#define TK_CONTAINS             241
+#define TK_IN                   241
-#define TK_IN                   242
+#define TK_JOIN                 242
-#define TK_JOIN                 243
+#define TK_INNER                243
-#define TK_INNER                244
+#define TK_SELECT               244
-#define TK_SELECT               245
+#define TK_DISTINCT             245
-#define TK_DISTINCT             246
+#define TK_WHERE                246
-#define TK_WHERE                247
+#define TK_PARTITION            247
-#define TK_PARTITION            248
+#define TK_BY                   248
-#define TK_BY                   249
+#define TK_SESSION              249
-#define TK_SESSION              250
+#define TK_STATE_WINDOW         250
-#define TK_STATE_WINDOW         251
+#define TK_SLIDING              251
-#define TK_SLIDING              252
+#define TK_FILL                 252
-#define TK_FILL                 253
+#define TK_VALUE                253
-#define TK_VALUE                254
+#define TK_NONE                 254
-#define TK_NONE                 255
+#define TK_PREV                 255
-#define TK_PREV                 256
+#define TK_LINEAR               256
-#define TK_LINEAR               257
+#define TK_NEXT                 257
-#define TK_NEXT                 258
+#define TK_HAVING               258
-#define TK_HAVING               259
+#define TK_RANGE                259
-#define TK_RANGE                260
+#define TK_EVERY                260
-#define TK_EVERY                261
+#define TK_ORDER                261
-#define TK_ORDER                262
+#define TK_SLIMIT               262
-#define TK_SLIMIT               263
+#define TK_SOFFSET              263
-#define TK_SOFFSET              264
+#define TK_LIMIT                264
-#define TK_LIMIT                265
+#define TK_OFFSET               265
-#define TK_OFFSET               266
+#define TK_ASC                  266
-#define TK_ASC                  267
+#define TK_NULLS                267
-#define TK_NULLS                268
+#define TK_ABORT                268
-#define TK_ABORT                269
+#define TK_AFTER                269
-#define TK_AFTER                270
+#define TK_ATTACH               270
-#define TK_ATTACH               271
+#define TK_BEFORE               271
-#define TK_BEFORE               272
+#define TK_BEGIN                272
-#define TK_BEGIN                273
+#define TK_BITAND               273
-#define TK_BITAND               274
+#define TK_BITNOT               274
-#define TK_BITNOT               275
+#define TK_BITOR                275
-#define TK_BITOR                276
+#define TK_BLOCKS               276
-#define TK_BLOCKS               277
+#define TK_CHANGE               277
-#define TK_CHANGE               278
+#define TK_COMMA                278
-#define TK_COMMA                279
+#define TK_COMPACT              279
-#define TK_COMPACT              280
+#define TK_CONCAT               280
-#define TK_CONCAT               281
+#define TK_CONFLICT             281
-#define TK_CONFLICT             282
+#define TK_COPY                 282
-#define TK_COPY                 283
+#define TK_DEFERRED             283
-#define TK_DEFERRED             284
+#define TK_DELIMITERS           284
-#define TK_DELIMITERS           285
+#define TK_DETACH               285
-#define TK_DETACH               286
+#define TK_DIVIDE               286
-#define TK_DIVIDE               287
+#define TK_DOT                  287
-#define TK_DOT                  288
+#define TK_EACH                 288
-#define TK_EACH                 289
+#define TK_FAIL                 289
-#define TK_FAIL                 290
+#define TK_FILE                 290
-#define TK_FILE                 291
+#define TK_FOR                  291
-#define TK_FOR                  292
+#define TK_GLOB                 292
-#define TK_GLOB                 293
+#define TK_ID                   293
-#define TK_ID                   294
+#define TK_IMMEDIATE            294
-#define TK_IMMEDIATE            295
+#define TK_IMPORT               295
-#define TK_IMPORT               296
+#define TK_INITIALLY            296
-#define TK_INITIALLY            297
+#define TK_INSTEAD              297
-#define TK_INSTEAD              298
+#define TK_ISNULL               298
-#define TK_ISNULL               299
+#define TK_KEY                  299
-#define TK_KEY                  300
+#define TK_MODULES              300
-#define TK_MODULES              301
+#define TK_NK_BITNOT            301
-#define TK_NK_BITNOT            302
+#define TK_NK_SEMI              302
-#define TK_NK_SEMI              303
+#define TK_NOTNULL              303
-#define TK_NOTNULL              304
+#define TK_OF                   304
-#define TK_OF                   305
+#define TK_PLUS                 305
-#define TK_PLUS                 306
+#define TK_PRIVILEGE            306
-#define TK_PRIVILEGE            307
+#define TK_RAISE                307
-#define TK_RAISE                308
+#define TK_REPLACE              308
-#define TK_REPLACE              309
+#define TK_RESTRICT             309
-#define TK_RESTRICT             310
+#define TK_ROW                  310
-#define TK_ROW                  311
+#define TK_SEMI                 311
-#define TK_SEMI                 312
+#define TK_STAR                 312
-#define TK_STAR                 313
+#define TK_STATEMENT            313
-#define TK_STATEMENT            314
+#define TK_STRICT               314
 #define TK_STRING               315
 #define TK_TIMES                316
 #define TK_UPDATE               317

include/libs/catalog/catalog.h

@@ -211,6 +211,8 @@ int32_t catalogGetCachedSTableMeta(SCatalog* pCtg, const SName* pTableName, STab
 
 int32_t catalogGetCachedTableHashVgroup(SCatalog* pCtg, const SName* pTableName, SVgroupInfo* pVgroup, bool* exists);
 
+int32_t catalogGetCachedTableVgMeta(SCatalog* pCtg, const SName* pTableName,          SVgroupInfo* pVgroup, STableMeta** pTableMeta);
+
 /**
  * Force refresh DB's local cached vgroup info.
  * @param pCtg (input, got with catalogGetHandle)

include/libs/sync/sync.h

@@ -230,7 +230,7 @@ int64_t syncOpen(SSyncInfo* pSyncInfo);
 int32_t syncStart(int64_t rid);
 void    syncStop(int64_t rid);
 void    syncPreStop(int64_t rid);
-int32_t syncPropose(int64_t rid, SRpcMsg* pMsg, bool isWeak);
+int32_t syncPropose(int64_t rid, SRpcMsg* pMsg, bool isWeak, int64_t* seq);
 int32_t syncProcessMsg(int64_t rid, SRpcMsg* pMsg);
 int32_t syncReconfig(int64_t rid, SSyncCfg* pCfg);
 int32_t syncBeginSnapshot(int64_t rid, int64_t lastApplyIndex);
@@ -240,6 +240,7 @@ int32_t syncStepDown(int64_t rid, SyncTerm newTerm);
 bool    syncIsReadyForRead(int64_t rid);
 bool    syncSnapshotSending(int64_t rid);
 bool    syncSnapshotRecving(int64_t rid);
+int32_t syncSendTimeoutRsp(int64_t rid, int64_t seq);
 
 SSyncState  syncGetState(int64_t rid);
 void        syncGetRetryEpSet(int64_t rid, SEpSet* pEpSet);

include/libs/transport/trpc.h

@@ -83,8 +83,6 @@ typedef struct SRpcInit {
   int32_t  sessions;      // number of sessions allowed
   int8_t   connType;      // TAOS_CONN_UDP, TAOS_CONN_TCPC, TAOS_CONN_TCPS
   int32_t  idleTime;      // milliseconds, 0 means idle timer is disabled
-  int32_t  retryLimit;     // retry limit
-  int32_t  retryInterval;  // retry interval ms
 
   int32_t retryMinInterval;  // retry init interval
   int32_t retryStepFactor;   // retry interval factor

include/os/osDir.h

@@ -62,6 +62,7 @@ int32_t taosRealPath(char *dirname, char *realPath, int32_t maxlen);
 bool    taosIsDir(const char *dirname);
 char   *taosDirName(char *dirname);
 char   *taosDirEntryBaseName(char *dirname);
+void    taosGetCwd(char *buf, int32_t len);
 
 TdDirPtr      taosOpenDir(const char *dirname);
 TdDirEntryPtr taosReadDir(TdDirPtr pDir);

include/os/osEnv.h

@@ -36,7 +36,7 @@ extern int64_t         tsStreamMax;
 extern float           tsNumOfCores;
 extern int64_t         tsTotalMemoryKB;
 extern char           *tsProcPath;
-extern char            tsSIMDEnable;
+extern char            tsSIMDBuiltins;
 extern char            tsSSE42Enable;
 extern char            tsAVXEnable;
 extern char            tsAVX2Enable;

include/os/osSystem.h

@@ -63,7 +63,10 @@ void    taosResetTerminalMode();
   }
 #else
 #define taosPrintTrace(flags, level, dflag)                                                                \
-  {}
+  {                                                                                                        \
+    taosPrintLog(flags, level, dflag,                                                                      \
+                 "backtrace not implemented on windows, so detailed stack information cannot be printed"); \
+    }
 #endif
 
 #ifdef __cplusplus

include/util/tdef.h

@@ -309,6 +309,7 @@ typedef enum ELogicConditionType {
 #define TSDB_DEFAULT_DURATION_PER_FILE  (10 * 1440)
 #define TSDB_MIN_KEEP                   (1 * 1440)          // data in db to be reserved. unit minute
 #define TSDB_MAX_KEEP                   (365000 * 1440)     // data in db to be reserved.
+#define TSDB_MAX_KEEP_NS                (365 * 292 * 1440)  // data in db to be reserved.
 #define TSDB_DEFAULT_KEEP               (3650 * 1440)    // ten years
 #define TSDB_MIN_MINROWS_FBLOCK         10
 #define TSDB_MAX_MINROWS_FBLOCK         1000
@@ -336,7 +337,7 @@ typedef enum ELogicConditionType {
 #define TSDB_DB_STRICT_ON_STR           "on"
 #define TSDB_DB_STRICT_OFF              0
 #define TSDB_DB_STRICT_ON               1
-#define TSDB_DEFAULT_DB_STRICT          TSDB_DB_STRICT_OFF
+#define TSDB_DEFAULT_DB_STRICT          TSDB_DB_STRICT_ON
 #define TSDB_CACHE_MODEL_STR_LEN        sizeof(TSDB_CACHE_MODEL_LAST_VALUE_STR)
 #define TSDB_CACHE_MODEL_NONE_STR       "none"
 #define TSDB_CACHE_MODEL_LAST_ROW_STR   "last_row"
@@ -496,6 +497,9 @@ enum {
 // sort page size by default
 #define DEFAULT_PAGESIZE 4096
 
+#define VNODE_TIMEOUT_SEC 60
+#define MNODE_TIMEOUT_SEC 10
+
 #ifdef __cplusplus
 }
 #endif

include/util/tlog.h

@@ -83,8 +83,8 @@ void taosPrintLongString(const char *flags, ELogLevel level, int32_t dflag, cons
 #endif
     ;
 
-bool taosAssertLog(bool condition, const char *file, int32_t line, const char *format, ...);
+bool taosAssert(bool condition, const char *file, int32_t line, const char *format, ...);
-#define ASSERTS(condition, ...) taosAssertLog(condition, __FILE__, __LINE__, __VA_ARGS__)
+#define ASSERTS(condition, ...) taosAssert(condition, __FILE__, __LINE__, __VA_ARGS__)
 #define ASSERT(condition)       ASSERTS(condition, "assert info not provided")
 
 // clang-format off

include/util/tqueue.h

@@ -65,6 +65,7 @@ typedef struct STaosQnode {
   STaosQnode *next;
   STaosQueue *queue;
   int64_t     timestamp;
+  int64_t     dataSize;
   int32_t     size;
   int8_t      itype;
   int8_t      reserved[3];
@@ -103,7 +104,7 @@ typedef struct STaosQall {
 STaosQueue *taosOpenQueue();
 void        taosCloseQueue(STaosQueue *queue);
 void        taosSetQueueFp(STaosQueue *queue, FItem itemFp, FItems itemsFp);
-void       *taosAllocateQitem(int32_t size, EQItype itype);
+void       *taosAllocateQitem(int32_t size, EQItype itype, int64_t dataSize);
 void        taosFreeQitem(void *pItem);
 void        taosWriteQitem(STaosQueue *queue, void *pItem);
 int32_t     taosReadQitem(STaosQueue *queue, void **ppItem);

packaging/tools/makeclient.sh

@@ -187,7 +187,7 @@ if [[ $productName == "TDengine" ]]; then
           git clone --depth 1 https://github.com/taosdata/taos-connector-dotnet ${install_dir}/connector/dotnet
           rm -rf ${install_dir}/connector/dotnet/.git ||:
 #          cp -r ${connector_dir}/nodejs ${install_dir}/connector
-          git clone --depth 1 https://github.com/taosdata/libtaos-rs ${install_dir}/connector/rust
+          git clone --depth 1 https://github.com/taosdata/taos-connector-rust ${install_dir}/connector/rust
           rm -rf ${install_dir}/connector/rust/.git ||:
       fi
   fi

packaging/tools/makepkg.sh

@@ -318,7 +318,7 @@ if [ "$verMode" == "cluster" ] || [ "$verMode" == "cloud" ]; then
         git clone --depth 1 https://github.com/taosdata/taos-connector-dotnet ${install_dir}/connector/dotnet
         rm -rf ${install_dir}/connector/dotnet/.git ||:
 
-        git clone --depth 1 https://github.com/taosdata/libtaos-rs ${install_dir}/connector/rust
+        git clone --depth 1 https://github.com/taosdata/taos-connector-rust ${install_dir}/connector/rust
         rm -rf ${install_dir}/connector/rust/.git ||:
 
         # cp -r ${connector_dir}/python ${install_dir}/connector

source/client/src/clientEnv.c

@@ -146,8 +146,7 @@ void *openTransporter(const char *user, const char *auth, int32_t numOfThread) {
   rpcInit.idleTime = tsShellActivityTimer * 1000;
   rpcInit.compressSize = tsCompressMsgSize;
   rpcInit.dfp = destroyAhandle;
-  rpcInit.retryLimit = tsRpcRetryLimit;
+
-  rpcInit.retryInterval = tsRpcRetryInterval;
   rpcInit.retryMinInterval = tsRedirectPeriod;
   rpcInit.retryStepFactor = tsRedirectFactor;
   rpcInit.retryMaxInterval = tsRedirectMaxPeriod;

source/client/src/clientImpl.c

@@ -190,8 +190,9 @@ int32_t buildRequest(uint64_t connId, const char* sql, int sqlLen, void* param,
   (*pRequest)->body.param = param;
 
   STscObj* pTscObj = (*pRequest)->pTscObj;
-  if (taosHashPut(pTscObj->pRequests, &(*pRequest)->self, sizeof((*pRequest)->self), &(*pRequest)->self,
+  int32_t  err = taosHashPut(pTscObj->pRequests, &(*pRequest)->self, sizeof((*pRequest)->self), &(*pRequest)->self,
-                  sizeof((*pRequest)->self))) {
+                             sizeof((*pRequest)->self));
+  if (err) {
     tscError("%" PRId64 " failed to add to request container, reqId:0x%" PRIx64 ", conn:%" PRId64 ", %s",
              (*pRequest)->self, (*pRequest)->requestId, pTscObj->id, sql);
 
@@ -1645,7 +1646,8 @@ int32_t getVersion1BlockMetaSize(const char* p, int32_t numOfCols) {
 static int32_t estimateJsonLen(SReqResultInfo* pResultInfo, int32_t numOfCols, int32_t numOfRows) {
   char* p = (char*)pResultInfo->pData;
 
-  // | version | total length | total rows | total columns | flag seg| block group id | column schema | each column length |
+  // | version | total length | total rows | total columns | flag seg| block group id | column schema | each column
+  // length |
   int32_t  len = getVersion1BlockMetaSize(p, numOfCols);
   int32_t* colLength = (int32_t*)(p + len);
   len += sizeof(int32_t) * numOfCols;
@@ -1971,8 +1973,6 @@ TSDB_SERVER_STATUS taos_check_server_status(const char* fqdn, int port, char* de
   rpcInit.idleTime = tsShellActivityTimer * 1000;
   rpcInit.compressSize = tsCompressMsgSize;
   rpcInit.user = "_dnd";
-  rpcInit.retryLimit = tsRpcRetryLimit;
-  rpcInit.retryInterval = tsRpcRetryInterval;
 
   clientRpc = rpcOpen(&rpcInit);
   if (clientRpc == NULL) {

source/client/src/clientMain.c

@@ -802,7 +802,7 @@ static void doAsyncQueryFromParse(SMetaData *pResultMeta, void *param, int32_t c
          tstrerror(code));
 
   if (code == TSDB_CODE_SUCCESS) {
-    pWrapper->pCatalogReq->forceUpdate = false;
+    //pWrapper->pCatalogReq->forceUpdate = false;
     code = qContinueParseSql(pWrapper->pParseCtx, pWrapper->pCatalogReq, pResultMeta, pQuery);
   }
 
@@ -883,6 +883,11 @@ void doAsyncQuery(SRequestObj *pRequest, bool updateMetaForce) {
 
   if (pRequest->retry++ > REQUEST_TOTAL_EXEC_TIMES) {
     code = pRequest->prevCode;
+    terrno = code;
+    pRequest->code = code;
+    tscDebug("call sync query cb with code: %s", tstrerror(code));
+    pRequest->body.queryFp(pRequest->body.param, pRequest, code);
+    return;
   }
 
   if (TSDB_CODE_SUCCESS == code) {
@@ -933,6 +938,17 @@ void doAsyncQuery(SRequestObj *pRequest, bool updateMetaForce) {
     tscError("0x%" PRIx64 " error happens, code:%d - %s, reqId:0x%" PRIx64, pRequest->self, code, tstrerror(code),
              pRequest->requestId);
     destorySqlCallbackWrapper(pWrapper);
+    qDestroyQuery(pRequest->pQuery);
+    pRequest->pQuery = NULL;
+
+    if (NEED_CLIENT_HANDLE_ERROR(code)) {
+      tscDebug("0x%" PRIx64 " client retry to handle the error, code:%d - %s, tryCount:%d, reqId:0x%" PRIx64,
+               pRequest->self, code, tstrerror(code), pRequest->retry, pRequest->requestId);
+      pRequest->prevCode = code;
+      doAsyncQuery(pRequest, true);
+      return;
+    }
+
     terrno = code;
     pRequest->code = code;
     pRequest->body.queryFp(pRequest->body.param, pRequest, code);

source/client/src/clientTmq.c

@@ -691,7 +691,7 @@ void tmqAssignAskEpTask(void* param, void* tmrId) {
   int64_t refId = *(int64_t*)param;
   tmq_t*  tmq = taosAcquireRef(tmqMgmt.rsetId, refId);
   if (tmq != NULL) {
-    int8_t* pTaskType = taosAllocateQitem(sizeof(int8_t), DEF_QITEM);
+    int8_t* pTaskType = taosAllocateQitem(sizeof(int8_t), DEF_QITEM, 0);
     *pTaskType = TMQ_DELAYED_TASK__ASK_EP;
     taosWriteQitem(tmq->delayedTask, pTaskType);
     tsem_post(&tmq->rspSem);
@@ -703,7 +703,7 @@ void tmqAssignDelayedCommitTask(void* param, void* tmrId) {
   int64_t refId = *(int64_t*)param;
   tmq_t*  tmq = taosAcquireRef(tmqMgmt.rsetId, refId);
   if (tmq != NULL) {
-    int8_t* pTaskType = taosAllocateQitem(sizeof(int8_t), DEF_QITEM);
+    int8_t* pTaskType = taosAllocateQitem(sizeof(int8_t), DEF_QITEM, 0);
     *pTaskType = TMQ_DELAYED_TASK__COMMIT;
     taosWriteQitem(tmq->delayedTask, pTaskType);
     tsem_post(&tmq->rspSem);
@@ -715,7 +715,7 @@ void tmqAssignDelayedReportTask(void* param, void* tmrId) {
   int64_t refId = *(int64_t*)param;
   tmq_t*  tmq = taosAcquireRef(tmqMgmt.rsetId, refId);
   if (tmq != NULL) {
-    int8_t* pTaskType = taosAllocateQitem(sizeof(int8_t), DEF_QITEM);
+    int8_t* pTaskType = taosAllocateQitem(sizeof(int8_t), DEF_QITEM, 0);
     *pTaskType = TMQ_DELAYED_TASK__REPORT;
     taosWriteQitem(tmq->delayedTask, pTaskType);
     tsem_post(&tmq->rspSem);
@@ -1171,7 +1171,7 @@ int32_t tmqPollCb(void* param, SDataBuf* pMsg, int32_t code) {
       goto CREATE_MSG_FAIL;
     }
     if (code == TSDB_CODE_TQ_NO_COMMITTED_OFFSET) {
-      SMqPollRspWrapper* pRspWrapper = taosAllocateQitem(sizeof(SMqPollRspWrapper), DEF_QITEM);
+      SMqPollRspWrapper* pRspWrapper = taosAllocateQitem(sizeof(SMqPollRspWrapper), DEF_QITEM, 0);
       if (pRspWrapper == NULL) {
         tscWarn("msg discard from vgId:%d, epoch %d since out of memory", vgId, epoch);
         goto CREATE_MSG_FAIL;
@@ -1204,7 +1204,7 @@ int32_t tmqPollCb(void* param, SDataBuf* pMsg, int32_t code) {
   // handle meta rsp
   int8_t rspType = ((SMqRspHead*)pMsg->pData)->mqMsgType;
 
-  SMqPollRspWrapper* pRspWrapper = taosAllocateQitem(sizeof(SMqPollRspWrapper), DEF_QITEM);
+  SMqPollRspWrapper* pRspWrapper = taosAllocateQitem(sizeof(SMqPollRspWrapper), DEF_QITEM, 0);
   if (pRspWrapper == NULL) {
     taosMemoryFree(pMsg->pData);
     taosMemoryFree(pMsg->pEpSet);
@@ -1394,7 +1394,7 @@ int32_t tmqAskEpCb(void* param, SDataBuf* pMsg, int32_t code) {
     tmqUpdateEp(tmq, head->epoch, &rsp);
     tDeleteSMqAskEpRsp(&rsp);
   } else {
-    SMqAskEpRspWrapper* pWrapper = taosAllocateQitem(sizeof(SMqAskEpRspWrapper), DEF_QITEM);
+    SMqAskEpRspWrapper* pWrapper = taosAllocateQitem(sizeof(SMqAskEpRspWrapper), DEF_QITEM, 0);
     if (pWrapper == NULL) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       code = -1;

source/common/src/tdatablock.c

@@ -358,7 +358,11 @@ size_t blockDataGetNumOfCols(const SSDataBlock* pBlock) { return taosArrayGetSiz
 size_t blockDataGetNumOfRows(const SSDataBlock* pBlock) { return pBlock->info.rows; }
 
 int32_t blockDataUpdateTsWindow(SSDataBlock* pDataBlock, int32_t tsColumnIndex) {
-  if (pDataBlock == NULL || pDataBlock->info.rows <= 0) {
+  if (pDataBlock->info.rows > 0) {
+//    ASSERT(pDataBlock->info.dataLoad == 1);
+  }
+
+  if (pDataBlock == NULL || pDataBlock->info.rows <= 0 || pDataBlock->info.dataLoad == 0) {
     return 0;
   }
 
@@ -1157,13 +1161,14 @@ void blockDataEmpty(SSDataBlock* pDataBlock) {
   }
 
   pInfo->rows = 0;
+  pInfo->dataLoad = 0;
   pInfo->window.ekey = 0;
   pInfo->window.skey = 0;
 }
 
 // todo temporarily disable it
 static int32_t doEnsureCapacity(SColumnInfoData* pColumn, const SDataBlockInfo* pBlockInfo, uint32_t numOfRows, bool clearPayload) {
-  ASSERT(numOfRows > 0 /*&& pBlockInfo->capacity >= pBlockInfo->rows*/);
+  ASSERT(numOfRows > 0);
   if (numOfRows <= pBlockInfo->capacity) {
     return TSDB_CODE_SUCCESS;
   }
@@ -1946,9 +1951,9 @@ char* dumpBlockData(SSDataBlock* pDataBlock, const char* flag, char** pDataBuf)
   int32_t len = 0;
   len += snprintf(dumpBuf + len, size - len,
                   "===stream===%s|block type %d|child id %d|group id:%" PRIu64 "|uid:%" PRId64
-                  "|rows:%d|version:%" PRIu64 "\n",
+                  "|rows:%d|version:%" PRIu64 "|cal start:%" PRIu64 "|cal end:%" PRIu64 "\n",
                   flag, (int32_t)pDataBlock->info.type, pDataBlock->info.childId, pDataBlock->info.id.groupId,
-                  pDataBlock->info.id.uid, pDataBlock->info.rows, pDataBlock->info.version);
+                  pDataBlock->info.id.uid, pDataBlock->info.rows, pDataBlock->info.version, pDataBlock->info.calWin.skey, pDataBlock->info.calWin.ekey);
   if (len >= size - 1) return dumpBuf;
 
   for (int32_t j = 0; j < rows; j++) {
@@ -2427,6 +2432,7 @@ const char* blockDecode(SSDataBlock* pBlock, const char* pData) {
     pStart += colLen[i];
   }
 
+  pBlock->info.dataLoad = 1;
   pBlock->info.rows = numOfRows;
   ASSERT(pStart - pData == dataLen);
   return pStart;

source/common/src/tglobal.c

@@ -180,8 +180,6 @@ int32_t tsUptimeInterval = 300;    // seconds
 char    tsUdfdResFuncs[512] = "";  // udfd resident funcs that teardown when udfd exits
 char    tsUdfdLdLibPath[512] = "";
 
-int32_t tsRpcRetryLimit = 100;
-int32_t tsRpcRetryInterval = 15;
 #ifndef _STORAGE
 int32_t taosSetTfsCfg(SConfig *pCfg) {
   SConfigItem *pItem = cfgGetItem(pCfg, "dataDir");
@@ -203,7 +201,9 @@ int32_t taosSetTfsCfg(SConfig *pCfg) {
 int32_t taosSetTfsCfg(SConfig *pCfg);
 #endif
 
-struct SConfig *taosGetCfg() { return tsCfg; }
+struct SConfig *taosGetCfg() {
+  return tsCfg;
+}
 
 static int32_t taosLoadCfg(SConfig *pCfg, const char **envCmd, const char *inputCfgDir, const char *envFile,
                            char *apolloUrl) {
@@ -313,8 +313,6 @@ static int32_t taosAddClientCfg(SConfig *pCfg) {
   if (cfgAddBool(pCfg, "smlDataFormat", tsSmlDataFormat, 1) != 0) return -1;
   if (cfgAddInt32(pCfg, "smlBatchSize", tsSmlBatchSize, 1, INT32_MAX, true) != 0) return -1;
   if (cfgAddInt32(pCfg, "maxMemUsedByInsert", tsMaxMemUsedByInsert, 1, INT32_MAX, true) != 0) return -1;
-  if (cfgAddInt32(pCfg, "rpcRetryLimit", tsRpcRetryLimit, 1, 100000, 0) != 0) return -1;
-  if (cfgAddInt32(pCfg, "rpcRetryInterval", tsRpcRetryInterval, 1, 100000, 0) != 0) return -1;
   if (cfgAddInt32(pCfg, "maxRetryWaitTime", tsMaxRetryWaitTime, 0, 86400000, 0) != 0) return -1;
 
   tsNumOfTaskQueueThreads = tsNumOfCores / 2;
@@ -341,7 +339,7 @@ static int32_t taosAddSystemCfg(SConfig *pCfg) {
   if (cfgAddBool(pCfg, "AVX", tsAVXEnable, 0) != 0) return -1;
   if (cfgAddBool(pCfg, "AVX2", tsAVX2Enable, 0) != 0) return -1;
   if (cfgAddBool(pCfg, "FMA", tsFMAEnable, 0) != 0) return -1;
-  if (cfgAddBool(pCfg, "SIMD-Supported", tsSIMDEnable, 0) != 0) return -1;
+  if (cfgAddBool(pCfg, "SIMD-builtins", tsSIMDBuiltins, 0) != 0) return -1;
 
   if (cfgAddInt64(pCfg, "openMax", tsOpenMax, 0, INT64_MAX, 1) != 0) return -1;
   if (cfgAddInt64(pCfg, "streamMax", tsStreamMax, 0, INT64_MAX, 1) != 0) return -1;
@@ -457,9 +455,6 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
   if (cfgAddString(pCfg, "udfdResFuncs", tsUdfdResFuncs, 0) != 0) return -1;
   if (cfgAddString(pCfg, "udfdLdLibPath", tsUdfdLdLibPath, 0) != 0) return -1;
 
-  if (cfgAddInt32(pCfg, "rpcRetryLimit", tsRpcRetryLimit, 1, 100000, 0) != 0) return -1;
-  if (cfgAddInt32(pCfg, "rpcRetryInterval", tsRpcRetryInterval, 1, 100000, 0) != 0) return -1;
-
   GRANT_CFG_ADD;
   return 0;
 }
@@ -674,8 +669,6 @@ static int32_t taosSetClientCfg(SConfig *pCfg) {
   tsQueryUseNodeAllocator = cfgGetItem(pCfg, "queryUseNodeAllocator")->bval;
   tsKeepColumnName = cfgGetItem(pCfg, "keepColumnName")->bval;
 
-  tsRpcRetryLimit = cfgGetItem(pCfg, "rpcRetryLimit")->i32;
-  tsRpcRetryInterval = cfgGetItem(pCfg, "rpcRetryInterval")->i32;
   tsMaxRetryWaitTime = cfgGetItem(pCfg, "maxRetryWaitTime")->i32;
   return 0;
 }
@@ -738,10 +731,6 @@ static int32_t taosSetServerCfg(SConfig *pCfg) {
   tstrncpy(tsTelemServer, cfgGetItem(pCfg, "telemetryServer")->str, TSDB_FQDN_LEN);
   tsTelemPort = (uint16_t)cfgGetItem(pCfg, "telemetryPort")->i32;
 
-  tsElectInterval = cfgGetItem(pCfg, "syncElectInterval")->i32;
-  tsHeartbeatInterval = cfgGetItem(pCfg, "syncHeartbeatInterval")->i32;
-  tsHeartbeatTimeout = cfgGetItem(pCfg, "syncHeartbeatTimeout")->i32;
-
   tsTransPullupInterval = cfgGetItem(pCfg, "transPullupInterval")->i32;
   tsMqRebalanceInterval = cfgGetItem(pCfg, "mqRebalanceInterval")->i32;
   tsTtlUnit = cfgGetItem(pCfg, "ttlUnit")->i32;
@@ -761,9 +750,6 @@ static int32_t taosSetServerCfg(SConfig *pCfg) {
   if (tsQueryBufferSize >= 0) {
     tsQueryBufferSizeBytes = tsQueryBufferSize * 1048576UL;
   }
-
-  tsRpcRetryLimit = cfgGetItem(pCfg, "rpcRetryLimit")->i32;
-  tsRpcRetryInterval = cfgGetItem(pCfg, "rpcRetryInterval")->i32;
   GRANT_CFG_GET;
   return 0;
 }

source/dnode/mgmt/exe/dmMain.c

@@ -17,6 +17,7 @@
 #include "dmMgmt.h"
 #include "mnode.h"
 #include "tconfig.h"
+#include "tglobal.h"
 
 // clang-format off
 #define DM_APOLLO_URL    "The apollo string to use when configuring the server, such as: -a 'jsonFile:./tests/cfg.json', cfg.json text can be '{\"fqdn\":\"td1\"}'."
@@ -45,9 +46,30 @@ static struct {
   SArray      *pArgs;  // SConfigPair
 } global = {0};
 
-static void dmStopDnode(int signum, void *info, void *ctx) { dmStop(); }
+static void dmSetDebugFlag(int32_t signum, void *sigInfo, void *context) { taosSetAllDebugFlag(143, true); }
+static void dmSetAssert(int32_t signum, void *sigInfo, void *context) { tsAssert = 1; }
+
+static void dmStopDnode(int signum, void *sigInfo, void *context) {
+  // taosIgnSignal(SIGUSR1);
+  // taosIgnSignal(SIGUSR2);
+  taosIgnSignal(SIGTERM);
+  taosIgnSignal(SIGHUP);
+  taosIgnSignal(SIGINT);
+  taosIgnSignal(SIGABRT);
+  taosIgnSignal(SIGBREAK);
+
+  dInfo("shut down signal is %d", signum);
+#ifndef WINDOWS
+  dInfo("sender PID:%d cmdline:%s", ((siginfo_t *)sigInfo)->si_pid,
+        taosGetCmdlineByPID(((siginfo_t *)sigInfo)->si_pid));
+#endif
+
+  dmStop();
+}
 
 static void dmSetSignalHandle() {
+  taosSetSignal(SIGUSR1, dmSetDebugFlag);
+  taosSetSignal(SIGUSR2, dmSetAssert);
   taosSetSignal(SIGTERM, dmStopDnode);
   taosSetSignal(SIGHUP, dmStopDnode);
   taosSetSignal(SIGINT, dmStopDnode);
@@ -105,6 +127,19 @@ static int32_t dmParseArgs(int32_t argc, char const *argv[]) {
   return 0;
 }
 
+static void dmPrintArgs(int32_t argc, char const *argv[]) {
+  char path[1024] = {0};
+  taosGetCwd(path, sizeof(path));
+
+  char    args[1024] = {0};
+  int32_t arglen = snprintf(args, sizeof(args), "%s", argv[0]);
+  for (int32_t i = 1; i < argc; ++i) {
+    arglen = arglen + snprintf(args + arglen, sizeof(args) - arglen, " %s", argv[i]);
+  }
+
+  dInfo("startup path:%s args:%s", path, args);
+}
+
 static void dmGenerateGrant() { mndGenerateMachineCode(); }
 
 static void dmPrintVersion() {
@@ -194,6 +229,8 @@ int mainWindows(int argc, char **argv) {
     return -1;
   }
 
+  dmPrintArgs(argc, argv);
+
   if (taosInitCfg(configDir, global.envCmd, global.envFile, global.apolloUrl, global.pArgs, 0) != 0) {
     dError("failed to start since read config error");
     taosCloseLog();

source/dnode/mgmt/mgmt_dnode/src/dmHandle.c

@@ -103,7 +103,12 @@ void dmSendStatusReq(SDnodeMgmt *pMgmt) {
   tSerializeSStatusReq(pHead, contLen, &req);
   tFreeSStatusReq(&req);
 
-  SRpcMsg rpcMsg = {.pCont = pHead, .contLen = contLen, .msgType = TDMT_MND_STATUS, .info.ahandle = (void *)0x9527};
+  SRpcMsg rpcMsg = {.pCont = pHead,
+                    .contLen = contLen,
+                    .msgType = TDMT_MND_STATUS,
+                    .info.ahandle = (void *)0x9527,
+                    .info.refId = 0,
+                    .info.noResp = 0};
   SRpcMsg rpcRsp = {0};
 
   dTrace("send status req to mnode, dnodeVer:%" PRId64 " statusSeq:%d", req.dnodeVer, req.statusSeq);
@@ -150,7 +155,8 @@ static void dmGetServerRunStatus(SDnodeMgmt *pMgmt, SServerStatusRsp *pStatus) {
   SServerStatusRsp statusRsp = {0};
   SMonMloadInfo    minfo = {0};
   (*pMgmt->getMnodeLoadsFp)(&minfo);
-  if (minfo.isMnode && (minfo.load.syncState == TAOS_SYNC_STATE_ERROR || minfo.load.syncState == TAOS_SYNC_STATE_OFFLINE)) {
+  if (minfo.isMnode &&
+      (minfo.load.syncState == TAOS_SYNC_STATE_ERROR || minfo.load.syncState == TAOS_SYNC_STATE_OFFLINE)) {
     pStatus->statusCode = TSDB_SRV_STATUS_SERVICE_DEGRADED;
     snprintf(pStatus->details, sizeof(pStatus->details), "mnode sync state is %s", syncStr(minfo.load.syncState));
     return;

source/dnode/mgmt/mgmt_dnode/src/dmWorker.c

@@ -21,6 +21,8 @@ static void *dmStatusThreadFp(void *param) {
   int64_t     lastTime = taosGetTimestampMs();
   setThreadName("dnode-status");
 
+  const static int16_t TRIM_FREQ = 30;
+  int32_t              trimCount = 0;
   while (1) {
     taosMsleep(200);
     if (pMgmt->pData->dropped || pMgmt->pData->stopped) break;
@@ -28,9 +30,13 @@ static void *dmStatusThreadFp(void *param) {
     int64_t curTime = taosGetTimestampMs();
     float   interval = (curTime - lastTime) / 1000.0f;
     if (interval >= tsStatusInterval) {
-      taosMemoryTrim(0); 
       dmSendStatusReq(pMgmt);
       lastTime = curTime;
+
+      trimCount = (trimCount + 1) % TRIM_FREQ;
+      if (trimCount == 0) {
+        taosMemoryTrim(0);
+      }
     }
   }
 

source/dnode/mgmt/mgmt_mnode/src/mmWorker.c

@@ -159,12 +159,12 @@ int32_t mmPutMsgToQueue(SMnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc) {
   }
 
   if (pWorker == NULL) return -1;
-  SRpcMsg *pMsg = taosAllocateQitem(sizeof(SRpcMsg), RPC_QITEM);
+  SRpcMsg *pMsg = taosAllocateQitem(sizeof(SRpcMsg), RPC_QITEM, pRpc->contLen);
   if (pMsg == NULL) return -1;
   memcpy(pMsg, pRpc, sizeof(SRpcMsg));
   pRpc->pCont = NULL;
 
-  dTrace("msg:%p, is created and will put into %s queue, type:%s", pMsg, pWorker->name, TMSG_INFO(pRpc->msgType));
+  dTrace("msg:%p, is created and will put into %s queue, type:%s len:%d", pMsg, pWorker->name, TMSG_INFO(pRpc->msgType), pRpc->contLen);
   int32_t code = mmPutMsgToWorker(pMgmt, pWorker, pMsg);
   if (code != 0) {
     dTrace("msg:%p, is freed", pMsg);

source/dnode/mgmt/mgmt_qnode/src/qmWorker.c

@@ -58,19 +58,19 @@ int32_t qmPutNodeMsgToFetchQueue(SQnodeMgmt *pMgmt, SRpcMsg *pMsg) {
 }
 
 int32_t qmPutRpcMsgToQueue(SQnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc) {
-  SRpcMsg *pMsg = taosAllocateQitem(sizeof(SRpcMsg), RPC_QITEM);
+  SRpcMsg *pMsg = taosAllocateQitem(sizeof(SRpcMsg), RPC_QITEM, pRpc->contLen);
   if (pMsg == NULL) return -1;
   memcpy(pMsg, pRpc, sizeof(SRpcMsg));
   pRpc->pCont = NULL;
 
   switch (qtype) {
     case QUERY_QUEUE:
-      dTrace("msg:%p, is created and will put into qnode-query queue", pMsg);
+      dTrace("msg:%p, is created and will put into qnode-query queue, len:%d", pMsg, pRpc->contLen);
       taosWriteQitem(pMgmt->queryWorker.queue, pMsg);
       return 0;
     case READ_QUEUE:
     case FETCH_QUEUE:
-      dTrace("msg:%p, is created and will put into qnode-fetch queue", pMsg);
+      dTrace("msg:%p, is created and will put into qnode-fetch queue, len:%d", pMsg, pRpc->contLen);
       taosWriteQitem(pMgmt->fetchWorker.queue, pMsg);
       return 0;
     default:

source/dnode/mgmt/mgmt_snode/src/smWorker.c

@@ -130,7 +130,7 @@ void smStopWorker(SSnodeMgmt *pMgmt) {
 }
 
 int32_t smPutMsgToQueue(SSnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc) {
-  SRpcMsg *pMsg = taosAllocateQitem(sizeof(SRpcMsg), RPC_QITEM);
+  SRpcMsg *pMsg = taosAllocateQitem(sizeof(SRpcMsg), RPC_QITEM, pRpc->contLen);
   if (pMsg == NULL) {
     rpcFreeCont(pRpc->pCont);
     pRpc->pCont = NULL;
@@ -139,8 +139,8 @@ int32_t smPutMsgToQueue(SSnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc) {
 
   SSnode *pSnode = pMgmt->pSnode;
   if (pSnode == NULL) {
-    dError("msg:%p failed to put into snode queue since %s, type:%s qtype:%d", pMsg, terrstr(),
+    dError("msg:%p failed to put into snode queue since %s, type:%s qtype:%d len:%d", pMsg, terrstr(),
-           TMSG_INFO(pMsg->msgType), qtype);
+           TMSG_INFO(pMsg->msgType), qtype, pRpc->contLen);
     taosFreeQitem(pMsg);
     rpcFreeCont(pRpc->pCont);
     pRpc->pCont = NULL;

source/dnode/mgmt/mgmt_vnode/inc/vmInt.h

@@ -38,6 +38,8 @@ typedef struct SVnodeMgmt {
   TdThreadRwlock lock;
   SVnodesStat    state;
   STfs          *pTfs;
+  TdThread       thread;
+  bool           stop;
 } SVnodeMgmt;
 
 typedef struct {

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

@@ -334,6 +334,62 @@ static void vmCleanup(SVnodeMgmt *pMgmt) {
   taosMemoryFree(pMgmt);
 }
 
+static void vmCheckSyncTimeout(SVnodeMgmt *pMgmt) {
+  int32_t     numOfVnodes = 0;
+  SVnodeObj **ppVnodes = vmGetVnodeListFromHash(pMgmt, &numOfVnodes);
+
+  for (int32_t i = 0; i < numOfVnodes; ++i) {
+    SVnodeObj *pVnode = ppVnodes[i];
+    vnodeSyncCheckTimeout(pVnode->pImpl);
+    vmReleaseVnode(pMgmt, pVnode);
+  }
+
+  if (ppVnodes != NULL) {
+    taosMemoryFree(ppVnodes);
+  }
+}
+
+static void *vmThreadFp(void *param) {
+  SVnodeMgmt *pMgmt = param;
+  int64_t     lastTime = 0;
+  setThreadName("vnode-timer");
+
+  while (1) {
+    lastTime++;
+    taosMsleep(100);
+    if (pMgmt->stop) break;
+    if (lastTime % 10 != 0) continue;
+
+    int64_t sec = lastTime / 10;
+    if (sec % (VNODE_TIMEOUT_SEC / 2) == 0) {
+      vmCheckSyncTimeout(pMgmt);
+    }
+  }
+
+  return NULL;
+}
+
+static int32_t vmInitTimer(SVnodeMgmt *pMgmt) {
+  TdThreadAttr thAttr;
+  taosThreadAttrInit(&thAttr);
+  taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE);
+  if (taosThreadCreate(&pMgmt->thread, &thAttr, vmThreadFp, pMgmt) != 0) {
+    dError("failed to create vnode timer thread since %s", strerror(errno));
+    return -1;
+  }
+
+  taosThreadAttrDestroy(&thAttr);
+  return 0;
+}
+
+static void vmCleanupTimer(SVnodeMgmt *pMgmt) {
+  pMgmt->stop = true;
+  if (taosCheckPthreadValid(pMgmt->thread)) {
+    taosThreadJoin(pMgmt->thread, NULL);
+    taosThreadClear(&pMgmt->thread);
+  }
+}
+
 static int32_t vmInit(SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
   int32_t code = -1;
 
@@ -510,12 +566,10 @@ static int32_t vmStartVnodes(SVnodeMgmt *pMgmt) {
     taosMemoryFree(ppVnodes);
   }
 
-  return 0;
+  return vmInitTimer(pMgmt);
 }
 
-static void vmStop(SVnodeMgmt *pMgmt) {
+static void vmStop(SVnodeMgmt *pMgmt) { vmCleanupTimer(pMgmt); }
-  // process inside the vnode
-}
 
 SMgmtFunc vmGetMgmtFunc() {
   SMgmtFunc mgmtFunc = {0};

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

@@ -233,7 +233,7 @@ int32_t vmPutMsgToMgmtQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
 }
 
 int32_t vmPutRpcMsgToQueue(SVnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc) {
-  SRpcMsg *pMsg = taosAllocateQitem(sizeof(SRpcMsg), RPC_QITEM);
+  SRpcMsg *pMsg = taosAllocateQitem(sizeof(SRpcMsg), RPC_QITEM, pRpc->contLen);
   if (pMsg == NULL) {
     rpcFreeCont(pRpc->pCont);
     pRpc->pCont = NULL;
@@ -241,7 +241,7 @@ int32_t vmPutRpcMsgToQueue(SVnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc) {
   }
 
   SMsgHead *pHead = pRpc->pCont;
-  dTrace("vgId:%d, msg:%p is created, type:%s", pHead->vgId, pMsg, TMSG_INFO(pRpc->msgType));
+  dTrace("vgId:%d, msg:%p is created, type:%s len:%d", pHead->vgId, pMsg, TMSG_INFO(pRpc->msgType), pRpc->contLen);
 
   pHead->contLen = htonl(pHead->contLen);
   pHead->vgId = htonl(pHead->vgId);

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

@@ -149,10 +149,13 @@ int32_t dmRunDnode(SDnode *pDnode) {
       return 0;
     }
 
-    if (count == 0) osUpdate();
+    if (count == 10) {
-
+      osUpdate();
-    count %= 10;
+      count = 0;
+    } else {
       count++;
+    }
+    
     taosMsleep(100);
   }
 }

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

@@ -141,11 +141,12 @@ static void dmProcessRpcMsg(SDnode *pDnode, SRpcMsg *pRpc, SEpSet *pEpSet) {
   }
 
   pRpc->info.wrapper = pWrapper;
-  pMsg = taosAllocateQitem(sizeof(SRpcMsg), RPC_QITEM);
+  pMsg = taosAllocateQitem(sizeof(SRpcMsg), RPC_QITEM, pRpc->contLen);
   if (pMsg == NULL) goto _OVER;
 
   memcpy(pMsg, pRpc, sizeof(SRpcMsg));
-  dGTrace("msg:%p, is created, type:%s handle:%p", pMsg, TMSG_INFO(pRpc->msgType), pMsg->info.handle);
+  dGTrace("msg:%p, is created, type:%s handle:%p len:%d", pMsg, TMSG_INFO(pRpc->msgType), pMsg->info.handle,
+          pRpc->contLen);
 
   code = dmProcessNodeMsg(pWrapper, pMsg);
 
@@ -258,8 +259,6 @@ int32_t dmInitClient(SDnode *pDnode) {
   rpcInit.rfp = rpcRfp;
   rpcInit.compressSize = tsCompressMsgSize;
 
-  rpcInit.retryLimit = tsRpcRetryLimit;
-  rpcInit.retryInterval = tsRpcRetryInterval;
   rpcInit.retryMinInterval = tsRedirectPeriod;
   rpcInit.retryStepFactor = tsRedirectFactor;
   rpcInit.retryMaxInterval = tsRedirectMaxPeriod;

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

@@ -88,7 +88,9 @@ typedef struct {
   int64_t       sync;
   int32_t       errCode;
   int32_t       transId;
-  SRWLatch lock;
+  int32_t       transSec;
+  int64_t       transSeq;
+  TdThreadMutex lock;
   int8_t        selfIndex;
   int8_t        numOfReplicas;
   SReplica      replicas[TSDB_MAX_REPLICA];

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

@@ -26,6 +26,7 @@ int32_t mndInitSync(SMnode *pMnode);
 void    mndCleanupSync(SMnode *pMnode);
 bool    mndIsLeader(SMnode *pMnode);
 int32_t mndSyncPropose(SMnode *pMnode, SSdbRaw *pRaw, int32_t transId);
+void    mndSyncCheckTimeout(SMnode *pMnode);
 void    mndSyncStart(SMnode *pMnode);
 void    mndSyncStop(SMnode *pMnode);
 

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

@@ -75,6 +75,7 @@ void    mndTransSetCb(STrans *pTrans, ETrnFunc startFunc, ETrnFunc stopFunc, voi
 void    mndTransSetDbName(STrans *pTrans, const char *dbname, const char *stbname);
 void    mndTransSetSerial(STrans *pTrans);
 void    mndTransSetOper(STrans *pTrans, EOperType oper);
+int32_t mndTrancCheckConflict(SMnode *pMnode, STrans *pTrans);
 
 int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans);
 int32_t mndTransProcessRsp(SRpcMsg *pRsp);

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

@@ -554,11 +554,6 @@ static int32_t mndProcessSubscribeReq(SRpcMsg *pMsg) {
       goto SUBSCRIBE_OVER;
     }
 
-    if (mndCheckDbPrivilegeByName(pMnode, pMsg->info.conn.user, MND_OPER_READ_DB, pTopic->db) != 0) {
-      mndReleaseTopic(pMnode, pTopic);
-      goto SUBSCRIBE_OVER;
-    }
-
     if (mndCheckTopicPrivilege(pMnode, pMsg->info.conn.user, MND_OPER_SUBSCRIBE, pTopic) != 0) {
       mndReleaseTopic(pMnode, pTopic);
       goto SUBSCRIBE_OVER;

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

@@ -776,6 +776,8 @@ static int32_t mndAlterDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pOld, SDbObj *p
 
   int32_t code = -1;
   mndTransSetDbName(pTrans, pOld->name, NULL);
+  if (mndTrancCheckConflict(pMnode, pTrans) != 0) return -1;
+
   if (mndSetAlterDbRedoLogs(pMnode, pTrans, pOld, pNew) != 0) goto _OVER;
   if (mndSetAlterDbCommitLogs(pMnode, pTrans, pOld, pNew) != 0) goto _OVER;
   if (mndSetAlterDbRedoActions(pMnode, pTrans, pOld, pNew) != 0) goto _OVER;
@@ -835,12 +837,14 @@ static int32_t mndProcessAlterDbReq(SRpcMsg *pReq) {
 
 _OVER:
   if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {
+    if (terrno != 0) code = terrno;
     mError("db:%s, failed to alter since %s", alterReq.db, terrstr());
   }
 
   mndReleaseDb(pMnode, pDb);
   taosArrayDestroy(dbObj.cfg.pRetensions);
 
+  terrno = code;
   return code;
 }
 
@@ -1183,7 +1187,8 @@ int32_t mndExtractDbInfo(SMnode *pMnode, SDbObj *pDb, SUseDbRsp *pRsp, const SUs
 
   int32_t numOfTable = mndGetDBTableNum(pDb, pMnode);
 
-  if (pReq == NULL || pReq->vgVersion < pDb->vgVersion || pReq->dbId != pDb->uid || numOfTable != pReq->numOfTable || pReq->stateTs < pDb->stateTs) {
+  if (pReq == NULL || pReq->vgVersion < pDb->vgVersion || pReq->dbId != pDb->uid || numOfTable != pReq->numOfTable ||
+      pReq->stateTs < pDb->stateTs) {
     mndBuildDBVgroupInfo(pDb, pMnode, pRsp->pVgroupInfos);
   }
 
@@ -1298,7 +1303,8 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbVgVersion *pDbs, int32_t numOfDbs,
 
     SUseDbRsp usedbRsp = {0};
 
-    if ((0 == strcasecmp(pDbVgVersion->dbFName, TSDB_INFORMATION_SCHEMA_DB) || (0 == strcasecmp(pDbVgVersion->dbFName, TSDB_PERFORMANCE_SCHEMA_DB)))) {
+    if ((0 == strcasecmp(pDbVgVersion->dbFName, TSDB_INFORMATION_SCHEMA_DB) ||
+         (0 == strcasecmp(pDbVgVersion->dbFName, TSDB_PERFORMANCE_SCHEMA_DB)))) {
       memcpy(usedbRsp.db, pDbVgVersion->dbFName, TSDB_DB_FNAME_LEN);
       int32_t vgVersion = mndGetGlobalVgroupVersion(pMnode);
       if (pDbVgVersion->vgVersion < vgVersion) {

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

@@ -672,6 +672,7 @@ static int32_t mndProcessCreateDnodeReq(SRpcMsg *pReq) {
   snprintf(ep, TSDB_EP_LEN, "%s:%d", createReq.fqdn, createReq.port);
   pDnode = mndAcquireDnodeByEp(pMnode, ep);
   if (pDnode != NULL) {
+    terrno = TSDB_CODE_MND_DNODE_ALREADY_EXIST;
     goto _OVER;
   }
 

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

@@ -101,6 +101,7 @@ static void *mndBuildCheckpointTickMsg(int32_t *pContLen, int64_t sec) {
 }
 
 static void mndPullupTrans(SMnode *pMnode) {
+  mTrace("pullup trans msg");
   int32_t contLen = 0;
   void   *pReq = mndBuildTimerMsg(&contLen);
   if (pReq != NULL) {
@@ -110,6 +111,7 @@ static void mndPullupTrans(SMnode *pMnode) {
 }
 
 static void mndPullupTtl(SMnode *pMnode) {
+  mTrace("pullup ttl");
   int32_t contLen = 0;
   void   *pReq = mndBuildTimerMsg(&contLen);
   SRpcMsg rpcMsg = {.msgType = TDMT_MND_TTL_TIMER, .pCont = pReq, .contLen = contLen};
@@ -117,6 +119,7 @@ static void mndPullupTtl(SMnode *pMnode) {
 }
 
 static void mndCalMqRebalance(SMnode *pMnode) {
+  mTrace("calc mq rebalance");
   int32_t contLen = 0;
   void   *pReq = mndBuildTimerMsg(&contLen);
   if (pReq != NULL) {
@@ -143,6 +146,7 @@ static void mndStreamCheckpointTick(SMnode *pMnode, int64_t sec) {
 }
 
 static void mndPullupTelem(SMnode *pMnode) {
+  mTrace("pullup telem msg");
   int32_t contLen = 0;
   void   *pReq = mndBuildTimerMsg(&contLen);
   if (pReq != NULL) {
@@ -152,6 +156,7 @@ static void mndPullupTelem(SMnode *pMnode) {
 }
 
 static void mndPullupGrant(SMnode *pMnode) {
+  mTrace("pullup grant msg");
   int32_t contLen = 0;
   void   *pReq = mndBuildTimerMsg(&contLen);
   if (pReq != NULL) {
@@ -162,6 +167,7 @@ static void mndPullupGrant(SMnode *pMnode) {
 }
 
 static void mndIncreaseUpTime(SMnode *pMnode) {
+  mTrace("increate uptime");
   int32_t contLen = 0;
   void   *pReq = mndBuildTimerMsg(&contLen);
   if (pReq != NULL) {
@@ -213,6 +219,9 @@ static void mndSetVgroupOffline(SMnode *pMnode, int32_t dnodeId, int64_t curMs)
 }
 
 static void mndCheckDnodeOffline(SMnode *pMnode) {
+  mTrace("check dnode offline");
+  if (mndAcquireRpc(pMnode) != 0) return;
+
   SSdb   *pSdb = pMnode->pSdb;
   int64_t curMs = taosGetTimestampMs();
 
@@ -230,6 +239,8 @@ static void mndCheckDnodeOffline(SMnode *pMnode) {
 
     sdbRelease(pSdb, pDnode);
   }
+
+  mndReleaseRpc(pMnode);
 }
 
 static void *mndThreadFp(void *param) {
@@ -277,6 +288,10 @@ static void *mndThreadFp(void *param) {
     if (sec % (tsStatusInterval * 5) == 0) {
       mndCheckDnodeOffline(pMnode);
     }
+
+    if (sec % (MNODE_TIMEOUT_SEC / 2) == 0) {
+      mndSyncCheckTimeout(pMnode);
+    }
   }
 
   return NULL;

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

@@ -769,7 +769,7 @@ static int32_t mndRetrieveQueries(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *p
     }
 
     int32_t numOfQueries = taosArrayGetSize(pConn->pQueries);
-    for (int32_t i = 0; i < numOfQueries; ++i) {
+    for (int32_t i = 0; i < numOfQueries && numOfRows < rows; ++i) {
       SQueryDesc *pQuery = taosArrayGet(pConn->pQueries, i);
       cols = 0;
 

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

@@ -78,35 +78,38 @@ int32_t mndProcessWriteMsg(const SSyncFSM *pFsm, SRpcMsg *pMsg, const SFsmCbMeta
   SSdbRaw   *pRaw = pMsg->pCont;
 
   int32_t transId = sdbGetIdFromRaw(pMnode->pSdb, pRaw);
-  pMgmt->errCode = pMeta->code;
   mInfo("trans:%d, is proposed, saved:%d code:0x%x, apply index:%" PRId64 " term:%" PRIu64 " config:%" PRId64
-        " role:%s raw:%p",
+        " role:%s raw:%p sec:%d seq:%" PRId64,
         transId, pMgmt->transId, pMeta->code, pMeta->index, pMeta->term, pMeta->lastConfigIndex, syncStr(pMeta->state),
-        pRaw);
+        pRaw, pMgmt->transSec, pMgmt->transSeq);
 
-  if (pMgmt->errCode == 0) {
+  if (pMeta->code == 0) {
     sdbWriteWithoutFree(pMnode->pSdb, pRaw);
     sdbSetApplyInfo(pMnode->pSdb, pMeta->index, pMeta->term, pMeta->lastConfigIndex);
   }
 
-  taosWLockLatch(&pMgmt->lock);
+  taosThreadMutexLock(&pMgmt->lock);
+  pMgmt->errCode = pMeta->code;
+
   if (transId <= 0) {
-    taosWUnLockLatch(&pMgmt->lock);
+    taosThreadMutexUnlock(&pMgmt->lock);
-    mError("trans:%d, invalid commit msg", transId);
+    mError("trans:%d, invalid commit msg, cache transId:%d seq:%" PRId64, transId, pMgmt->transId, pMgmt->transSeq);
   } else if (transId == pMgmt->transId) {
     if (pMgmt->errCode != 0) {
       mError("trans:%d, failed to propose since %s, post sem", transId, tstrerror(pMgmt->errCode));
     } else {
-      mInfo("trans:%d, is proposed and post sem", transId);
+      mInfo("trans:%d, is proposed and post sem, seq:%" PRId64, transId, pMgmt->transSeq);
     }
     pMgmt->transId = 0;
+    pMgmt->transSec = 0;
+    pMgmt->transSeq = 0;
     tsem_post(&pMgmt->syncSem);
-    taosWUnLockLatch(&pMgmt->lock);
+    taosThreadMutexUnlock(&pMgmt->lock);
   } else {
-    taosWUnLockLatch(&pMgmt->lock);
+    taosThreadMutexUnlock(&pMgmt->lock);
     STrans *pTrans = mndAcquireTrans(pMnode, transId);
     if (pTrans != NULL) {
-      mInfo("trans:%d, execute in mnode which not leader", transId);
+      mInfo("trans:%d, execute in mnode which not leader or sync timeout", transId);
       mndTransExecute(pMnode, pTrans);
       mndReleaseTrans(pMnode, pTrans);
       // sdbWriteFile(pMnode->pSdb, SDB_WRITE_DELTA);
@@ -149,9 +152,13 @@ void mndRestoreFinish(const SSyncFSM *pFsm) {
   SMnode *pMnode = pFsm->data;
 
   if (!pMnode->deploy) {
+    if (!pMnode->restored) {
       mInfo("vgId:1, sync restore finished, and will handle outstanding transactions");
       mndTransPullup(pMnode);
       mndSetRestored(pMnode, true);
+    } else {
+      mInfo("vgId:1, sync restore finished, repeat call");
+    }
   } else {
     mInfo("vgId:1, sync restore finished");
   }
@@ -195,17 +202,19 @@ int32_t mndSnapshotDoWrite(const SSyncFSM *pFsm, void *pWriter, void *pBuf, int3
 
 static void mndBecomeFollower(const SSyncFSM *pFsm) {
   SMnode    *pMnode = pFsm->data;
+  SSyncMgmt *pMgmt = &pMnode->syncMgmt;
   mInfo("vgId:1, become follower");
 
-  taosWLockLatch(&pMnode->syncMgmt.lock);
+  taosThreadMutexLock(&pMgmt->lock);
-  if (pMnode->syncMgmt.transId != 0) {
+  if (pMgmt->transId != 0) {
-    mInfo("vgId:1, become follower and post sem, trans:%d, failed to propose since not leader",
+    mInfo("vgId:1, become follower and post sem, trans:%d, failed to propose since not leader", pMgmt->transId);
-          pMnode->syncMgmt.transId);
+    pMgmt->transId = 0;
-    pMnode->syncMgmt.transId = 0;
+    pMgmt->transSec = 0;
-    pMnode->syncMgmt.errCode = TSDB_CODE_SYN_NOT_LEADER;
+    pMgmt->transSeq = 0;
-    tsem_post(&pMnode->syncMgmt.syncSem);
+    pMgmt->errCode = TSDB_CODE_SYN_NOT_LEADER;
+    tsem_post(&pMgmt->syncSem);
   }
-  taosWUnLockLatch(&pMnode->syncMgmt.lock);
+  taosThreadMutexUnlock(&pMgmt->lock);
 }
 
 static void mndBecomeLeader(const SSyncFSM *pFsm) {
@@ -261,8 +270,10 @@ SSyncFSM *mndSyncMakeFsm(SMnode *pMnode) {
 
 int32_t mndInitSync(SMnode *pMnode) {
   SSyncMgmt *pMgmt = &pMnode->syncMgmt;
-  taosInitRWLatch(&pMgmt->lock);
+  taosThreadMutexInit(&pMgmt->lock, NULL);
   pMgmt->transId = 0;
+  pMgmt->transSec = 0;
+  pMgmt->transSeq = 0;
 
   SSyncInfo syncInfo = {
       .snapshotStrategy = SYNC_STRATEGY_STANDARD_SNAPSHOT,
@@ -309,12 +320,38 @@ void mndCleanupSync(SMnode *pMnode) {
   mInfo("mnode-sync is stopped, id:%" PRId64, pMgmt->sync);
 
   tsem_destroy(&pMgmt->syncSem);
+  taosThreadMutexDestroy(&pMgmt->lock);
   memset(pMgmt, 0, sizeof(SSyncMgmt));
 }
 
+void mndSyncCheckTimeout(SMnode *pMnode) {
+  mTrace("check sync timeout");
+  SSyncMgmt *pMgmt = &pMnode->syncMgmt;
+  taosThreadMutexLock(&pMgmt->lock);
+  if (pMgmt->transId != 0) {
+    int32_t curSec = taosGetTimestampSec();
+    int32_t delta = curSec - pMgmt->transSec;
+    if (delta > MNODE_TIMEOUT_SEC) {
+      mError("trans:%d, failed to propose since timeout, start:%d cur:%d delta:%d seq:%" PRId64, pMgmt->transId,
+             pMgmt->transSec, curSec, delta, pMgmt->transSeq);
+      pMgmt->transId = 0;
+      pMgmt->transSec = 0;
+      pMgmt->transSeq = 0;
+      terrno = TSDB_CODE_SYN_TIMEOUT;
+      pMgmt->errCode = TSDB_CODE_SYN_TIMEOUT;
+      tsem_post(&pMgmt->syncSem);
+    } else {
+      mDebug("trans:%d, waiting for sync confirm, start:%d cur:%d delta:%d seq:%" PRId64, pMgmt->transId,
+             pMgmt->transSec, curSec, curSec - pMgmt->transSec, pMgmt->transSeq);
+    }
+  } else {
+    // mTrace("check sync timeout msg, no trans waiting for confirm");
+  }
+  taosThreadMutexUnlock(&pMgmt->lock);
+}
+
 int32_t mndSyncPropose(SMnode *pMnode, SSdbRaw *pRaw, int32_t transId) {
   SSyncMgmt *pMgmt = &pMnode->syncMgmt;
-  pMgmt->errCode = 0;
 
   SRpcMsg req = {.msgType = TDMT_MND_APPLY_MSG, .contLen = sdbGetRawTotalSize(pRaw)};
   if (req.contLen <= 0) return -1;
@@ -323,35 +360,42 @@ int32_t mndSyncPropose(SMnode *pMnode, SSdbRaw *pRaw, int32_t transId) {
   if (req.pCont == NULL) return -1;
   memcpy(req.pCont, pRaw, req.contLen);
 
-  taosWLockLatch(&pMgmt->lock);
+  taosThreadMutexLock(&pMgmt->lock);
+  pMgmt->errCode = 0;
+
   if (pMgmt->transId != 0) {
     mError("trans:%d, can't be proposed since trans:%d already waiting for confirm", transId, pMgmt->transId);
-    taosWUnLockLatch(&pMgmt->lock);
+    taosThreadMutexUnlock(&pMgmt->lock);
     terrno = TSDB_CODE_MND_LAST_TRANS_NOT_FINISHED;
-    return -1;
+    return terrno;
   }
 
   mInfo("trans:%d, will be proposed", transId);
   pMgmt->transId = transId;
-  taosWUnLockLatch(&pMgmt->lock);
+  pMgmt->transSec = taosGetTimestampSec();
 
-  int32_t code = syncPropose(pMgmt->sync, &req, false);
+  int64_t seq = 0;
+  int32_t code = syncPropose(pMgmt->sync, &req, false, &seq);
   if (code == 0) {
-    mInfo("trans:%d, is proposing and wait sem", pMgmt->transId);
+    mInfo("trans:%d, is proposing and wait sem, seq:%" PRId64, transId, seq);
+    pMgmt->transSeq = seq;
+    taosThreadMutexUnlock(&pMgmt->lock);
     tsem_wait(&pMgmt->syncSem);
   } else if (code > 0) {
     mInfo("trans:%d, confirm at once since replica is 1, continue execute", transId);
-    taosWLockLatch(&pMgmt->lock);
     pMgmt->transId = 0;
-    taosWUnLockLatch(&pMgmt->lock);
+    pMgmt->transSec = 0;
+    pMgmt->transSeq = 0;
+    taosThreadMutexUnlock(&pMgmt->lock);
     sdbWriteWithoutFree(pMnode->pSdb, pRaw);
     sdbSetApplyInfo(pMnode->pSdb, req.info.conn.applyIndex, req.info.conn.applyTerm, SYNC_INDEX_INVALID);
     code = 0;
   } else {
     mError("trans:%d, failed to proposed since %s", transId, terrstr());
-    taosWLockLatch(&pMgmt->lock);
     pMgmt->transId = 0;
-    taosWUnLockLatch(&pMgmt->lock);
+    pMgmt->transSec = 0;
+    pMgmt->transSeq = 0;
+    taosThreadMutexUnlock(&pMgmt->lock);
     if (terrno == 0) {
       terrno = TSDB_CODE_APP_ERROR;
     }
@@ -365,7 +409,7 @@ int32_t mndSyncPropose(SMnode *pMnode, SSdbRaw *pRaw, int32_t transId) {
   }
 
   terrno = pMgmt->errCode;
-  return pMgmt->errCode;
+  return terrno;
 }
 
 void mndSyncStart(SMnode *pMnode) {
@@ -378,13 +422,17 @@ void mndSyncStart(SMnode *pMnode) {
 }
 
 void mndSyncStop(SMnode *pMnode) {
-  taosWLockLatch(&pMnode->syncMgmt.lock);
+  SSyncMgmt *pMgmt = &pMnode->syncMgmt;
-  if (pMnode->syncMgmt.transId != 0) {
+
-    mInfo("vgId:1, is stopped and post sem, trans:%d", pMnode->syncMgmt.transId);
+  taosThreadMutexLock(&pMgmt->lock);
-    pMnode->syncMgmt.transId = 0;
+  if (pMgmt->transId != 0) {
-    tsem_post(&pMnode->syncMgmt.syncSem);
+    mInfo("vgId:1, is stopped and post sem, trans:%d", pMgmt->transId);
+    pMgmt->transId = 0;
+    pMgmt->transSec = 0;
+    pMgmt->errCode = TSDB_CODE_APP_IS_STOPPING;
+    tsem_post(&pMgmt->syncSem);
   }
-  taosWUnLockLatch(&pMnode->syncMgmt.lock);
+  taosThreadMutexUnlock(&pMgmt->lock);
 }
 
 bool mndIsLeader(SMnode *pMnode) {

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

@@ -838,7 +838,7 @@ static bool mndCheckTransConflict(SMnode *pMnode, STrans *pNew) {
   return conflict;
 }
 
-int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans) {
+int32_t mndTrancCheckConflict(SMnode *pMnode, STrans *pTrans) {
   if (pTrans->conflict == TRN_CONFLICT_DB || pTrans->conflict == TRN_CONFLICT_DB_INSIDE) {
     if (strlen(pTrans->dbname) == 0 && strlen(pTrans->stbname) == 0) {
       terrno = TSDB_CODE_MND_TRANS_CONFLICT;
@@ -853,6 +853,14 @@ int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans) {
     return -1;
   }
 
+  return 0;
+}
+
+int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans) {
+  if (mndTrancCheckConflict(pMnode, pTrans) != 0) {
+    return -1;
+  }
+
   if (taosArrayGetSize(pTrans->commitActions) <= 0) {
     terrno = TSDB_CODE_MND_TRANS_CLOG_IS_NULL;
     mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
@@ -1027,6 +1035,7 @@ int32_t mndTransProcessRsp(SRpcMsg *pRsp) {
   if (pAction != NULL) {
     pAction->msgReceived = 1;
     pAction->errCode = pRsp->code;
+    pTrans->lastErrorNo = pRsp->code;
   }
 
   mInfo("trans:%d, %s:%d response is received, code:0x%x, accept:0x%x retry:0x%x", transId, mndTransStr(pAction->stage),
@@ -1238,7 +1247,7 @@ static int32_t mndTransExecuteRedoActionsSerial(SMnode *pMnode, STrans *pTrans)
   if (numOfActions == 0) return code;
   if (pTrans->redoActionPos >= numOfActions) return code;
 
-  mInfo("trans:%d, execute %d actions serial", pTrans->id, numOfActions);
+  mInfo("trans:%d, execute %d actions serial, current redoAction:%d", pTrans->id, numOfActions, pTrans->redoActionPos);
 
   for (int32_t action = pTrans->redoActionPos; action < numOfActions; ++action) {
     STransAction *pAction = taosArrayGet(pTrans->redoActions, pTrans->redoActionPos);
@@ -1289,13 +1298,16 @@ static int32_t mndTransExecuteRedoActionsSerial(SMnode *pMnode, STrans *pTrans)
     } else if (code == TSDB_CODE_ACTION_IN_PROGRESS) {
       mInfo("trans:%d, %s:%d is in progress and wait it finish", pTrans->id, mndTransStr(pAction->stage), pAction->id);
       break;
-    } else if (code == pAction->retryCode) {
+    } else if (code == pAction->retryCode || code == TSDB_CODE_SYN_PROPOSE_NOT_READY ||
+               code == TSDB_CODE_SYN_RESTORING || code == TSDB_CODE_SYN_NOT_LEADER) {
       mInfo("trans:%d, %s:%d receive code:0x%x and retry", pTrans->id, mndTransStr(pAction->stage), pAction->id, code);
+      pTrans->lastErrorNo = code;
       taosMsleep(300);
       action--;
       continue;
     } else {
       terrno = code;
+      pTrans->lastErrorNo = code;
       pTrans->code = code;
       mInfo("trans:%d, %s:%d receive code:0x%x and wait another schedule, failedTimes:%d", pTrans->id,
             mndTransStr(pAction->stage), pAction->id, code, pTrans->failedTimes);

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

@@ -507,7 +507,7 @@ static int32_t mndGetAvailableDnode(SMnode *pMnode, SDbObj *pDb, SVgObj *pVgroup
   for (int32_t v = 0; v < pVgroup->replica; ++v) {
     SVnodeGid *pVgid = &pVgroup->vnodeGid[v];
     SDnodeObj *pDnode = taosArrayGet(pArray, v);
-    if (pDnode == NULL || pDnode->numOfVnodes > pDnode->numOfSupportVnodes) {
+    if (pDnode == NULL || pDnode->numOfVnodes >= pDnode->numOfSupportVnodes) {
       terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;
       return -1;
     }
@@ -891,7 +891,7 @@ static int32_t mndAddVnodeToVgroup(SMnode *pMnode, STrans *pTrans, SVgObj *pVgro
     }
     if (used) continue;
 
-    if (pDnode == NULL || pDnode->numOfVnodes > pDnode->numOfSupportVnodes) {
+    if (pDnode == NULL || pDnode->numOfVnodes >= pDnode->numOfSupportVnodes) {
       terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;
       return -1;
     }

source/dnode/vnode/inc/vnode.h

@@ -54,6 +54,7 @@ int32_t vnodeAlter(const char *path, SAlterVnodeReplicaReq *pReq, STfs *pTfs);
 void    vnodeDestroy(const char *path, STfs *pTfs);
 SVnode *vnodeOpen(const char *path, STfs *pTfs, SMsgCb msgCb);
 void    vnodePreClose(SVnode *pVnode);
+void    vnodeSyncCheckTimeout(SVnode* pVnode);
 void    vnodeClose(SVnode *pVnode);
 
 int32_t vnodeStart(SVnode *pVnode);

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

@@ -344,7 +344,12 @@ struct SVnode {
   bool          blocked;
   bool          restored;
   tsem_t        syncSem;
+  int32_t       blockSec;
+  int64_t       blockSeq;
   SQHandle*     pQuery;
+#if 0
+  SRpcHandleInfo blockInfo;
+#endif
 };
 
 #define TD_VID(PVNODE) ((PVNODE)->config.vgId)

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

@@ -132,7 +132,8 @@ int32_t metaCacheOpen(SMeta* pMeta) {
     goto _err2;
   }
 
-  pCache->sTagFilterResCache.pTableEntry = taosHashInit(1024, taosGetDefaultHashFunction(TSDB_DATA_TYPE_VARCHAR), false, HASH_NO_LOCK);
+  pCache->sTagFilterResCache.pTableEntry =
+      taosHashInit(1024, taosGetDefaultHashFunction(TSDB_DATA_TYPE_VARCHAR), false, HASH_NO_LOCK);
   if (pCache->sTagFilterResCache.pTableEntry == NULL) {
     code = TSDB_CODE_OUT_OF_MEMORY;
     goto _err2;
@@ -419,7 +420,8 @@ int32_t metaStatsCacheGet(SMeta* pMeta, int64_t uid, SMetaStbStats* pInfo) {
   return code;
 }
 
-int32_t metaGetCachedTableUidList(SMeta* pMeta, tb_uid_t suid, const uint8_t* pKey, int32_t keyLen, SArray* pList1, bool* acquireRes) {
+int32_t metaGetCachedTableUidList(SMeta* pMeta, tb_uid_t suid, const uint8_t* pKey, int32_t keyLen, SArray* pList1,
+                                  bool* acquireRes) {
   uint64_t* pBuf = pMeta->pCache->sTagFilterResCache.keyBuf;
 
   // generate the composed key for LRU cache
@@ -470,9 +472,12 @@ int32_t metaGetCachedTableUidList(SMeta* pMeta, tb_uid_t suid, const uint8_t* pK
       for (int32_t i = 0; i < s; ++i) {
         SListNode** p1 = taosArrayGet(pList, i);
         tdListPopNode(&(*pEntry)->list, *p1);
+        taosMemoryFree(*p1);
       }
 
       (*pEntry)->qTimes = 0;  // reset the query times
+
+      taosArrayDestroy(pList);
     }
   }
 
@@ -487,7 +492,8 @@ static void freePayload(const void* key, size_t keyLen, void* value) {
 }
 
 // check both the payload size and selectivity ratio
-int32_t metaUidFilterCachePut(SMeta* pMeta, uint64_t suid, const void* pKey, int32_t keyLen, void* pPayload, int32_t payloadLen, double selectivityRatio) {
+int32_t metaUidFilterCachePut(SMeta* pMeta, uint64_t suid, const void* pKey, int32_t keyLen, void* pPayload,
+                              int32_t payloadLen, double selectivityRatio) {
   if (selectivityRatio > tsSelectivityRatio) {
     metaDebug("vgId:%d, suid:%" PRIu64
               " failed to add to uid list cache, due to selectivity ratio %.2f less than threshold %.2f",
@@ -525,9 +531,10 @@ int32_t metaUidFilterCachePut(SMeta* pMeta, uint64_t suid, const void* pKey, int
   ASSERT(sizeof(uint64_t) + keyLen == 24);
 
   // add to cache.
-  taosLRUCacheInsert(pCache, pBuf, sizeof(uint64_t) + keyLen, pPayload, payloadLen, freePayload, NULL, TAOS_LRU_PRIORITY_LOW);
+  taosLRUCacheInsert(pCache, pBuf, sizeof(uint64_t) + keyLen, pPayload, payloadLen, freePayload, NULL,
-  metaDebug("vgId:%d, suid:%"PRIu64" list cache added into cache, total:%d, tables:%d", TD_VID(pMeta->pVnode),
+                     TAOS_LRU_PRIORITY_LOW);
-            suid, (int32_t) taosLRUCacheGetUsage(pCache), taosHashGetSize(pTableEntry));
+  metaDebug("vgId:%d, suid:%" PRIu64 " list cache added into cache, total:%d, tables:%d", TD_VID(pMeta->pVnode), suid,
+            (int32_t)taosLRUCacheGetUsage(pCache), taosHashGetSize(pTableEntry));
 
   return TSDB_CODE_SUCCESS;
 }

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

@@ -549,8 +549,8 @@ int metaTtlDropTable(SMeta *pMeta, int64_t ttl, SArray *tbUids) {
 }
 
 static void metaBuildTtlIdxKey(STtlIdxKey *ttlKey, const SMetaEntry *pME) {
-  int64_t ttlDays;
+  int64_t ttlDays = 0;
-  int64_t ctime;
+  int64_t ctime = 0;
   if (pME->type == TSDB_CHILD_TABLE) {
     ctime = pME->ctbEntry.ctime;
     ttlDays = pME->ctbEntry.ttlDays;
@@ -1353,6 +1353,10 @@ static int metaUpdateTagIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry) {
     goto end;
   }
 
+  if (stbEntry.stbEntry.schemaTag.pSchema == NULL) {
+    goto end;
+  }
+
   pTagColumn = &stbEntry.stbEntry.schemaTag.pSchema[0];
 
   STagVal tagVal = {.cid = pTagColumn->colId};

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

@@ -763,7 +763,7 @@ static int32_t tdExecuteRSmaImplAsync(SSma *pSma, const void *pMsg, int32_t inpu
                                       tb_uid_t suid) {
   const SSubmitReq *pReq = (const SSubmitReq *)pMsg;
 
-  void *qItem = taosAllocateQitem(pReq->header.contLen, DEF_QITEM);
+  void *qItem = taosAllocateQitem(pReq->header.contLen, DEF_QITEM, 0);
   if (!qItem) {
     return TSDB_CODE_FAILED;
   }

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

@@ -1271,7 +1271,7 @@ int32_t tqProcessDelReq(STQ* pTq, void* pReq, int32_t len, int64_t ver) {
     qDebug("delete req enqueue stream task: %d, ver: %" PRId64, pTask->taskId, ver);
 
     if (!failed) {
-      SStreamRefDataBlock* pRefBlock = taosAllocateQitem(sizeof(SStreamRefDataBlock), DEF_QITEM);
+      SStreamRefDataBlock* pRefBlock = taosAllocateQitem(sizeof(SStreamRefDataBlock), DEF_QITEM, 0);
       pRefBlock->type = STREAM_INPUT__REF_DATA_BLOCK;
       pRefBlock->pBlock = pDelBlock;
       pRefBlock->dataRef = pRef;
@@ -1303,7 +1303,7 @@ int32_t tqProcessDelReq(STQ* pTq, void* pReq, int32_t len, int64_t ver) {
   }
 
 #if 0
-    SStreamDataBlock* pStreamBlock = taosAllocateQitem(sizeof(SStreamDataBlock), DEF_QITEM);
+    SStreamDataBlock* pStreamBlock = taosAllocateQitem(sizeof(SStreamDataBlock), DEF_QITEM, 0);
     pStreamBlock->type = STREAM_INPUT__DATA_BLOCK;
     pStreamBlock->blocks = taosArrayInit(0, sizeof(SSDataBlock));
     SSDataBlock block = {0};

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

@@ -533,6 +533,7 @@ int32_t tqRetrieveDataBlock(SSDataBlock* pBlock, STqReader* pReader) {
   pBlock->info.id.uid = pReader->msgIter.uid;
   pBlock->info.rows = pReader->msgIter.numOfRows;
   pBlock->info.version = pReader->pMsg->version;
+  pBlock->info.dataLoad = 1;
 
   while ((row = tGetSubmitBlkNext(&pReader->blkIter)) != NULL) {
     tdSTSRowIterReset(&iter, row);

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

@@ -952,12 +952,17 @@ static int32_t nextRowIterOpen(CacheNextRowIter *pIter, tb_uid_t uid, STsdb *pTs
     SArray *pDelIdxArray = taosArrayInit(32, sizeof(SDelIdx));
 
     code = tsdbReadDelIdx(pDelFReader, pDelIdxArray);
-    if (code) goto _err;
+    if (code) {
+      taosArrayDestroy(pDelIdxArray);
+      tsdbDelFReaderClose(&pDelFReader);
+      goto _err;
+    }
 
     SDelIdx *delIdx = taosArraySearch(pDelIdxArray, &(SDelIdx){.suid = suid, .uid = uid}, tCmprDelIdx, TD_EQ);
 
     code = getTableDelSkyline(pMem, pIMem, pDelFReader, delIdx, pIter->pSkyline);
     if (code) {
+      taosArrayDestroy(pDelIdxArray);
       tsdbDelFReaderClose(&pDelFReader);
       goto _err;
     }

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

@@ -962,6 +962,7 @@ int32_t tsdbFSUpsertFSet(STsdbFS *pFS, SDFileSet *pSet) {
         }
       }
 
+      pDFileSet->diskId = pSet->diskId;
       goto _exit;
     }
   }

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

@@ -121,7 +121,7 @@ static SBlockData *loadLastBlock(SLDataIter *pIter, const char *idStr) {
     return &pInfo->blockData[1];
   }
 
-  if (pIter->pSttBlk == NULL) {
+  if (pIter->pSttBlk == NULL || pInfo->pSchema == NULL) {
     return NULL;
   }
 

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

@@ -1143,6 +1143,7 @@ static int32_t copyBlockDataToSDataBlock(STsdbReader* pReader, STableBlockScanIn
     i += 1;
   }
 
+  pResBlock->info.dataLoad = 1;
   pResBlock->info.rows = dumpedRows;
   pDumpInfo->rowIndex += step * dumpedRows;
 
@@ -2538,6 +2539,7 @@ static int32_t buildComposedDataBlock(STsdbReader* pReader) {
 
 _end:
   pResBlock->info.id.uid = (pBlockScanInfo != NULL) ? pBlockScanInfo->uid : 0;
+  pResBlock->info.dataLoad = 1;
   blockDataUpdateTsWindow(pResBlock, pReader->suppInfo.slotId[0]);
 
   setComposedBlockFlag(pReader, true);
@@ -2790,6 +2792,7 @@ static int32_t doLoadLastBlockSequentially(STsdbReader* pReader) {
   while (1) {
     // load the last data block of current table
     STableBlockScanInfo* pScanInfo = *(STableBlockScanInfo**)pStatus->pTableIter;
+
     bool hasVal = initLastBlockReader(pLastBlockReader, pScanInfo, pReader);
     if (!hasVal) {
       bool hasNexTable = moveToNextTable(pOrderedCheckInfo, pStatus);
@@ -3129,7 +3132,7 @@ bool hasBeenDropped(const SArray* pDelList, int32_t* index, TSDBKEY* pKey, int32
         return false;
       } else if (pKey->ts == last->ts) {
         TSDBKEY* prev = taosArrayGet(pDelList, num - 2);
-        return (prev->version >= pKey->version);
+        return (prev->version >= pKey->version && prev->version <= pVerRange->maxVer && prev->version >= pVerRange->minVer);
       }
     } else {
       TSDBKEY* pCurrent = taosArrayGet(pDelList, *index);
@@ -3621,6 +3624,7 @@ int32_t doAppendRowFromTSRow(SSDataBlock* pBlock, STsdbReader* pReader, STSRow*
     i += 1;
   }
 
+  pBlock->info.dataLoad = 1;
   pBlock->info.rows += 1;
   pScanInfo->lastKey = pTSRow->ts;
   return TSDB_CODE_SUCCESS;
@@ -3668,6 +3672,7 @@ int32_t doAppendRowFromFileBlock(SSDataBlock* pResBlock, STsdbReader* pReader, S
     i += 1;
   }
 
+  pResBlock->info.dataLoad = 1;
   pResBlock->info.rows += 1;
   return TSDB_CODE_SUCCESS;
 }
@@ -3823,6 +3828,8 @@ int32_t tsdbReaderOpen(SVnode* pVnode, SQueryTableDataCond* pCond, void* pTableL
   }
 
   // NOTE: the endVersion in pCond is the data version not schema version, so pCond->endVersion is not correct here.
+  //  no valid error code set in metaGetTbTSchema, so let's set the error code here.
+  //  we should proceed in case of tmq processing.
   if (pCond->suid != 0) {
     pReader->pSchema = metaGetTbTSchema(pReader->pTsdb->pVnode->pMeta, pReader->suid, -1, 1);
     if (pReader->pSchema == NULL) {
@@ -3890,6 +3897,7 @@ int32_t tsdbReaderOpen(SVnode* pVnode, SQueryTableDataCond* pCond, void* pTableL
 
 _err:
   tsdbError("failed to create data reader, code:%s %s", tstrerror(code), idstr);
+  tsdbReaderClose(pReader);
   return code;
 }
 

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

@@ -155,7 +155,7 @@ static int32_t tsdbSnapReadOpenFile(STsdbSnapReader* pReader) {
 
         if (rowVer >= pReader->sver && rowVer <= pReader->ever) {
           pIter->rInfo.suid = pIter->bData.suid;
-          pIter->rInfo.uid = pIter->bData.uid;
+          pIter->rInfo.uid = pIter->bData.uid ? pIter->bData.uid : pIter->bData.aUid[pIter->iRow];
           pIter->rInfo.row = tsdbRowFromBlockData(&pIter->bData, pIter->iRow);
           goto _add_iter;
         }
@@ -179,16 +179,14 @@ _err:
   return code;
 }
 
-static SRowInfo* tsdbSnapGetRow(STsdbSnapReader* pReader) { return pReader->pIter ? &pReader->pIter->rInfo : NULL; }
-
 static int32_t tsdbSnapNextRow(STsdbSnapReader* pReader) {
   int32_t code = 0;
 
   if (pReader->pIter) {
-    SFDataIter* pIter = pReader->pIter;
+    SFDataIter* pIter = NULL;
-
     while (true) {
     _find_row:
+      pIter = pReader->pIter;
       for (pIter->iRow++; pIter->iRow < pIter->bData.nRow; pIter->iRow++) {
         int64_t rowVer = pIter->bData.aVersion[pIter->iRow];
 
@@ -224,6 +222,7 @@ static int32_t tsdbSnapNextRow(STsdbSnapReader* pReader) {
         }
 
         pReader->pIter = NULL;
+        break;
       } else if (pIter->type == SNAP_STT_FILE_ITER) {
         for (pIter->iSttBlk++; pIter->iSttBlk < taosArrayGetSize(pIter->aSttBlk); pIter->iSttBlk++) {
           SSttBlk* pSttBlk = (SSttBlk*)taosArrayGet(pIter->aSttBlk, pIter->iSttBlk);
@@ -238,6 +237,7 @@ static int32_t tsdbSnapNextRow(STsdbSnapReader* pReader) {
         }
 
         pReader->pIter = NULL;
+        break;
       } else {
         ASSERT(0);
       }
@@ -269,6 +269,20 @@ _err:
   return code;
 }
 
+static SRowInfo* tsdbSnapGetRow(STsdbSnapReader* pReader) {
+  if (pReader->pIter) {
+    return &pReader->pIter->rInfo;
+  } else {
+    tsdbSnapNextRow(pReader);
+
+    if (pReader->pIter) {
+      return &pReader->pIter->rInfo;
+    } else {
+      return NULL;
+    }
+  }
+}
+
 static int32_t tsdbSnapCmprData(STsdbSnapReader* pReader, uint8_t** ppData) {
   int32_t code = 0;
 
@@ -1356,7 +1370,7 @@ _exit:
       taosMemoryFree(pWriter);
     }
   } else {
-    tsdbDebug("vgId:%d, tsdb snapshot writer open for %s succeed", TD_VID(pTsdb->pVnode), pTsdb->path);
+    tsdbInfo("vgId:%d %s done", TD_VID(pTsdb->pVnode), __func__);
     *ppWriter = pWriter;
   }
   return code;
@@ -1421,7 +1435,7 @@ int32_t tsdbSnapWriterClose(STsdbSnapWriter** ppWriter, int8_t rollback) {
   for (int32_t iBuf = 0; iBuf < sizeof(pWriter->aBuf) / sizeof(uint8_t*); iBuf++) {
     tFree(pWriter->aBuf[iBuf]);
   }
-  tsdbInfo("vgId:%d, vnode snapshot tsdb writer close for %s", TD_VID(pWriter->pTsdb->pVnode), pWriter->pTsdb->path);
+  tsdbInfo("vgId:%d %s done", TD_VID(pWriter->pTsdb->pVnode), __func__);
   taosMemoryFree(pWriter);
   *ppWriter = NULL;
   return code;

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

@@ -22,32 +22,21 @@ static inline bool vnodeIsMsgWeak(tmsg_t type) { return false; }
 
 static inline void vnodeWaitBlockMsg(SVnode *pVnode, const SRpcMsg *pMsg) {
   const STraceId *trace = &pMsg->info.traceId;
-  vGTrace("vgId:%d, msg:%p wait block, type:%s", pVnode->config.vgId, pMsg, TMSG_INFO(pMsg->msgType));
+  vGTrace("vgId:%d, msg:%p wait block, type:%s sec:%d seq:%" PRId64, pVnode->config.vgId, pMsg,
+          TMSG_INFO(pMsg->msgType), pVnode->blockSec, pVnode->blockSeq);
   tsem_wait(&pVnode->syncSem);
 }
 
-static inline void vnodeWaitBlockMsgOld(SVnode *pVnode, const SRpcMsg *pMsg) {
-  if (vnodeIsMsgBlock(pMsg->msgType)) {
-    const STraceId *trace = &pMsg->info.traceId;
-    taosThreadMutexLock(&pVnode->lock);
-    if (!pVnode->blocked) {
-      vGTrace("vgId:%d, msg:%p wait block, type:%s", pVnode->config.vgId, pMsg, TMSG_INFO(pMsg->msgType));
-      pVnode->blocked = true;
-      taosThreadMutexUnlock(&pVnode->lock);
-      tsem_wait(&pVnode->syncSem);
-    } else {
-      taosThreadMutexUnlock(&pVnode->lock);
-    }
-  }
-}
-
 static inline void vnodePostBlockMsg(SVnode *pVnode, const SRpcMsg *pMsg) {
   if (vnodeIsMsgBlock(pMsg->msgType)) {
     const STraceId *trace = &pMsg->info.traceId;
     taosThreadMutexLock(&pVnode->lock);
     if (pVnode->blocked) {
-      vGTrace("vgId:%d, msg:%p post block, type:%s", pVnode->config.vgId, pMsg, TMSG_INFO(pMsg->msgType));
+      vGTrace("vgId:%d, msg:%p post block, type:%s sec:%d seq:%" PRId64, pVnode->config.vgId, pMsg,
+              TMSG_INFO(pMsg->msgType), pVnode->blockSec, pVnode->blockSeq);
       pVnode->blocked = false;
+      pVnode->blockSec = 0;
+      pVnode->blockSeq = 0;
       tsem_post(&pVnode->syncSem);
     }
     taosThreadMutexUnlock(&pVnode->lock);
@@ -217,12 +206,19 @@ void vnodeProposeWriteMsg(SQueueInfo *pInfo, STaosQall *qall, int32_t numOfMsgs)
 #else
 
 static int32_t inline vnodeProposeMsg(SVnode *pVnode, SRpcMsg *pMsg, bool isWeak) {
+  int64_t seq = 0;
+
   taosThreadMutexLock(&pVnode->lock);
-  int32_t code = syncPropose(pVnode->sync, pMsg, isWeak);
+  int32_t code = syncPropose(pVnode->sync, pMsg, isWeak, &seq);
   bool    wait = (code == 0 && vnodeIsMsgBlock(pMsg->msgType));
   if (wait) {
     ASSERT(!pVnode->blocked);
     pVnode->blocked = true;
+    pVnode->blockSec = taosGetTimestampSec();
+    pVnode->blockSeq = seq;
+#if 0
+    pVnode->blockInfo = pMsg->info;
+#endif
   }
   taosThreadMutexUnlock(&pVnode->lock);
 
@@ -289,12 +285,15 @@ void vnodeApplyWriteMsg(SQueueInfo *pInfo, STaosQall *qall, int32_t numOfMsgs) {
   for (int32_t i = 0; i < numOfMsgs; ++i) {
     if (taosGetQitem(qall, (void **)&pMsg) == 0) continue;
     const STraceId *trace = &pMsg->info.traceId;
-    vGTrace("vgId:%d, msg:%p get from vnode-apply queue, type:%s handle:%p index:%" PRId64, vgId, pMsg,
-            TMSG_INFO(pMsg->msgType), pMsg->info.handle, pMsg->info.conn.applyIndex);
 
     if (vnodeIsMsgBlock(pMsg->msgType)) {
-      vTrace("vgId:%d, blocking msg obtained from apply-queue. index:%" PRId64 ", term: %" PRId64 ", type: %s", vgId,
+      vGTrace("vgId:%d, msg:%p get from vnode-apply queue, type:%s handle:%p index:%" PRId64
-             pMsg->info.conn.applyIndex, pMsg->info.conn.applyTerm, TMSG_INFO(pMsg->msgType));
+              ", blocking msg obtained sec:%d seq:%" PRId64,
+              vgId, pMsg, TMSG_INFO(pMsg->msgType), pMsg->info.handle, pMsg->info.conn.applyIndex, pVnode->blockSec,
+              pVnode->blockSeq);
+    } else {
+      vGTrace("vgId:%d, msg:%p get from vnode-apply queue, type:%s handle:%p index:%" PRId64, vgId, pMsg,
+              TMSG_INFO(pMsg->msgType), pMsg->info.handle, pMsg->info.conn.applyIndex);
     }
 
     SRpcMsg rsp = {.code = pMsg->code, .info = pMsg->info};
@@ -621,6 +620,32 @@ void vnodeSyncClose(SVnode *pVnode) {
   syncStop(pVnode->sync);
 }
 
+void vnodeSyncCheckTimeout(SVnode *pVnode) {
+  vTrace("vgId:%d, check sync timeout msg", pVnode->config.vgId);
+  taosThreadMutexLock(&pVnode->lock);
+  if (pVnode->blocked) {
+    int32_t curSec = taosGetTimestampSec();
+    int32_t delta = curSec - pVnode->blockSec;
+    if (delta > VNODE_TIMEOUT_SEC) {
+      vError("vgId:%d, failed to propose since timeout and post block, start:%d cur:%d delta:%d seq:%" PRId64,
+             pVnode->config.vgId, pVnode->blockSec, curSec, delta, pVnode->blockSeq);
+      if (syncSendTimeoutRsp(pVnode->sync, pVnode->blockSeq) != 0) {
+#if 0  
+        SRpcMsg rpcMsg = {.code = TSDB_CODE_SYN_TIMEOUT, .info = pVnode->blockInfo};
+        vError("send timeout response since its applyed, seq:%" PRId64 " handle:%p ahandle:%p", pVnode->blockSeq,
+              rpcMsg.info.handle, rpcMsg.info.ahandle);
+        rpcSendResponse(&rpcMsg);
+#endif
+      }
+      pVnode->blocked = false;
+      pVnode->blockSec = 0;
+      pVnode->blockSeq = 0;
+      tsem_post(&pVnode->syncSem);
+    }
+  }
+  taosThreadMutexUnlock(&pVnode->lock);
+}
+
 bool vnodeIsRoleLeader(SVnode *pVnode) {
   SSyncState state = syncGetState(pVnode->sync);
   return state.state == TAOS_SYNC_STATE_LEADER;

source/libs/catalog/inc/catalogInt.h

@@ -798,6 +798,9 @@ SName*  ctgGetFetchName(SArray* pNames, SCtgFetch* pFetch);
 int32_t ctgdGetOneHandle(SCatalog **pHandle);
 int     ctgVgInfoComp(const void* lp, const void* rp);
 int32_t ctgMakeVgArray(SDBVgInfo* dbInfo);
+int32_t ctgAcquireVgMetaFromCache(SCatalog *pCtg, const char *dbFName, const char *tbName, SCtgDBCache **pDb, SCtgTbCache **pTb);
+int32_t ctgCopyTbMeta(SCatalog *pCtg, SCtgTbMetaCtx *ctx, SCtgDBCache **pDb, SCtgTbCache **pTb, STableMeta **pTableMeta, char* dbFName);
+void    ctgReleaseVgMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, SCtgTbCache *pCache);
 
 extern SCatalogMgmt gCtgMgmt;
 extern SCtgDebug    gCTGDebug;

source/libs/catalog/src/catalog.c

@@ -551,6 +551,35 @@ _return:
   CTG_RET(code);
 }
 
+int32_t ctgGetCachedTbVgMeta(SCatalog* pCtg, const SName* pTableName, SVgroupInfo* pVgroup, STableMeta** pTableMeta) {
+  int32_t      code = 0;
+  char         db[TSDB_DB_FNAME_LEN] = {0};
+  tNameGetFullDbName(pTableName, db);
+  SCtgDBCache *dbCache = NULL;
+  SCtgTbCache *tbCache = NULL;
+
+  CTG_ERR_RET(ctgAcquireVgMetaFromCache(pCtg, db, pTableName->tname, &dbCache, &tbCache));
+
+  if (NULL == dbCache || NULL == tbCache) {
+    *pTableMeta = NULL;
+    return TSDB_CODE_SUCCESS;
+  }
+
+  CTG_ERR_JRET(ctgGetVgInfoFromHashValue(pCtg, dbCache->vgCache.vgInfo, pTableName, pVgroup));
+
+  SCtgTbMetaCtx ctx = {0};
+  ctx.pName = (SName*)pTableName;
+  ctx.flag = CTG_FLAG_UNKNOWN_STB;
+  CTG_ERR_JRET(ctgCopyTbMeta(pCtg, &ctx, &dbCache, &tbCache, pTableMeta, db));
+
+_return:
+  
+  ctgReleaseVgMetaToCache(pCtg, dbCache, tbCache);
+
+  CTG_RET(code);
+}
+
+
 int32_t ctgRemoveTbMeta(SCatalog* pCtg, SName* pTableName) {
   int32_t code = 0;
 
@@ -1118,6 +1147,13 @@ int32_t catalogGetCachedTableHashVgroup(SCatalog* pCtg, const SName* pTableName,
   CTG_API_LEAVE(ctgGetTbHashVgroup(pCtg, NULL, pTableName, pVgroup, exists));
 }
 
+int32_t catalogGetCachedTableVgMeta(SCatalog* pCtg, const SName* pTableName,          SVgroupInfo* pVgroup, STableMeta** pTableMeta) {
+  CTG_API_ENTER();
+
+  CTG_API_LEAVE(ctgGetCachedTbVgMeta(pCtg, pTableName, pVgroup, pTableMeta));
+}
+
+
 #if 0
 int32_t catalogGetAllMeta(SCatalog* pCtg, SRequestConnInfo* pConn, const SCatalogReq* pReq, SMetaData* pRsp) {
   CTG_API_ENTER();

source/libs/catalog/src/ctgCache.c

@@ -130,7 +130,7 @@ void ctgReleaseVgInfoToCache(SCatalog *pCtg, SCtgDBCache *dbCache) {
 }
 
 void ctgReleaseTbMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, SCtgTbCache *pCache) {
-  if (pCache) {
+  if (pCache && dbCache) {
     CTG_UNLOCK(CTG_READ, &pCache->metaLock);
     taosHashRelease(dbCache->tbCache, pCache);
   }
@@ -151,6 +151,18 @@ void ctgReleaseTbIndexToCache(SCatalog *pCtg, SCtgDBCache *dbCache, SCtgTbCache
   }
 }
 
+void ctgReleaseVgMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, SCtgTbCache *pCache) {
+  if (pCache && dbCache) {
+    CTG_UNLOCK(CTG_READ, &pCache->metaLock);
+    taosHashRelease(dbCache->tbCache, pCache);
+  }
+
+  if (dbCache) {
+    ctgRUnlockVgInfo(dbCache);
+    ctgReleaseDBCache(pCtg, dbCache);
+  }
+}
+
 int32_t ctgAcquireVgInfoFromCache(SCatalog *pCtg, const char *dbFName, SCtgDBCache **pCache) {
   SCtgDBCache *dbCache = NULL;
   ctgAcquireDBCache(pCtg, dbFName, &dbCache);
@@ -226,6 +238,75 @@ _return:
   return TSDB_CODE_SUCCESS;
 }
 
+int32_t ctgAcquireVgMetaFromCache(SCatalog *pCtg, const char *dbFName, const char *tbName, SCtgDBCache **pDb, SCtgTbCache **pTb) {
+  SCtgDBCache *dbCache = NULL;
+  SCtgTbCache *tbCache = NULL;
+  bool vgInCache = false;
+
+  ctgAcquireDBCache(pCtg, dbFName, &dbCache);
+  if (NULL == dbCache) {
+    ctgDebug("db %s not in cache", dbFName);
+    CTG_CACHE_STAT_INC(numOfVgMiss, 1);
+    goto _return;
+  }
+
+  ctgRLockVgInfo(pCtg, dbCache, &vgInCache);
+  if (!vgInCache) {
+    ctgDebug("vgInfo of db %s not in cache", dbFName);
+    CTG_CACHE_STAT_INC(numOfVgMiss, 1);
+    goto _return;
+  }
+
+  *pDb = dbCache;
+
+  CTG_CACHE_STAT_INC(numOfVgHit, 1);
+
+  ctgDebug("Got db vgInfo from cache, dbFName:%s", dbFName);
+
+  tbCache = taosHashAcquire(dbCache->tbCache, tbName, strlen(tbName));
+  if (NULL == tbCache) {
+    ctgDebug("tb %s not in cache, dbFName:%s", tbName, dbFName);
+    CTG_CACHE_STAT_INC(numOfMetaMiss, 1);
+    goto _return;
+  }
+
+  CTG_LOCK(CTG_READ, &tbCache->metaLock);
+  if (NULL == tbCache->pMeta) {
+    ctgDebug("tb %s meta not in cache, dbFName:%s", tbName, dbFName);
+    CTG_CACHE_STAT_INC(numOfMetaMiss, 1);
+    goto _return;
+  }
+
+  *pTb = tbCache;
+
+  ctgDebug("tb %s meta got in cache, dbFName:%s", tbName, dbFName);
+
+  CTG_CACHE_STAT_INC(numOfMetaHit, 1);
+
+  return TSDB_CODE_SUCCESS;
+
+_return:
+
+  if (tbCache) {
+    CTG_UNLOCK(CTG_READ, &tbCache->metaLock);
+    taosHashRelease(dbCache->tbCache, tbCache);
+  }
+
+  if (vgInCache) {
+    ctgRUnlockVgInfo(dbCache);
+  }
+
+  if (dbCache) {
+    ctgReleaseDBCache(pCtg, dbCache);
+  }
+
+  *pDb = NULL;
+  *pTb = NULL;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
 /*
 int32_t ctgAcquireStbMetaFromCache(SCatalog *pCtg, char *dbFName, uint64_t suid, SCtgDBCache **pDb, SCtgTbCache **pTb) {
   SCtgDBCache *dbCache = NULL;
@@ -378,6 +459,78 @@ int32_t ctgTbMetaExistInCache(SCatalog *pCtg, char *dbFName, char *tbName, int32
   return TSDB_CODE_SUCCESS;
 }
 
+int32_t ctgCopyTbMeta(SCatalog *pCtg, SCtgTbMetaCtx *ctx, SCtgDBCache **pDb, SCtgTbCache **pTb, STableMeta **pTableMeta, char* dbFName) {
+  SCtgDBCache *dbCache = *pDb;
+  SCtgTbCache *tbCache = *pTb;
+  STableMeta *tbMeta = tbCache->pMeta;
+  ctx->tbInfo.inCache = true;
+  ctx->tbInfo.dbId = dbCache->dbId;
+  ctx->tbInfo.suid = tbMeta->suid;
+  ctx->tbInfo.tbType = tbMeta->tableType;
+
+  if (tbMeta->tableType != TSDB_CHILD_TABLE) {
+    int32_t metaSize = CTG_META_SIZE(tbMeta);
+    *pTableMeta = taosMemoryCalloc(1, metaSize);
+    if (NULL == *pTableMeta) {
+      CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
+    }
+
+    memcpy(*pTableMeta, tbMeta, metaSize);
+
+    ctgDebug("Got tb %s meta from cache, type:%d, dbFName:%s", ctx->pName->tname, tbMeta->tableType, dbFName);
+    return TSDB_CODE_SUCCESS;
+  }
+
+  // PROCESS FOR CHILD TABLE
+
+  int32_t metaSize = sizeof(SCTableMeta);
+  *pTableMeta = taosMemoryCalloc(1, metaSize);
+  if (NULL == *pTableMeta) {
+    CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
+  }
+
+  memcpy(*pTableMeta, tbMeta, metaSize);
+
+  //ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache);
+
+  if (tbCache) {
+    CTG_UNLOCK(CTG_READ, &tbCache->metaLock);
+    taosHashRelease(dbCache->tbCache, tbCache);
+    *pTb = NULL;
+  }
+  
+  ctgDebug("Got ctb %s meta from cache, will continue to get its stb meta, type:%d, dbFName:%s", ctx->pName->tname,
+           ctx->tbInfo.tbType, dbFName);
+
+  ctgAcquireStbMetaFromCache(dbCache, pCtg, dbFName, ctx->tbInfo.suid, &tbCache);
+  if (NULL == tbCache) {
+    taosMemoryFreeClear(*pTableMeta);
+    *pDb = NULL;
+    ctgDebug("stb 0x%" PRIx64 " meta not in cache", ctx->tbInfo.suid);
+    return TSDB_CODE_SUCCESS;
+  }
+
+  *pTb = tbCache;
+
+  STableMeta *stbMeta = tbCache->pMeta;
+  if (stbMeta->suid != ctx->tbInfo.suid) {
+    ctgError("stb suid 0x%" PRIx64 " in stbCache mis-match, expected suid 0x%" PRIx64, stbMeta->suid, ctx->tbInfo.suid);
+    taosMemoryFreeClear(*pTableMeta);
+    CTG_ERR_RET(TSDB_CODE_CTG_INTERNAL_ERROR);
+  }
+
+  metaSize = CTG_META_SIZE(stbMeta);
+  *pTableMeta = taosMemoryRealloc(*pTableMeta, metaSize);
+  if (NULL == *pTableMeta) {
+    CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
+  }
+
+  memcpy(&(*pTableMeta)->sversion, &stbMeta->sversion, metaSize - sizeof(SCTableMeta));
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
 int32_t ctgReadTbMetaFromCache(SCatalog *pCtg, SCtgTbMetaCtx *ctx, STableMeta **pTableMeta) {
   int32_t      code = 0;
   SCtgDBCache *dbCache = NULL;
@@ -397,70 +550,7 @@ int32_t ctgReadTbMetaFromCache(SCatalog *pCtg, SCtgTbMetaCtx *ctx, STableMeta **
     return TSDB_CODE_SUCCESS;
   }
 
-  STableMeta *tbMeta = tbCache->pMeta;
+  CTG_ERR_JRET(ctgCopyTbMeta(pCtg, ctx, &dbCache, &tbCache, pTableMeta, dbFName));
-  ctx->tbInfo.inCache = true;
-  ctx->tbInfo.dbId = dbCache->dbId;
-  ctx->tbInfo.suid = tbMeta->suid;
-  ctx->tbInfo.tbType = tbMeta->tableType;
-
-  if (tbMeta->tableType != TSDB_CHILD_TABLE) {
-    int32_t metaSize = CTG_META_SIZE(tbMeta);
-    *pTableMeta = taosMemoryCalloc(1, metaSize);
-    if (NULL == *pTableMeta) {
-      ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache);
-      CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY);
-    }
-
-    memcpy(*pTableMeta, tbMeta, metaSize);
-
-    ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache);
-    ctgDebug("Got tb %s meta from cache, type:%d, dbFName:%s", ctx->pName->tname, tbMeta->tableType, dbFName);
-    return TSDB_CODE_SUCCESS;
-  }
-
-  // PROCESS FOR CHILD TABLE
-
-  int32_t metaSize = sizeof(SCTableMeta);
-  *pTableMeta = taosMemoryCalloc(1, metaSize);
-  if (NULL == *pTableMeta) {
-    CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY);
-  }
-
-  memcpy(*pTableMeta, tbMeta, metaSize);
-
-  //ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache);
-
-  if (tbCache) {
-    CTG_UNLOCK(CTG_READ, &tbCache->metaLock);
-    taosHashRelease(dbCache->tbCache, tbCache);
-  }
-  
-  ctgDebug("Got ctb %s meta from cache, will continue to get its stb meta, type:%d, dbFName:%s", ctx->pName->tname,
-           ctx->tbInfo.tbType, dbFName);
-
-  ctgAcquireStbMetaFromCache(dbCache, pCtg, dbFName, ctx->tbInfo.suid, &tbCache);
-  if (NULL == tbCache) {
-    //ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache);
-    taosMemoryFreeClear(*pTableMeta);
-    ctgDebug("stb 0x%" PRIx64 " meta not in cache", ctx->tbInfo.suid);
-    return TSDB_CODE_SUCCESS;
-  }
-
-  STableMeta *stbMeta = tbCache->pMeta;
-  if (stbMeta->suid != ctx->tbInfo.suid) {
-    ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache);
-    ctgError("stb suid 0x%" PRIx64 " in stbCache mis-match, expected suid 0x%" PRIx64, stbMeta->suid, ctx->tbInfo.suid);
-    CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR);
-  }
-
-  metaSize = CTG_META_SIZE(stbMeta);
-  *pTableMeta = taosMemoryRealloc(*pTableMeta, metaSize);
-  if (NULL == *pTableMeta) {
-    ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache);
-    CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY);
-  }
-
-  memcpy(&(*pTableMeta)->sversion, &stbMeta->sversion, metaSize - sizeof(SCTableMeta));
 
   ctgReleaseTbMetaToCache(pCtg, dbCache, tbCache);
 
@@ -1638,7 +1728,7 @@ int32_t ctgOpUpdateVgroup(SCtgCacheOperation *operation) {
   }
 
   if (dbInfo->vgVersion < 0 || taosHashGetSize(dbInfo->vgHash) <= 0) {
-    ctgError("invalid db vgInfo, dbFName:%s, vgHash:%p, vgVersion:%d, vgHashSize:%d", dbFName, dbInfo->vgHash,
+    ctgDebug("invalid db vgInfo, dbFName:%s, vgHash:%p, vgVersion:%d, vgHashSize:%d", dbFName, dbInfo->vgHash,
              dbInfo->vgVersion, taosHashGetSize(dbInfo->vgHash));
     CTG_ERR_JRET(TSDB_CODE_APP_ERROR);
   }

source/libs/executor/src/dataDeleter.c

@@ -133,7 +133,7 @@ static int32_t getStatus(SDataDeleterHandle* pDeleter) {
 
 static int32_t putDataBlock(SDataSinkHandle* pHandle, const SInputData* pInput, bool* pContinue) {
   SDataDeleterHandle* pDeleter = (SDataDeleterHandle*)pHandle;
-  SDataDeleterBuf*    pBuf = taosAllocateQitem(sizeof(SDataDeleterBuf), DEF_QITEM);
+  SDataDeleterBuf*    pBuf = taosAllocateQitem(sizeof(SDataDeleterBuf), DEF_QITEM, 0);
   if (NULL == pBuf) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }

source/libs/executor/src/dataDispatcher.c

@@ -126,7 +126,7 @@ static int32_t getStatus(SDataDispatchHandle* pDispatcher) {
 
 static int32_t putDataBlock(SDataSinkHandle* pHandle, const SInputData* pInput, bool* pContinue) {
   SDataDispatchHandle* pDispatcher = (SDataDispatchHandle*)pHandle;
-  SDataDispatchBuf*    pBuf = taosAllocateQitem(sizeof(SDataDispatchBuf), DEF_QITEM);
+  SDataDispatchBuf*    pBuf = taosAllocateQitem(sizeof(SDataDispatchBuf), DEF_QITEM, 0);
   if (NULL == pBuf) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }

source/libs/executor/src/exchangeoperator.c

@@ -510,6 +510,7 @@ int32_t extractDataBlockFromFetchRsp(SSDataBlock* pRes, char* pData, SArray* pCo
     blockDataEnsureCapacity(pRes, pBlock->info.rows);
 
     // data from mnode
+    pRes->info.dataLoad = 1;
     pRes->info.rows = pBlock->info.rows;
     relocateColumnData(pRes, pColList, pBlock->pDataBlock, false);
     blockDataDestroy(pBlock);

source/libs/executor/src/executorimpl.c

@@ -1080,7 +1080,7 @@ int32_t doCopyToSDataBlock(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprS
 
   qDebug("%s result generated, rows:%d, groupId:%" PRIu64, GET_TASKID(pTaskInfo), pBlock->info.rows,
          pBlock->info.id.groupId);
-
+  pBlock->info.dataLoad = 1;
   blockDataUpdateTsWindow(pBlock, 0);
   return 0;
 }
@@ -2546,6 +2546,7 @@ int32_t buildDataBlockFromGroupRes(SOperatorInfo* pOperator, SStreamState* pStat
     pBlock->info.rows += pRow->numOfRows;
     releaseOutputBuf(pState, &key, pRow);
   }
+  pBlock->info.dataLoad = 1;
   blockDataUpdateTsWindow(pBlock, 0);
   return TSDB_CODE_SUCCESS;
 }
@@ -2635,6 +2636,7 @@ int32_t buildSessionResultDataBlock(SOperatorInfo* pOperator, SStreamState* pSta
       }
     }
 
+    pBlock->info.dataLoad = 1;
     pBlock->info.rows += pRow->numOfRows;
     // saveSessionDiscBuf(pState, pKey, pVal, size);
     releaseOutputBuf(pState, NULL, pRow);

source/libs/executor/src/groupoperator.c

@@ -314,7 +314,8 @@ static void doHashGroupbyAgg(SOperatorInfo* pOperator, SSDataBlock* pBlock) {
     }
 
     int32_t rowIndex = j - num;
-    applyAggFunctionOnPartialTuples(pTaskInfo, pCtx, NULL, rowIndex, num, pBlock->info.rows, pOperator->exprSupp.numOfExprs);
+    applyAggFunctionOnPartialTuples(pTaskInfo, pCtx, NULL, rowIndex, num, pBlock->info.rows,
+                                    pOperator->exprSupp.numOfExprs);
 
     // assign the group keys or user input constant values if required
     doAssignGroupKeys(pCtx, pOperator->exprSupp.numOfExprs, pBlock->info.rows, rowIndex);
@@ -331,7 +332,8 @@ static void doHashGroupbyAgg(SOperatorInfo* pOperator, SSDataBlock* pBlock) {
     }
 
     int32_t rowIndex = pBlock->info.rows - num;
-    applyAggFunctionOnPartialTuples(pTaskInfo, pCtx, NULL, rowIndex, num, pBlock->info.rows, pOperator->exprSupp.numOfExprs);
+    applyAggFunctionOnPartialTuples(pTaskInfo, pCtx, NULL, rowIndex, num, pBlock->info.rows,
+                                    pOperator->exprSupp.numOfExprs);
     doAssignGroupKeys(pCtx, pOperator->exprSupp.numOfExprs, pBlock->info.rows, rowIndex);
   }
 }
@@ -469,8 +471,8 @@ SOperatorInfo* createGroupOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode*
   initResultRowInfo(&pInfo->binfo.resultRowInfo);
   setOperatorInfo(pOperator, "GroupbyAggOperator", 0, true, OP_NOT_OPENED, pInfo, pTaskInfo);
 
-  pOperator->fpSet =
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, hashGroupbyAggregate, NULL, destroyGroupOperatorInfo,
-      createOperatorFpSet(optrDummyOpenFn, hashGroupbyAggregate, NULL, destroyGroupOperatorInfo, optrDefaultBufFn, NULL);
+                                         optrDefaultBufFn, NULL);
   code = appendDownstream(pOperator, &downstream, 1);
   if (code != TSDB_CODE_SUCCESS) {
     goto _error;
@@ -696,6 +698,7 @@ static SSDataBlock* buildPartitionResult(SOperatorInfo* pOperator) {
   pInfo->pageIndex += 1;
   releaseBufPage(pInfo->pBuf, page);
 
+  pInfo->binfo.pRes->info.dataLoad = 1;
   blockDataUpdateTsWindow(pInfo->binfo.pRes, 0);
   pInfo->binfo.pRes->info.id.groupId = pGroupInfo->groupId;
 
@@ -776,6 +779,12 @@ static void destroyPartitionOperatorInfo(void* param) {
 
   taosArrayDestroy(pInfo->pGroupColVals);
   taosMemoryFree(pInfo->keyBuf);
+
+  int32_t size = taosArrayGetSize(pInfo->sortedGroupArray);
+  for (int32_t i = 0; i < size; i++) {
+    SDataGroupInfo* pGp = taosArrayGet(pInfo->sortedGroupArray, i);
+    taosArrayDestroy(pGp->pPageList);
+  }
   taosArrayDestroy(pInfo->sortedGroupArray);
 
   void* pGroupIter = taosHashIterate(pInfo->pGroupSet, NULL);
@@ -850,7 +859,8 @@ SOperatorInfo* createPartitionOperatorInfo(SOperatorInfo* downstream, SPartition
   pOperator->exprSupp.numOfExprs = numOfCols;
   pOperator->exprSupp.pExprInfo = pExprInfo;
 
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, hashPartition, NULL, destroyPartitionOperatorInfo, optrDefaultBufFn, NULL);
+  pOperator->fpSet =
+      createOperatorFpSet(optrDummyOpenFn, hashPartition, NULL, destroyPartitionOperatorInfo, optrDefaultBufFn, NULL);
 
   code = appendDownstream(pOperator, &downstream, 1);
   return pOperator;
@@ -951,6 +961,8 @@ static SSDataBlock* buildStreamPartitionResult(SOperatorInfo* pOperator) {
   }
   taosArrayDestroy(pParInfo->rowIds);
   pParInfo->rowIds = NULL;
+  pDest->info.dataLoad = 1;
+
   blockDataUpdateTsWindow(pDest, pInfo->tsColIndex);
   pDest->info.id.groupId = pParInfo->groupId;
   pOperator->resultInfo.totalRows += pDest->info.rows;
@@ -1141,8 +1153,8 @@ SOperatorInfo* createStreamPartitionOperatorInfo(SOperatorInfo* downstream, SStr
                   pInfo, pTaskInfo);
   pOperator->exprSupp.numOfExprs = numOfCols;
   pOperator->exprSupp.pExprInfo = pExprInfo;
-  pOperator->fpSet =
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamHashPartition, NULL,
-      createOperatorFpSet(optrDummyOpenFn, doStreamHashPartition, NULL, destroyStreamPartitionOperatorInfo, optrDefaultBufFn, NULL);
+                                         destroyStreamPartitionOperatorInfo, optrDefaultBufFn, NULL);
 
   initParDownStream(downstream, &pInfo->partitionSup, &pInfo->scalarSup);
   code = appendDownstream(pOperator, &downstream, 1);

source/libs/executor/src/joinoperator.c

@@ -87,11 +87,11 @@ SOperatorInfo* createMergeJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t
   }
 
   int32_t      numOfCols = 0;
-  SSDataBlock* pResBlock = createDataBlockFromDescNode(pJoinNode->node.pOutputDataBlockDesc);
+  pInfo->pRes = createDataBlockFromDescNode(pJoinNode->node.pOutputDataBlockDesc);
+
   SExprInfo*   pExprInfo = createExprInfo(pJoinNode->pTargets, NULL, &numOfCols);
   initResultSizeInfo(&pOperator->resultInfo, 4096);
-
+  blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
-  pInfo->pRes = pResBlock;
 
   setOperatorInfo(pOperator, "MergeJoinOperator", QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN, false, OP_NOT_OPENED, pInfo, pTaskInfo);
   pOperator->exprSupp.pExprInfo = pExprInfo;
@@ -401,6 +401,7 @@ static void doMergeJoinImpl(struct SOperatorInfo* pOperator, SSDataBlock* pRes)
 
     // the pDataBlock are always the same one, no need to call this again
     pRes->info.rows = nrows;
+    pRes->info.dataLoad = 1;
     if (pRes->info.rows >= pOperator->resultInfo.threshold) {
       break;
     }
@@ -412,7 +413,7 @@ SSDataBlock* doMergeJoin(struct SOperatorInfo* pOperator) {
 
   SSDataBlock* pRes = pJoinInfo->pRes;
   blockDataCleanup(pRes);
-  blockDataEnsureCapacity(pRes, 4096);
+
   while (true) {
     int32_t numOfRowsBefore = pRes->info.rows;
     doMergeJoinImpl(pOperator, pRes);

source/libs/executor/src/projectoperator.c

@@ -654,6 +654,7 @@ static void setPseudoOutputColInfo(SSDataBlock* pResult, SqlFunctionCtx* pCtx, S
 int32_t projectApplyFunctions(SExprInfo* pExpr, SSDataBlock* pResult, SSDataBlock* pSrcBlock, SqlFunctionCtx* pCtx,
                               int32_t numOfOutput, SArray* pPseudoList) {
   setPseudoOutputColInfo(pResult, pCtx, pPseudoList);
+  pResult->info.dataLoad = 1;
 
   if (pSrcBlock == NULL) {
     for (int32_t k = 0; k < numOfOutput; ++k) {

source/libs/executor/src/scanoperator.c

@@ -110,9 +110,9 @@ static bool overlapWithTimeWindow(SInterval* pInterval, SDataBlockInfo* pBlockIn
 
   if (order == TSDB_ORDER_ASC) {
     w = getAlignQueryTimeWindow(pInterval, pInterval->precision, pBlockInfo->window.skey);
-    assert(w.ekey >= pBlockInfo->window.skey);
+    ASSERT(w.ekey >= pBlockInfo->window.skey);
 
-    if (TMAX(w.skey, pBlockInfo->window.skey) <= TMIN(w.ekey, pBlockInfo->window.ekey)) {
+    if (w.ekey < pBlockInfo->window.ekey) {
       return true;
     }
 
@@ -122,16 +122,16 @@ static bool overlapWithTimeWindow(SInterval* pInterval, SDataBlockInfo* pBlockIn
         break;
       }
 
-      assert(w.ekey > pBlockInfo->window.ekey);
+      ASSERT(w.ekey > pBlockInfo->window.ekey);
       if (TMAX(w.skey, pBlockInfo->window.skey) <= pBlockInfo->window.ekey) {
         return true;
       }
     }
   } else {
     w = getAlignQueryTimeWindow(pInterval, pInterval->precision, pBlockInfo->window.ekey);
-    assert(w.skey <= pBlockInfo->window.ekey);
+    ASSERT(w.skey <= pBlockInfo->window.ekey);
 
-    if (TMAX(w.skey, pBlockInfo->window.skey) <= TMIN(w.ekey, pBlockInfo->window.ekey)) {
+    if (w.skey > pBlockInfo->window.skey) {
       return true;
     }
 
@@ -1342,6 +1342,7 @@ static int32_t generateScanRange(SStreamScanInfo* pInfo, SSDataBlock* pSrcBlock,
   }
   pDestBlock->info.type = STREAM_CLEAR;
   pDestBlock->info.version = pSrcBlock->info.version;
+  pDestBlock->info.dataLoad = 1;
   blockDataUpdateTsWindow(pDestBlock, 0);
   return code;
 }
@@ -1450,6 +1451,7 @@ static void checkUpdateData(SStreamScanInfo* pInfo, bool invertible, SSDataBlock
   }
   if (out && pInfo->pUpdateDataRes->info.rows > 0) {
     pInfo->pUpdateDataRes->info.version = pBlock->info.version;
+    pInfo->pUpdateDataRes->info.dataLoad = 1;
     blockDataUpdateTsWindow(pInfo->pUpdateDataRes, 0);
     pInfo->pUpdateDataRes->info.type = pInfo->partitionSup.needCalc ? STREAM_DELETE_DATA : STREAM_CLEAR;
   }
@@ -1512,6 +1514,7 @@ static int32_t setBlockIntoRes(SStreamScanInfo* pInfo, const SSDataBlock* pBlock
     doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
   }
 
+  pInfo->pRes->info.dataLoad = 1;
   blockDataUpdateTsWindow(pInfo->pRes, pInfo->primaryTsIndex);
   blockDataFreeRes((SSDataBlock*)pBlock);
 
@@ -1793,6 +1796,7 @@ FETCH_NEXT_BLOCK:
     // TODO move into scan
     pBlock->info.calWin.skey = INT64_MIN;
     pBlock->info.calWin.ekey = INT64_MAX;
+    pBlock->info.dataLoad = 1;
     blockDataUpdateTsWindow(pBlock, 0);
     switch (pBlock->info.type) {
       case STREAM_NORMAL:
@@ -1970,6 +1974,7 @@ FETCH_NEXT_BLOCK:
         }
 
         doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+        pInfo->pRes->info.dataLoad = 1;
         blockDataUpdateTsWindow(pInfo->pRes, pInfo->primaryTsIndex);
 
         if (pBlockInfo->rows > 0 || pInfo->pUpdateDataRes->info.rows > 0) {

source/libs/executor/src/sortoperator.c

@@ -105,6 +105,7 @@ void appendOneRowToDataBlock(SSDataBlock* pBlock, STupleHandle* pTupleHandle) {
     }
   }
 
+  pBlock->info.dataLoad = 1;
   pBlock->info.rows += 1;
 }
 
@@ -698,6 +699,7 @@ SSDataBlock* getMultiwaySortedBlockData(SSortHandle* pHandle, SSDataBlock* pData
     pInfo->limitInfo.numOfOutputRows += p->info.rows;
     pDataBlock->info.rows = p->info.rows;
     pDataBlock->info.id.groupId = pInfo->groupId;
+    pDataBlock->info.dataLoad = 1;
   }
 
   qDebug("%s get sorted block, groupId:0x%" PRIx64 " rows:%d", GET_TASKID(pTaskInfo), pDataBlock->info.id.groupId,

source/libs/executor/src/timesliceoperator.c

@@ -49,10 +49,10 @@ static void doKeepPrevRows(STimeSliceOperatorInfo* pSliceInfo, const SSDataBlock
     if (!colDataIsNull_s(pColInfoData, rowIndex)) {
       pkey->isNull = false;
       char* val = colDataGetData(pColInfoData, rowIndex);
-      if (!IS_VAR_DATA_TYPE(pkey->type)) {
+      if (IS_VAR_DATA_TYPE(pkey->type)) {
-        memcpy(pkey->pData, val, pkey->bytes);
-      } else {
         memcpy(pkey->pData, val, varDataLen(val));
+      } else {
+        memcpy(pkey->pData, val, pkey->bytes);
       }
     } else {
       pkey->isNull = true;
@@ -91,20 +91,37 @@ static void doKeepLinearInfo(STimeSliceOperatorInfo* pSliceInfo, const SSDataBlo
     SColumnInfoData* pTsCol = taosArrayGet(pBlock->pDataBlock, pSliceInfo->tsCol.slotId);
     SFillLinearInfo* pLinearInfo = taosArrayGet(pSliceInfo->pLinearInfo, i);
 
+
+    if (!IS_MATHABLE_TYPE(pColInfoData->info.type)) {
+      continue;
+    }
+
     // null value is represented by using key = INT64_MIN for now.
     // TODO: optimize to ignore null values for linear interpolation.
     if (!pLinearInfo->isStartSet) {
       if (!colDataIsNull_s(pColInfoData, rowIndex)) {
-        ASSERT(IS_MATHABLE_TYPE(pColInfoData->info.type));
 
         pLinearInfo->start.key = *(int64_t*)colDataGetData(pTsCol, rowIndex);
-        memcpy(pLinearInfo->start.val, colDataGetData(pColInfoData, rowIndex), pLinearInfo->bytes);
+        char* p = colDataGetData(pColInfoData, rowIndex);
+        if (IS_VAR_DATA_TYPE(pColInfoData->info.type)) {
+          ASSERT(varDataTLen(p) <= pColInfoData->info.bytes);
+          memcpy(pLinearInfo->start.val, p, varDataTLen(p));
+        } else {
+          memcpy(pLinearInfo->start.val, p, pLinearInfo->bytes);
+        }
       }
       pLinearInfo->isStartSet = true;
     } else if (!pLinearInfo->isEndSet) {
       if (!colDataIsNull_s(pColInfoData, rowIndex)) {
         pLinearInfo->end.key = *(int64_t*)colDataGetData(pTsCol, rowIndex);
-        memcpy(pLinearInfo->end.val, colDataGetData(pColInfoData, rowIndex), pLinearInfo->bytes);
+
+        char* p = colDataGetData(pColInfoData, rowIndex);
+        if (IS_VAR_DATA_TYPE(pColInfoData->info.type)) {
+          ASSERT(varDataTLen(p) <= pColInfoData->info.bytes);
+          memcpy(pLinearInfo->end.val, p, varDataTLen(p));
+        } else {
+          memcpy(pLinearInfo->end.val, p, pLinearInfo->bytes);
+        }
       }
       pLinearInfo->isEndSet = true;
     } else {
@@ -113,7 +130,15 @@ static void doKeepLinearInfo(STimeSliceOperatorInfo* pSliceInfo, const SSDataBlo
 
       if (!colDataIsNull_s(pColInfoData, rowIndex)) {
         pLinearInfo->end.key = *(int64_t*)colDataGetData(pTsCol, rowIndex);
-        memcpy(pLinearInfo->end.val, colDataGetData(pColInfoData, rowIndex), pLinearInfo->bytes);
+
+        char* p = colDataGetData(pColInfoData, rowIndex);
+        if (IS_VAR_DATA_TYPE(pColInfoData->info.type)) {
+          ASSERT(varDataTLen(p) <= pColInfoData->info.bytes);
+          memcpy(pLinearInfo->end.val, p, varDataTLen(p));
+        } else {
+          memcpy(pLinearInfo->end.val, p, pLinearInfo->bytes);
+        }
+
       } else {
         pLinearInfo->end.key = INT64_MIN;
       }

source/libs/executor/src/timewindowoperator.c

@@ -23,6 +23,7 @@
 #include "ttime.h"
 
 #define IS_FINAL_OP(op) ((op)->isFinal)
+#define DEAULT_DELETE_MARK (1000LL * 60LL * 60LL * 24LL * 365LL * 10LL);
 
 typedef struct SSessionAggOperatorInfo {
   SOptrBasicInfo     binfo;
@@ -56,6 +57,7 @@ typedef enum SResultTsInterpType {
 typedef struct SPullWindowInfo {
   STimeWindow window;
   uint64_t    groupId;
+  STimeWindow calWin;
 } SPullWindowInfo;
 
 typedef struct SOpenWindowInfo {
@@ -793,18 +795,19 @@ int32_t comparePullWinKey(void* pKey, void* data, int32_t index) {
   SArray*          res = (SArray*)data;
   SPullWindowInfo* pos = taosArrayGet(res, index);
   SPullWindowInfo* pData = (SPullWindowInfo*)pKey;
-  if (pData->window.skey == pos->window.skey) {
   if (pData->groupId > pos->groupId) {
     return 1;
   } else if (pData->groupId < pos->groupId) {
     return -1;
   }
-    return 0;
+
-  } else if (pData->window.skey > pos->window.skey) {
+  if (pData->window.skey > pos->window.ekey) {
     return 1;
-  }
+  } else if (pData->window.ekey < pos->window.skey) {
     return -1;
   }
+  return 0;
+}
 
 static int32_t savePullWindow(SPullWindowInfo* pPullInfo, SArray* pPullWins) {
   int32_t size = taosArrayGetSize(pPullWins);
@@ -812,10 +815,16 @@ static int32_t savePullWindow(SPullWindowInfo* pPullInfo, SArray* pPullWins) {
   if (index == -1) {
     index = 0;
   } else {
-    if (comparePullWinKey(pPullInfo, pPullWins, index) > 0) {
+    int32_t code = comparePullWinKey(pPullInfo, pPullWins, index);
-      index++;
+    if (code == 0) {
-    } else {
+      SPullWindowInfo* pos = taosArrayGet(pPullWins ,index);
+      pos->window.skey = TMIN(pos->window.skey, pPullInfo->window.skey);
+      pos->window.ekey = TMAX(pos->window.ekey, pPullInfo->window.ekey);
+      pos->calWin.skey = TMIN(pos->calWin.skey, pPullInfo->calWin.skey);
+      pos->calWin.ekey = TMAX(pos->calWin.ekey, pPullInfo->calWin.ekey);
       return TSDB_CODE_SUCCESS;
+    } else if (code > 0 ){
+      index++;
     }
   }
   if (taosArrayInsert(pPullWins, index, pPullInfo) == NULL) {
@@ -863,19 +872,20 @@ static void removeResults(SArray* pWins, SHashObj* pUpdatedMap) {
 
 int32_t compareWinRes(void* pKey, void* data, int32_t index) {
   SArray*     res = (SArray*)data;
-  SWinKey*    pos = taosArrayGet(res, index);
+  SWinKey*    pDataPos = taosArrayGet(res, index);
-  SResKeyPos* pData = (SResKeyPos*)pKey;
+  SResKeyPos* pRKey = (SResKeyPos*)pKey;
-  if (*(int64_t*)pData->key == pos->ts) {
+  if (pRKey->groupId > pDataPos->groupId) {
-    if (pData->groupId > pos->groupId) {
     return 1;
-    } else if (pData->groupId < pos->groupId) {
+  } else if (pRKey->groupId < pDataPos->groupId) {
+    return -1;
+  }
+  
+  if (*(int64_t*)pRKey->key > pDataPos->ts) {
+    return 1;
+  } else if (*(int64_t*)pRKey->key < pDataPos->ts){
     return -1;
   }
   return 0;
-  } else if (*(int64_t*)pData->key > pos->ts) {
-    return 1;
-  }
-  return -1;
 }
 
 static void removeDeleteResults(SHashObj* pUpdatedMap, SArray* pDelWins) {
@@ -1027,9 +1037,10 @@ SResultRowPosition addToOpenWindowList(SResultRowInfo* pResultRowInfo, const SRe
 int64_t* extractTsCol(SSDataBlock* pBlock, const SIntervalAggOperatorInfo* pInfo) {
   TSKEY* tsCols = NULL;
 
-  if (pBlock->pDataBlock != NULL) {
+  if (pBlock->pDataBlock != NULL && pBlock->info.dataLoad == 1) {
     SColumnInfoData* pColDataInfo = taosArrayGet(pBlock->pDataBlock, pInfo->primaryTsIndex);
     tsCols = (int64_t*)pColDataInfo->pData;
+    ASSERT(tsCols[0] != 0);
 
     // no data in primary ts
     if (tsCols[0] == 0 && tsCols[pBlock->info.rows - 1] == 0) {
@@ -1073,8 +1084,6 @@ static int32_t doOpenIntervalAgg(SOperatorInfo* pOperator) {
 
     // the pDataBlock are always the same one, no need to call this again
     setInputDataBlock(pSup, pBlock, pInfo->inputOrder, scanFlag, true);
-    blockDataUpdateTsWindow(pBlock, pInfo->primaryTsIndex);
-
     hashIntervalAgg(pOperator, &pInfo->binfo.resultRowInfo, pBlock, scanFlag);
   }
 
@@ -1400,19 +1409,21 @@ static int32_t getAllIntervalWindow(SSHashObj* pHashMap, SHashObj* resWins) {
 
 int32_t compareWinKey(void* pKey, void* data, int32_t index) {
   SArray*  res = (SArray*)data;
-  SWinKey* pos = taosArrayGet(res, index);
+  SWinKey* pDataPos = taosArrayGet(res, index);
-  SWinKey* pData = (SWinKey*)pKey;
+  SWinKey* pWKey = (SWinKey*)pKey;
-  if (pData->ts == pos->ts) {
+
-    if (pData->groupId > pos->groupId) {
+  if (pWKey->groupId > pDataPos->groupId) {
     return 1;
-    } else if (pData->groupId < pos->groupId) {
+  } else if (pWKey->groupId < pDataPos->groupId) {
+    return -1;
+  }
+
+  if (pWKey->ts > pDataPos->ts) {
+    return 1;
+  } else if (pWKey->ts < pDataPos->ts) {
     return -1;
   }
   return 0;
-  } else if (pData->ts > pos->ts) {
-    return 1;
-  }
-  return -1;
 }
 
 static int32_t closeStreamIntervalWindow(SSHashObj* pHashMap, STimeWindowAggSupp* pTwSup, SInterval* pInterval,
@@ -2252,8 +2263,8 @@ static void doBuildPullDataBlock(SArray* array, int32_t* pIndex, SSDataBlock* pB
     colDataAppend(pStartTs, pBlock->info.rows, (const char*)&pWin->window.skey, false);
     colDataAppend(pEndTs, pBlock->info.rows, (const char*)&pWin->window.ekey, false);
     colDataAppend(pGroupId, pBlock->info.rows, (const char*)&pWin->groupId, false);
-    colDataAppend(pCalStartTs, pBlock->info.rows, (const char*)&pWin->window.skey, false);
+    colDataAppend(pCalStartTs, pBlock->info.rows, (const char*)&pWin->calWin.skey, false);
-    colDataAppend(pCalEndTs, pBlock->info.rows, (const char*)&pWin->window.ekey, false);
+    colDataAppend(pCalEndTs, pBlock->info.rows, (const char*)&pWin->calWin.ekey, false);
     pBlock->info.rows++;
   }
   if ((*pIndex) == size) {
@@ -2263,14 +2274,18 @@ static void doBuildPullDataBlock(SArray* array, int32_t* pIndex, SSDataBlock* pB
   blockDataUpdateTsWindow(pBlock, 0);
 }
 
-void processPullOver(SSDataBlock* pBlock, SHashObj* pMap) {
+void processPullOver(SSDataBlock* pBlock, SHashObj* pMap, SInterval* pInterval) {
   SColumnInfoData* pStartCol = taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX);
   TSKEY*           tsData = (TSKEY*)pStartCol->pData;
+  SColumnInfoData* pEndCol = taosArrayGet(pBlock->pDataBlock, END_TS_COLUMN_INDEX);
+  TSKEY*           tsEndData = (TSKEY*)pEndCol->pData;
   SColumnInfoData* pGroupCol = taosArrayGet(pBlock->pDataBlock, GROUPID_COLUMN_INDEX);
   uint64_t*        groupIdData = (uint64_t*)pGroupCol->pData;
   int32_t          chId = getChildIndex(pBlock);
   for (int32_t i = 0; i < pBlock->info.rows; i++) {
-    SWinKey winRes = {.ts = tsData[i], .groupId = groupIdData[i]};
+    TSKEY winTs = tsData[i];
+    while (winTs < tsEndData[i]) {
+      SWinKey winRes = {.ts = winTs, .groupId = groupIdData[i]};
       void*   chIds = taosHashGet(pMap, &winRes, sizeof(SWinKey));
       if (chIds) {
         SArray* chArray = *(SArray**)chIds;
@@ -2285,6 +2300,8 @@ void processPullOver(SSDataBlock* pBlock, SHashObj* pMap) {
           }
         }
       }
+      winTs = taosTimeAdd(winTs, pInterval->sliding, pInterval->slidingUnit, pInterval->precision);
+    }
   }
 }
 
@@ -2296,9 +2313,9 @@ static void addRetriveWindow(SArray* wins, SStreamIntervalOperatorInfo* pInfo) {
     if (needDeleteWindowBuf(&nextWin, &pInfo->twAggSup) && !pInfo->ignoreExpiredData) {
       void* chIds = taosHashGet(pInfo->pPullDataMap, winKey, sizeof(SWinKey));
       if (!chIds) {
-        SPullWindowInfo pull = {.window = nextWin, .groupId = winKey->groupId};
+        SPullWindowInfo pull = {.window = nextWin, .groupId = winKey->groupId, .calWin.skey = nextWin.skey, .calWin.ekey = nextWin.skey};
         // add pull data request
-        savePullWindow(&pull, pInfo->pPullWins);
+        if (savePullWindow(&pull, pInfo->pPullWins) == TSDB_CODE_SUCCESS) {
           int32_t size1 = taosArrayGetSize(pInfo->pChildren);
           addPullWindow(pInfo->pPullDataMap, winKey, size1);
           qDebug("===stream===prepare retrive for delete %" PRId64 ", size:%d", winKey->ts, size1);
@@ -2306,6 +2323,7 @@ static void addRetriveWindow(SArray* wins, SStreamIntervalOperatorInfo* pInfo) {
       }
     }
   }
+}
 
 static void clearFunctionContext(SExprSupp* pSup) {
   for (int32_t i = 0; i < pSup->numOfExprs; i++) {
@@ -2371,12 +2389,13 @@ static void doStreamIntervalAggImpl(SOperatorInfo* pOperatorInfo, SSDataBlock* p
       };
       void* chIds = taosHashGet(pInfo->pPullDataMap, &winRes, sizeof(SWinKey));
       if (isDeletedStreamWindow(&nextWin, groupId, pInfo->pState, &pInfo->twAggSup) && !chIds) {
-        SPullWindowInfo pull = {.window = nextWin, .groupId = groupId};
+        SPullWindowInfo pull = {.window = nextWin, .groupId = groupId, .calWin.skey = nextWin.skey, .calWin.ekey = nextWin.skey};
         // add pull data request
-        savePullWindow(&pull, pInfo->pPullWins);
+        if (savePullWindow(&pull, pInfo->pPullWins) == TSDB_CODE_SUCCESS) {
           int32_t size = taosArrayGetSize(pInfo->pChildren);
           addPullWindow(pInfo->pPullDataMap, &winRes, size);
           qDebug("===stream===prepare retrive %" PRId64 ", size:%d", winRes.ts, size);
+        }
       } else {
         int32_t index = -1;
         SArray* chArray = NULL;
@@ -2557,7 +2576,7 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) {
       }
       continue;
     } else if (pBlock->info.type == STREAM_PULL_OVER && IS_FINAL_OP(pInfo)) {
-      processPullOver(pBlock, pInfo->pPullDataMap);
+      processPullOver(pBlock, pInfo->pPullDataMap, &pInfo->interval);
       continue;
     }
 
@@ -2635,6 +2654,15 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) {
   return NULL;
 }
 
+int64_t getDeleteMark(SIntervalPhysiNode* pIntervalPhyNode) {
+  if (pIntervalPhyNode->window.deleteMark <= 0) {
+    return DEAULT_DELETE_MARK;
+  }
+  int64_t deleteMark = TMAX(pIntervalPhyNode->window.deleteMark,pIntervalPhyNode->window.watermark);
+  deleteMark = TMAX(deleteMark, pIntervalPhyNode->interval);
+  return deleteMark;
+}
+
 SOperatorInfo* createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode,
                                                      SExecTaskInfo* pTaskInfo, int32_t numOfChild) {
   SIntervalPhysiNode*          pIntervalPhyNode = (SIntervalPhysiNode*)pPhyNode;
@@ -2656,9 +2684,7 @@ SOperatorInfo* createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream,
       .calTrigger = pIntervalPhyNode->window.triggerType,
       .maxTs = INT64_MIN,
       .minTs = INT64_MAX,
-      // for test 315360000000
+      .deleteMark = getDeleteMark(pIntervalPhyNode),
-      .deleteMark = 1000LL * 60LL * 60LL * 24LL * 365LL * 10LL,
-      // .deleteMark = INT64_MAX,
       .deleteMarkSaved = 0,
       .calTriggerSaved = 0,
   };
@@ -4802,7 +4828,7 @@ SOperatorInfo* createStreamIntervalOperatorInfo(SOperatorInfo* downstream, SPhys
       .calTrigger = pIntervalPhyNode->window.triggerType,
       .maxTs = INT64_MIN,
       .minTs = INT64_MAX,
-      .deleteMark = INT64_MAX,
+      .deleteMark = getDeleteMark(pIntervalPhyNode),
   };
 
   ASSERT(twAggSupp.calTrigger != STREAM_TRIGGER_MAX_DELAY);

source/libs/executor/test/executorTests.cpp

@@ -166,6 +166,7 @@ SSDataBlock* get2ColsDummyBlock(SOperatorInfo* pOperator) {
 
   pInfo->current += 1;
 
+  pBlock->info.dataLoad = 1;
   blockDataUpdateTsWindow(pBlock, 0);
   return pBlock;
 }

source/libs/function/src/detail/tavgfunction.c

@@ -514,7 +514,7 @@ int32_t avgFunction(SqlFunctionCtx* pCtx) {
     numOfElem = pInput->numOfRows;
     pAvgRes->count += pInput->numOfRows;
 
-    bool simdAvailable = tsAVXEnable && tsSIMDEnable && (numOfRows > THRESHOLD_SIZE);
+    bool simdAvailable = tsAVXEnable && tsSIMDBuiltins && (numOfRows > THRESHOLD_SIZE);
 
     switch(type) {
       case TSDB_DATA_TYPE_UTINYINT:

source/libs/function/src/detail/tminmax.c

@@ -369,7 +369,7 @@ static int32_t findFirstValPosition(const SColumnInfoData* pCol, int32_t start,
 static void handleInt8Col(const void* data, int32_t start, int32_t numOfRows, SMinmaxResInfo* pBuf, bool isMinFunc,
                           bool signVal) {
   // AVX2 version to speedup the loop
-  if (tsAVX2Enable && tsSIMDEnable) {
+  if (tsAVX2Enable && tsSIMDBuiltins) {
     pBuf->v = i8VectorCmpAVX2(data, numOfRows, isMinFunc, signVal);
   } else {
     if (!pBuf->assign) {
@@ -403,7 +403,7 @@ static void handleInt8Col(const void* data, int32_t start, int32_t numOfRows, SM
 static void handleInt16Col(const void* data, int32_t start, int32_t numOfRows, SMinmaxResInfo* pBuf, bool isMinFunc,
                            bool signVal) {
   // AVX2 version to speedup the loop
-  if (tsAVX2Enable && tsSIMDEnable) {
+  if (tsAVX2Enable && tsSIMDBuiltins) {
     pBuf->v = i16VectorCmpAVX2(data, numOfRows, isMinFunc, signVal);
   } else {
     if (!pBuf->assign) {
@@ -437,7 +437,7 @@ static void handleInt16Col(const void* data, int32_t start, int32_t numOfRows, S
 static void handleInt32Col(const void* data, int32_t start, int32_t numOfRows, SMinmaxResInfo* pBuf, bool isMinFunc,
                            bool signVal) {
   // AVX2 version to speedup the loop
-  if (tsAVX2Enable && tsSIMDEnable) {
+  if (tsAVX2Enable && tsSIMDBuiltins) {
     pBuf->v = i32VectorCmpAVX2(data, numOfRows, isMinFunc, signVal);
   } else {
     if (!pBuf->assign) {
@@ -500,7 +500,7 @@ static void handleFloatCol(SColumnInfoData* pCol, int32_t start, int32_t numOfRo
   float* val = (float*)&pBuf->v;
 
   // AVX version to speedup the loop
-  if (tsAVXEnable && tsSIMDEnable) {
+  if (tsAVXEnable && tsSIMDBuiltins) {
     *val = floatVectorCmpAVX(pData, numOfRows, isMinFunc);
   } else {
     if (!pBuf->assign) {
@@ -530,7 +530,7 @@ static void handleDoubleCol(SColumnInfoData* pCol, int32_t start, int32_t numOfR
   double* val = (double*)&pBuf->v;
 
   // AVX version to speedup the loop
-  if (tsAVXEnable && tsSIMDEnable) {
+  if (tsAVXEnable && tsSIMDBuiltins) {
     *val = (double)doubleVectorCmpAVX(pData, numOfRows, isMinFunc);
   } else {
     if (!pBuf->assign) {

source/libs/function/src/tpercentile.c

@@ -364,15 +364,18 @@ int32_t tMemBucketPut(tMemBucket *pBucket, const void *data, size_t size) {
         assert(pSlot->info.data->num >= pBucket->elemPerPage && pSlot->info.size > 0);
 
         // keep the pointer in memory
+        setBufPageDirty(pSlot->info.data, true);
         releaseBufPage(pBucket->pBuffer, pSlot->info.data);
         pSlot->info.data = NULL;
       }
 
-      SArray *pPageIdList = (SArray *)taosHashGet(pBucket->groupPagesMap, &groupId, sizeof(groupId));
+      SArray *pPageIdList;
-      if (pPageIdList == NULL) {
+      void *p = taosHashGet(pBucket->groupPagesMap, &groupId, sizeof(groupId));
-        SArray *pList = taosArrayInit(4, sizeof(int32_t));
+      if (p == NULL) {
-        taosHashPut(pBucket->groupPagesMap, &groupId, sizeof(groupId), &pList, POINTER_BYTES);
+        pPageIdList = taosArrayInit(4, sizeof(int32_t));
-        pPageIdList = pList;
+        taosHashPut(pBucket->groupPagesMap, &groupId, sizeof(groupId), &pPageIdList, POINTER_BYTES);
+      } else {
+        pPageIdList = *(SArray **)p;
       }
 
       pSlot->info.data = getNewBufPage(pBucket->pBuffer, &pageId);
@@ -495,15 +498,16 @@ double getPercentileImpl(tMemBucket *pMemBucket, int32_t count, double fraction)
         resetSlotInfo(pMemBucket);
 
         int32_t groupId = getGroupId(pMemBucket->numOfSlots, i, pMemBucket->times - 1);
-        SArray* list = taosHashGet(pMemBucket->groupPagesMap, &groupId, sizeof(groupId));
+        SArray* list = *(SArray **)taosHashGet(pMemBucket->groupPagesMap, &groupId, sizeof(groupId));
         ASSERT(list != NULL && list->size > 0);
 
         for (int32_t f = 0; f < list->size; ++f) {
-          SPageInfo *pgInfo = *(SPageInfo **)taosArrayGet(list, f);
+          int32_t *pageId = taosArrayGet(list, f);
-          SFilePage *pg = getBufPage(pMemBucket->pBuffer, getPageId(pgInfo));
+          SFilePage *pg = getBufPage(pMemBucket->pBuffer, *pageId);
 
           tMemBucketPut(pMemBucket, pg->data, (int32_t)pg->num);
-          releaseBufPageInfo(pMemBucket->pBuffer, pgInfo);
+          setBufPageDirty(pg, true);
+          releaseBufPage(pMemBucket->pBuffer, pg);
         }
 
         return getPercentileImpl(pMemBucket, count - num, fraction);

source/libs/function/src/tudf.c

@@ -837,9 +837,34 @@ int32_t convertUdfColumnToDataBlock(SUdfColumn *udfCol, SSDataBlock *block) {
 }
 
 int32_t convertScalarParamToDataBlock(SScalarParam *input, int32_t numOfCols, SSDataBlock *output) {
-  output->info.rows = input->numOfRows;
+  int32_t numOfRows = 0;
+  for (int32_t i = 0; i < numOfCols; ++i) {
+    numOfRows = (input[i].numOfRows > numOfRows) ? input[i].numOfRows : numOfRows;
+  }
+  output->info.rows = numOfRows;
   output->pDataBlock = taosArrayInit(numOfCols, sizeof(SColumnInfoData));
   for (int32_t i = 0; i < numOfCols; ++i) {
+    if ((input+i)->numOfRows < numOfRows) {
+      SColumnInfoData* pColInfoData = (input+i)->columnData;
+      int32_t startRow = (input+i)->numOfRows;
+      int32_t expandRows = numOfRows - startRow;
+      colInfoDataEnsureCapacity(pColInfoData, numOfRows, false);
+      bool isNull = colDataIsNull_s(pColInfoData, (input+i)->numOfRows - 1);
+      if (isNull) {
+        colDataAppendNNULL(pColInfoData, startRow, expandRows);
+      } else {
+        char* src = colDataGetData(pColInfoData, (input + i)->numOfRows - 1);
+        int32_t bytes = pColInfoData->info.bytes;
+        char* data = taosMemoryMalloc(bytes);
+        memcpy(data, src, bytes);
+        for (int j = 0; j < expandRows; ++j) {
+          colDataAppend(pColInfoData, startRow+j, data, false);
+        }
+        //colDataAppendNItems(pColInfoData, startRow, data, expandRows);
+        taosMemoryFree(data);
+      }
+    }
+
     taosArrayPush(output->pDataBlock, (input + i)->columnData);
 
     if (IS_VAR_DATA_TYPE((input + i)->columnData->info.type)) {

source/libs/function/src/udfd.c

@@ -28,7 +28,7 @@
 #include "tmsg.h"
 #include "trpc.h"
 #include "tmisce.h"
-// clang-foramt on
+// clang-format on
 
 typedef struct SUdfdContext {
   uv_loop_t  *loop;
@@ -49,18 +49,25 @@ typedef struct SUdfdContext {
 
 SUdfdContext global;
 
+struct SUdfdUvConn;
+struct SUvUdfWork;
+
 typedef struct SUdfdUvConn {
   uv_stream_t *client;
   char        *inputBuf;
   int32_t      inputLen;
   int32_t      inputCap;
   int32_t      inputTotal;
+
+  struct SUvUdfWork *pWorkList;  // head of work list
 } SUdfdUvConn;
 
 typedef struct SUvUdfWork {
-  uv_stream_t *client;
+  SUdfdUvConn *conn;
   uv_buf_t     input;
   uv_buf_t     output;
+
+  struct SUvUdfWork *pWorkNext;
 } SUvUdfWork;
 
 typedef enum { UDF_STATE_INIT = 0, UDF_STATE_LOADING, UDF_STATE_READY, UDF_STATE_UNLOADING } EUdfState;
@@ -248,7 +255,8 @@ void udfdProcessSetupRequest(SUvUdfWork *uvUdf, SUdfRequest *request) {
 
 void udfdProcessCallRequest(SUvUdfWork *uvUdf, SUdfRequest *request) {
   SUdfCallRequest *call = &request->call;
-  fnDebug("call request. call type %d, handle: %" PRIx64 ", seq num %" PRId64 , call->callType, call->udfHandle, request->seqNum);
+  fnDebug("call request. call type %d, handle: %" PRIx64 ", seq num %" PRId64, call->callType, call->udfHandle,
+          request->seqNum);
   SUdfcFuncHandle  *handle = (SUdfcFuncHandle *)(call->udfHandle);
   SUdf             *udf = handle->udf;
   SUdfResponse      response = {0};
@@ -417,7 +425,6 @@ void udfdProcessRpcRsp(void *parent, SRpcMsg *pMsg, SEpSet *pEpSet) {
       goto _return;
     }
 
-     
     if (connectRsp.epSet.numOfEps == 0) {
       msgInfo->code = TSDB_CODE_APP_ERROR;
       goto _return;
@@ -601,7 +608,8 @@ 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_SYN_RESTORING || code == TSDB_CODE_MNODE_NOT_FOUND || code == TSDB_CODE_APP_IS_STARTING ||
       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) {
+    if (msgType == TDMT_SCH_QUERY || msgType == TDMT_SCH_MERGE_QUERY || msgType == TDMT_SCH_FETCH ||
+        msgType == TDMT_SCH_MERGE_FETCH) {
       return false;
     }
     return true;
@@ -684,6 +692,17 @@ void udfdOnWrite(uv_write_t *req, int status) {
   if (status < 0) {
     fnError("udfd send response error, length: %zu code: %s", work->output.len, uv_err_name(status));
   }
+  // remove work from the connection work list
+  if (work->conn != NULL) {
+    SUvUdfWork **ppWork;
+    for (ppWork = &work->conn->pWorkList; *ppWork && (*ppWork != work); ppWork = &((*ppWork)->pWorkNext)) {
+    }
+    if (*ppWork == work) {
+      *ppWork = work->pWorkNext;
+    } else {
+      fnError("work not in conn any more");
+    }
+  }
   taosMemoryFree(work->output.base);
   taosMemoryFree(work);
   taosMemoryFree(req);
@@ -692,10 +711,11 @@ void udfdOnWrite(uv_write_t *req, int status) {
 void udfdSendResponse(uv_work_t *work, int status) {
   SUvUdfWork *udfWork = (SUvUdfWork *)(work->data);
 
+  if (udfWork->conn != NULL) {
     uv_write_t *write_req = taosMemoryMalloc(sizeof(uv_write_t));
     write_req->data = udfWork;
-  uv_write(write_req, udfWork->client, &udfWork->output, 1, udfdOnWrite);
+    uv_write(write_req, udfWork->conn->client, &udfWork->output, 1, udfdOnWrite);
-
+  }
   taosMemoryFree(work);
 }
 
@@ -744,10 +764,15 @@ bool isUdfdUvMsgComplete(SUdfdUvConn *pipe) {
 }
 
 void udfdHandleRequest(SUdfdUvConn *conn) {
+  char *inputBuf = conn->inputBuf;
+  int32_t inputLen = conn->inputLen;
+
   uv_work_t  *work = taosMemoryMalloc(sizeof(uv_work_t));
   SUvUdfWork *udfWork = taosMemoryMalloc(sizeof(SUvUdfWork));
-  udfWork->client = conn->client;
+  udfWork->conn = conn;
-  udfWork->input = uv_buf_init(conn->inputBuf, conn->inputLen);
+  udfWork->pWorkNext = conn->pWorkList;
+  conn->pWorkList = udfWork;
+  udfWork->input = uv_buf_init(inputBuf, inputLen);
   conn->inputBuf = NULL;
   conn->inputLen = 0;
   conn->inputCap = 0;
@@ -758,13 +783,19 @@ void udfdHandleRequest(SUdfdUvConn *conn) {
 
 void udfdPipeCloseCb(uv_handle_t *pipe) {
   SUdfdUvConn *conn = pipe->data;
+  SUvUdfWork* pWork = conn->pWorkList;
+  while (pWork != NULL) {
+    pWork->conn = NULL;
+    pWork = pWork->pWorkNext;
+  }
+
   taosMemoryFree(conn->client);
   taosMemoryFree(conn->inputBuf);
   taosMemoryFree(conn);
 }
 
 void udfdPipeRead(uv_stream_t *client, ssize_t nread, const uv_buf_t *buf) {
-  fnDebug("udf read %zd bytes from client", nread);
+  fnDebug("udfd read %zd bytes from client", nread);
   if (nread == 0) return;
 
   SUdfdUvConn *conn = client->data;
@@ -780,10 +811,10 @@ void udfdPipeRead(uv_stream_t *client, ssize_t nread, const uv_buf_t *buf) {
   }
 
   if (nread < 0) {
-    fnError("Receive error %s", uv_err_name(nread));
     if (nread == UV_EOF) {
-      // TODO check more when close
+      fnInfo("udfd pipe read EOF");
     } else {
+      fnError("Receive error %s", uv_err_name(nread));
     }
     udfdUvHandleError(conn);
   }
@@ -799,6 +830,7 @@ void udfdOnNewConnection(uv_stream_t *server, int status) {
   uv_pipe_init(global.loop, client, 0);
   if (uv_accept(server, (uv_stream_t *)client) == 0) {
     SUdfdUvConn *ctx = taosMemoryMalloc(sizeof(SUdfdUvConn));
+    ctx->pWorkList = NULL;
     ctx->client = (uv_stream_t *)client;
     ctx->inputBuf = 0;
     ctx->inputLen = 0;

source/libs/parser/inc/sql.y

@@ -194,7 +194,7 @@ db_options(A) ::= db_options(B) PAGESIZE NK_INTEGER(C).
 db_options(A) ::= db_options(B) TSDB_PAGESIZE NK_INTEGER(C).                      { A = setDatabaseOption(pCxt, B, DB_OPTION_TSDB_PAGESIZE, &C); }
 db_options(A) ::= db_options(B) PRECISION NK_STRING(C).                           { A = setDatabaseOption(pCxt, B, DB_OPTION_PRECISION, &C); }
 db_options(A) ::= db_options(B) REPLICA NK_INTEGER(C).                            { A = setDatabaseOption(pCxt, B, DB_OPTION_REPLICA, &C); }
-db_options(A) ::= db_options(B) STRICT NK_STRING(C).                              { A = setDatabaseOption(pCxt, B, DB_OPTION_STRICT, &C); }
+//db_options(A) ::= db_options(B) STRICT NK_STRING(C).                              { A = setDatabaseOption(pCxt, B, DB_OPTION_STRICT, &C); }
 db_options(A) ::= db_options(B) VGROUPS NK_INTEGER(C).                            { A = setDatabaseOption(pCxt, B, DB_OPTION_VGROUPS, &C); }
 db_options(A) ::= db_options(B) SINGLE_STABLE NK_INTEGER(C).                      { A = setDatabaseOption(pCxt, B, DB_OPTION_SINGLE_STABLE, &C); }
 db_options(A) ::= db_options(B) RETENTIONS retention_list(C).                     { A = setDatabaseOption(pCxt, B, DB_OPTION_RETENTIONS, C); }
@@ -232,7 +232,7 @@ alter_db_option(A) ::= KEEP integer_list(B).
 alter_db_option(A) ::= KEEP variable_list(B).                                     { A.type = DB_OPTION_KEEP; A.pList = B; }
 alter_db_option(A) ::= PAGES NK_INTEGER(B).                                       { A.type = DB_OPTION_PAGES; A.val = B; }
 alter_db_option(A) ::= REPLICA NK_INTEGER(B).                                     { A.type = DB_OPTION_REPLICA; A.val = B; }
-alter_db_option(A) ::= STRICT NK_STRING(B).                                       { A.type = DB_OPTION_STRICT; A.val = B; }
+//alter_db_option(A) ::= STRICT NK_STRING(B).                                       { A.type = DB_OPTION_STRICT; A.val = B; }
 alter_db_option(A) ::= WAL_LEVEL NK_INTEGER(B).                                   { A.type = DB_OPTION_WAL; A.val = B; }
 alter_db_option(A) ::= STT_TRIGGER NK_INTEGER(B).                                 { A.type = DB_OPTION_STT_TRIGGER; A.val = B; }
 
@@ -1067,5 +1067,5 @@ null_ordering_opt(A) ::= NULLS FIRST.
 null_ordering_opt(A) ::= NULLS LAST.                                              { A = NULL_ORDER_LAST; }
 
 %fallback ABORT AFTER ATTACH BEFORE BEGIN BITAND BITNOT BITOR BLOCKS CHANGE COMMA COMPACT CONCAT CONFLICT COPY DEFERRED DELIMITERS DETACH DIVIDE DOT EACH END FAIL 
-  FILE FOR GLOB ID IMMEDIATE IMPORT INITIALLY INSTEAD ISNULL KEY MODULES NK_BITNOT NK_SEMI NOTNULL OF PLUS PRIVILEGE RAISE REPLACE RESTRICT ROW SEMI STAR STATEMENT STRING 
+  FILE FOR GLOB ID IMMEDIATE IMPORT INITIALLY INSTEAD ISNULL KEY MODULES NK_BITNOT NK_SEMI NOTNULL OF PLUS PRIVILEGE RAISE REPLACE RESTRICT ROW SEMI STAR STATEMENT
-  TIMES UPDATE VALUES VARIABLE VIEW WAL.
+  STRICT STRING TIMES UPDATE VALUES VARIABLE VIEW WAL.

source/libs/parser/src/parInsertSql.c

@@ -563,7 +563,8 @@ static int32_t parseTagValue(SInsertParseContext* pCxt, SVnodeModifOpStmt* pStmt
 
 static void buildCreateTbReq(SVnodeModifOpStmt* pStmt, STag* pTag, SArray* pTagName) {
   insBuildCreateTbReq(&pStmt->createTblReq, pStmt->targetTableName.tname, pTag, pStmt->pTableMeta->suid,
-                      pStmt->usingTableName.tname, pTagName, pStmt->pTableMeta->tableInfo.numOfTags, TSDB_DEFAULT_TABLE_TTL);
+                      pStmt->usingTableName.tname, pTagName, pStmt->pTableMeta->tableInfo.numOfTags,
+                      TSDB_DEFAULT_TABLE_TTL);
 }
 
 static int32_t checkAndTrimValue(SToken* pToken, char* tmpTokenBuf, SMsgBuf* pMsgBuf) {
@@ -829,6 +830,44 @@ static int32_t getTableVgroup(SParseContext* pCxt, SVnodeModifOpStmt* pStmt, boo
   return code;
 }
 
+static int32_t getTableMetaAndVgroupImpl(SParseContext* pCxt, SVnodeModifOpStmt* pStmt, bool* pMissCache) {
+  SVgroupInfo vg;
+  int32_t     code = catalogGetCachedTableVgMeta(pCxt->pCatalog, &pStmt->targetTableName, &vg, &pStmt->pTableMeta);
+  if (TSDB_CODE_SUCCESS == code) {
+    if (NULL != pStmt->pTableMeta) {
+      code = taosHashPut(pStmt->pVgroupsHashObj, (const char*)&vg.vgId, sizeof(vg.vgId), (char*)&vg, sizeof(vg));
+    }
+    *pMissCache = (NULL == pStmt->pTableMeta);
+  }
+  return code;
+}
+
+static int32_t getTableMetaAndVgroup(SInsertParseContext* pCxt, SVnodeModifOpStmt* pStmt, bool* pMissCache) {
+  SParseContext* pComCxt = pCxt->pComCxt;
+  int32_t        code = TSDB_CODE_SUCCESS;
+  if (pComCxt->async) {
+    code = getTableMetaAndVgroupImpl(pComCxt, pStmt, pMissCache);
+  } else {
+    code = getTableMeta(pCxt, &pStmt->targetTableName, false, &pStmt->pTableMeta, pMissCache);
+    if (TSDB_CODE_SUCCESS == code && !pCxt->missCache) {
+      code = getTableVgroup(pCxt->pComCxt, pStmt, false, &pCxt->missCache);
+    }
+  }
+  return code;
+}
+
+static int32_t collectUseTable(const SName* pName, SHashObj* pTable) {
+  char fullName[TSDB_TABLE_FNAME_LEN];
+  tNameExtractFullName(pName, fullName);
+  return taosHashPut(pTable, fullName, strlen(fullName), pName, sizeof(SName));
+}
+
+static int32_t collectUseDatabase(const SName* pName, SHashObj* pDbs) {
+  char dbFName[TSDB_DB_FNAME_LEN] = {0};
+  tNameGetFullDbName(pName, dbFName);
+  return taosHashPut(pDbs, dbFName, strlen(dbFName), dbFName, sizeof(dbFName));
+}
+
 static int32_t getTargetTableSchema(SInsertParseContext* pCxt, SVnodeModifOpStmt* pStmt) {
   if (pCxt->forceUpdate) {
     pCxt->missCache = true;
@@ -836,12 +875,24 @@ static int32_t getTargetTableSchema(SInsertParseContext* pCxt, SVnodeModifOpStmt
   }
 
   int32_t code = checkAuth(pCxt->pComCxt, &pStmt->targetTableName, &pCxt->missCache);
+#if 0
   if (TSDB_CODE_SUCCESS == code && !pCxt->missCache) {
     code = getTableMeta(pCxt, &pStmt->targetTableName, false, &pStmt->pTableMeta, &pCxt->missCache);
   }
   if (TSDB_CODE_SUCCESS == code && !pCxt->missCache) {
     code = getTableVgroup(pCxt->pComCxt, pStmt, false, &pCxt->missCache);
   }
+#else
+  if (TSDB_CODE_SUCCESS == code && !pCxt->missCache) {
+    code = getTableMetaAndVgroup(pCxt, pStmt, &pCxt->missCache);
+  }
+#endif
+  if (TSDB_CODE_SUCCESS == code && !pCxt->pComCxt->async) {
+    code = collectUseDatabase(&pStmt->targetTableName, pStmt->pDbFNameHashObj);
+    if (TSDB_CODE_SUCCESS == code) {
+      code = collectUseTable(&pStmt->targetTableName, pStmt->pTableNameHashObj);
+    }
+  }
   return code;
 }
 
@@ -862,6 +913,12 @@ static int32_t getUsingTableSchema(SInsertParseContext* pCxt, SVnodeModifOpStmt*
   if (TSDB_CODE_SUCCESS == code && !pCxt->missCache) {
     code = getTableVgroup(pCxt->pComCxt, pStmt, true, &pCxt->missCache);
   }
+  if (TSDB_CODE_SUCCESS == code && !pCxt->pComCxt->async) {
+    code = collectUseDatabase(&pStmt->usingTableName, pStmt->pDbFNameHashObj);
+    if (TSDB_CODE_SUCCESS == code) {
+      code = collectUseTable(&pStmt->usingTableName, pStmt->pTableNameHashObj);
+    }
+  }
   return code;
 }
 
@@ -934,10 +991,9 @@ static int32_t getTableDataBlocks(SInsertParseContext* pCxt, SVnodeModifOpStmt*
       pStmt->pTableMeta->uid = 0;
     }
 
-    return insGetDataBlockFromList(pStmt->pTableBlockHashObj, &uid, sizeof(pStmt->pTableMeta->uid),
+    return insGetDataBlockFromList(
-                                   TSDB_DEFAULT_PAYLOAD_SIZE, sizeof(SSubmitBlk),
+        pStmt->pTableBlockHashObj, &uid, sizeof(pStmt->pTableMeta->uid), TSDB_DEFAULT_PAYLOAD_SIZE, sizeof(SSubmitBlk),
-                                   getTableInfo(pStmt->pTableMeta).rowSize, pStmt->pTableMeta, pDataBuf, NULL,
+        getTableInfo(pStmt->pTableMeta).rowSize, pStmt->pTableMeta, pDataBuf, NULL, &pStmt->createTblReq);
-                                   &pStmt->createTblReq);
   }
   char tbFName[TSDB_TABLE_FNAME_LEN];
   tNameExtractFullName(&pStmt->targetTableName, tbFName);
@@ -1540,8 +1596,9 @@ static int32_t setStmtInfo(SInsertParseContext* pCxt, SVnodeModifOpStmt* pStmt)
   memcpy(tags, &pCxt->tags, sizeof(pCxt->tags));
 
   SStmtCallback* pStmtCb = pCxt->pComCxt->pStmtCb;
-  int32_t code = (*pStmtCb->setInfoFn)(pStmtCb->pStmt, pStmt->pTableMeta, tags, &pStmt->targetTableName, pStmt->usingTableProcessing,
+  int32_t        code = (*pStmtCb->setInfoFn)(pStmtCb->pStmt, pStmt->pTableMeta, tags, &pStmt->targetTableName,
-                                       pStmt->pVgroupsHashObj, pStmt->pTableBlockHashObj, pStmt->usingTableName.tname);
+                                       pStmt->usingTableProcessing, pStmt->pVgroupsHashObj, pStmt->pTableBlockHashObj,
+                                       pStmt->usingTableName.tname);
 
   memset(&pCxt->tags, 0, sizeof(pCxt->tags));
   pStmt->pVgroupsHashObj = NULL;
@@ -1776,17 +1833,26 @@ static int32_t initInsertQuery(SInsertParseContext* pCxt, SCatalogReq* pCatalogR
 
 static int32_t setRefreshMate(SQuery* pQuery) {
   SVnodeModifOpStmt* pStmt = (SVnodeModifOpStmt*)pQuery->pRoot;
+
+  if (taosHashGetSize(pStmt->pTableNameHashObj) > 0) {
+    taosArrayDestroy(pQuery->pTableList);
+    pQuery->pTableList = taosArrayInit(taosHashGetSize(pStmt->pTableNameHashObj), sizeof(SName));
     SName* pTable = taosHashIterate(pStmt->pTableNameHashObj, NULL);
     while (NULL != pTable) {
       taosArrayPush(pQuery->pTableList, pTable);
       pTable = taosHashIterate(pStmt->pTableNameHashObj, pTable);
     }
+  }
 
+  if (taosHashGetSize(pStmt->pDbFNameHashObj) > 0) {
+    taosArrayDestroy(pQuery->pDbList);
+    pQuery->pDbList = taosArrayInit(taosHashGetSize(pStmt->pDbFNameHashObj), TSDB_DB_FNAME_LEN);
     char* pDb = taosHashIterate(pStmt->pDbFNameHashObj, NULL);
     while (NULL != pDb) {
       taosArrayPush(pQuery->pDbList, pDb);
       pDb = taosHashIterate(pStmt->pDbFNameHashObj, pDb);
     }
+  }
 
   return TSDB_CODE_SUCCESS;
 }
@@ -1899,29 +1965,28 @@ static int32_t buildInsertCatalogReq(SInsertParseContext* pCxt, SVnodeModifOpStm
 }
 
 static int32_t setNextStageInfo(SInsertParseContext* pCxt, SQuery* pQuery, SCatalogReq* pCatalogReq) {
+  SVnodeModifOpStmt* pStmt = (SVnodeModifOpStmt*)pQuery->pRoot;
   if (pCxt->missCache) {
-    parserDebug("0x%" PRIx64 " %d rows have been inserted before cache miss", pCxt->pComCxt->requestId,
+    parserDebug("0x%" PRIx64 " %d rows of %d tables have been inserted before cache miss", pCxt->pComCxt->requestId,
-                ((SVnodeModifOpStmt*)pQuery->pRoot)->totalRowsNum);
+                pStmt->totalRowsNum, pStmt->totalTbNum);
 
     pQuery->execStage = QUERY_EXEC_STAGE_PARSE;
-    return buildInsertCatalogReq(pCxt, (SVnodeModifOpStmt*)pQuery->pRoot, pCatalogReq);
+    return buildInsertCatalogReq(pCxt, pStmt, pCatalogReq);
   }
 
-  parserDebug("0x%" PRIx64 " %d rows have been inserted", pCxt->pComCxt->requestId,
+  parserDebug("0x%" PRIx64 " %d rows of %d tables have been inserted", pCxt->pComCxt->requestId, pStmt->totalRowsNum,
-              ((SVnodeModifOpStmt*)pQuery->pRoot)->totalRowsNum);
+              pStmt->totalTbNum);
 
   pQuery->execStage = QUERY_EXEC_STAGE_SCHEDULE;
   return TSDB_CODE_SUCCESS;
 }
 
 int32_t parseInsertSql(SParseContext* pCxt, SQuery** pQuery, SCatalogReq* pCatalogReq, const SMetaData* pMetaData) {
-  SInsertParseContext context = {
+  SInsertParseContext context = {.pComCxt = pCxt,
-      .pComCxt = pCxt,
                                  .msg = {.buf = pCxt->pMsg, .len = pCxt->msgLen},
                                  .missCache = false,
                                  .usingDuplicateTable = false,
-      .forceUpdate = (NULL != pCatalogReq ? pCatalogReq->forceUpdate : false)
+                                 .forceUpdate = (NULL != pCatalogReq ? pCatalogReq->forceUpdate : false)};
-  };
 
   int32_t code = initInsertQuery(&context, pCatalogReq, pMetaData, pQuery);
   if (TSDB_CODE_SUCCESS == code) {

source/libs/parser/src/parTranslater.c

@@ -2837,7 +2837,7 @@ static int32_t rewriteProjectAlias(SNodeList* pProjectionList) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t checkProjectAlias(STranslateContext* pCxt, SNodeList* pProjectionList) {
+static int32_t checkProjectAlias(STranslateContext* pCxt, SNodeList* pProjectionList, SHashObj** pOutput) {
   SHashObj* pUserAliasSet = taosHashInit(LIST_LENGTH(pProjectionList),
                                          taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
   SNode*    pProject = NULL;
@@ -2849,13 +2849,17 @@ static int32_t checkProjectAlias(STranslateContext* pCxt, SNodeList* pProjection
     }
     taosHashPut(pUserAliasSet, pExpr->userAlias, strlen(pExpr->userAlias), &pExpr, POINTER_BYTES);
   }
+  if (NULL == pOutput) {
     taosHashCleanup(pUserAliasSet);
+  } else {
+    *pOutput = pUserAliasSet;
+  }
   return TSDB_CODE_SUCCESS;
 }
 
 static int32_t translateProjectionList(STranslateContext* pCxt, SSelectStmt* pSelect) {
   if (pSelect->isSubquery) {
-    return checkProjectAlias(pCxt, pSelect->pProjectionList);
+    return checkProjectAlias(pCxt, pSelect->pProjectionList, NULL);
   }
   return rewriteProjectAlias(pSelect->pProjectionList);
 }
@@ -3879,12 +3883,16 @@ static int32_t checkDbKeepOption(STranslateContext* pCxt, SDatabaseOptions* pOpt
     pOptions->keep[2] = getBigintFromValueNode((SValueNode*)nodesListGetNode(pOptions->pKeep, 2));
   }
 
+  int64_t tsdbMaxKeep = TSDB_MAX_KEEP;
+  if (pOptions->precision == TSDB_TIME_PRECISION_NANO) {
+    tsdbMaxKeep = TSDB_MAX_KEEP_NS;
+  }
+
   if (pOptions->keep[0] < TSDB_MIN_KEEP || pOptions->keep[1] < TSDB_MIN_KEEP || pOptions->keep[2] < TSDB_MIN_KEEP ||
-      pOptions->keep[0] > TSDB_MAX_KEEP || pOptions->keep[1] > TSDB_MAX_KEEP || pOptions->keep[2] > TSDB_MAX_KEEP) {
+      pOptions->keep[0] > tsdbMaxKeep || pOptions->keep[1] > tsdbMaxKeep || pOptions->keep[2] > tsdbMaxKeep) {
     return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_DB_OPTION,
                                    "Invalid option keep: %" PRId64 ", %" PRId64 ", %" PRId64 " valid range: [%dm, %dm]",
-                                   pOptions->keep[0], pOptions->keep[1], pOptions->keep[2], TSDB_MIN_KEEP,
+                                   pOptions->keep[0], pOptions->keep[1], pOptions->keep[2], TSDB_MIN_KEEP, tsdbMaxKeep);
-                                   TSDB_MAX_KEEP);
   }
 
   if (!((pOptions->keep[0] <= pOptions->keep[1]) && (pOptions->keep[1] <= pOptions->keep[2]))) {
@@ -4036,7 +4044,10 @@ static int32_t checkDatabaseOptions(STranslateContext* pCxt, const char* pDbName
                               TSDB_MAX_MINROWS_FBLOCK);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = checkDbKeepOption(pCxt, pOptions);
+    code = checkDbPrecisionOption(pCxt, pOptions);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = checkDbKeepOption(pCxt, pOptions);  // use precision
   }
   if (TSDB_CODE_SUCCESS == code) {
     code = checkDbRangeOption(pCxt, "pages", pOptions->pages, TSDB_MIN_PAGES_PER_VNODE, TSDB_MAX_PAGES_PER_VNODE);
@@ -4049,9 +4060,6 @@ static int32_t checkDatabaseOptions(STranslateContext* pCxt, const char* pDbName
     code = checkDbRangeOption(pCxt, "tsdbPagesize", pOptions->tsdbPageSize, TSDB_MIN_TSDB_PAGESIZE,
                               TSDB_MAX_TSDB_PAGESIZE);
   }
-  if (TSDB_CODE_SUCCESS == code) {
-    code = checkDbPrecisionOption(pCxt, pOptions);
-  }
   if (TSDB_CODE_SUCCESS == code) {
     code = checkDbEnumOption(pCxt, "replications", pOptions->replica, TSDB_MIN_DB_REPLICA, TSDB_MAX_DB_REPLICA);
   }
@@ -5499,8 +5507,23 @@ static void getSourceDatabase(SNode* pStmt, int32_t acctId, char* pDbFName) {
   tNameGetFullDbName(&name, pDbFName);
 }
 
-static int32_t addWstartTsToCreateStreamQuery(SNode* pStmt) {
+static void getStreamQueryFirstProjectAliasName(SHashObj* pUserAliasSet, char* aliasName, int32_t len) {
-  SSelectStmt* pSelect = (SSelectStmt*)pStmt;
+  if (NULL == taosHashGet(pUserAliasSet, "_wstart", strlen("_wstart"))) {
+    snprintf(aliasName, len, "%s", "_wstart");
+    return;
+  }
+  if (NULL == taosHashGet(pUserAliasSet, "ts", strlen("ts"))) {
+    snprintf(aliasName, len, "%s", "ts");
+    return;
+  }
+  do {
+    taosRandStr(aliasName, len - 1);
+    aliasName[len - 1] = '\0';
+  } while (NULL != taosHashGet(pUserAliasSet, aliasName, strlen(aliasName)));
+  return;
+}
+
+static int32_t addWstartTsToCreateStreamQueryImpl(SSelectStmt* pSelect, SHashObj* pUserAliasSet) {
   SNode* pProj = nodesListGetNode(pSelect->pProjectionList, 0);
   if (NULL == pSelect->pWindow ||
       (QUERY_NODE_FUNCTION == nodeType(pProj) && 0 == strcmp("_wstart", ((SFunctionNode*)pProj)->functionName))) {
@@ -5511,7 +5534,7 @@ static int32_t addWstartTsToCreateStreamQuery(SNode* pStmt) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }
   strcpy(pFunc->functionName, "_wstart");
-  strcpy(pFunc->node.aliasName, pFunc->functionName);
+  getStreamQueryFirstProjectAliasName(pUserAliasSet, pFunc->node.aliasName, sizeof(pFunc->node.aliasName));
   int32_t code = nodesListPushFront(pSelect->pProjectionList, (SNode*)pFunc);
   if (TSDB_CODE_SUCCESS != code) {
     nodesDestroyNode((SNode*)pFunc);
@@ -5519,6 +5542,17 @@ static int32_t addWstartTsToCreateStreamQuery(SNode* pStmt) {
   return code;
 }
 
+static int32_t addWstartTsToCreateStreamQuery(STranslateContext* pCxt, SNode* pStmt) {
+  SSelectStmt* pSelect = (SSelectStmt*)pStmt;
+  SHashObj*    pUserAliasSet = NULL;
+  int32_t      code = checkProjectAlias(pCxt, pSelect->pProjectionList, &pUserAliasSet);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = addWstartTsToCreateStreamQueryImpl(pSelect, pUserAliasSet);
+  }
+  taosHashCleanup(pUserAliasSet);
+  return code;
+}
+
 static int32_t addTagsToCreateStreamQuery(STranslateContext* pCxt, SCreateStreamStmt* pStmt, SSelectStmt* pSelect) {
   if (NULL == pStmt->pTags) {
     return TSDB_CODE_SUCCESS;
@@ -5621,7 +5655,7 @@ static int32_t checkStreamQuery(STranslateContext* pCxt, SSelectStmt* pSelect) {
 
 static int32_t buildCreateStreamQuery(STranslateContext* pCxt, SCreateStreamStmt* pStmt, SCMCreateStreamReq* pReq) {
   pCxt->createStream = true;
-  int32_t code = addWstartTsToCreateStreamQuery(pStmt->pQuery);
+  int32_t code = addWstartTsToCreateStreamQuery(pCxt, pStmt->pQuery);
   if (TSDB_CODE_SUCCESS == code) {
     code = addSubtableInfoToCreateStreamQuery(pCxt, pStmt);
   }

source/libs/parser/test/mockCatalog.cpp

@@ -248,6 +248,13 @@ int32_t __catalogGetCachedTableHashVgroup(SCatalog* pCtg, const SName* pTableNam
   return code;
 }
 
+int32_t __catalogGetCachedTableVgMeta(SCatalog* pCtg, const SName* pTableName,          SVgroupInfo* pVgroup, STableMeta** pTableMeta) {
+  int32_t code = g_mockCatalogService->catalogGetTableMeta(pTableName, pTableMeta, true);
+  if (code) return code;
+  code = g_mockCatalogService->catalogGetTableHashVgroup(pTableName, pVgroup, true);
+  return code;
+}
+
 int32_t __catalogGetTableDistVgInfo(SCatalog* pCtg, SRequestConnInfo* pConn, const SName* pTableName,
                                     SArray** pVgList) {
   return g_mockCatalogService->catalogGetTableDistVgInfo(pTableName, pVgList);
@@ -316,6 +323,7 @@ void initMetaDataEnv() {
   stub.set(catalogGetCachedSTableMeta, __catalogGetCachedTableMeta);
   stub.set(catalogGetTableHashVgroup, __catalogGetTableHashVgroup);
   stub.set(catalogGetCachedTableHashVgroup, __catalogGetCachedTableHashVgroup);
+  stub.set(catalogGetCachedTableVgMeta, __catalogGetCachedTableVgMeta);
   stub.set(catalogGetTableDistVgInfo, __catalogGetTableDistVgInfo);
   stub.set(catalogGetDBVgVersion, __catalogGetDBVgVersion);
   stub.set(catalogGetDBVgList, __catalogGetDBVgList);

source/libs/parser/test/parInitialCTest.cpp

@@ -48,7 +48,7 @@ TEST_F(ParserInitialCTest, createAccount) {
  *   | PRECISION {'ms' | 'us' | 'ns'}
  *   | REPLICA value
  *   | RETENTIONS ingestion_duration:keep_duration ...
- *   | STRICT {'off' | 'on'}
+ *   | STRICT {'off' | 'on'}  // not support
  *   | WAL_LEVEL value
  *   | VGROUPS value
  *   | SINGLE_STABLE {0 | 1}
@@ -216,7 +216,7 @@ TEST_F(ParserInitialCTest, createDatabase) {
   addDbRetentionFunc(15 * MILLISECOND_PER_SECOND, 7 * MILLISECOND_PER_DAY, TIME_UNIT_SECOND, TIME_UNIT_DAY);
   addDbRetentionFunc(1 * MILLISECOND_PER_MINUTE, 21 * MILLISECOND_PER_DAY, TIME_UNIT_MINUTE, TIME_UNIT_DAY);
   addDbRetentionFunc(15 * MILLISECOND_PER_MINUTE, 500 * MILLISECOND_PER_DAY, TIME_UNIT_MINUTE, TIME_UNIT_DAY);
-  setDbStrictaFunc(1);
+  // setDbStrictaFunc(1);
   setDbWalLevelFunc(2);
   setDbVgroupsFunc(100);
   setDbSingleStableFunc(1);
@@ -244,7 +244,7 @@ TEST_F(ParserInitialCTest, createDatabase) {
       "PRECISION 'ns' "
       "REPLICA 3 "
       "RETENTIONS 15s:7d,1m:21d,15m:500d "
-      "STRICT 'on' "
+      //      "STRICT 'on' "
       "WAL_LEVEL 2 "
       "VGROUPS 100 "
       "SINGLE_STABLE 1 "

source/libs/qworker/inc/qwInt.h

@@ -31,7 +31,7 @@ extern "C" {
 
 #define QW_DEFAULT_SCHEDULER_NUMBER 100
 #define QW_DEFAULT_TASK_NUMBER      10000
-#define QW_DEFAULT_SCH_TASK_NUMBER  10000
+#define QW_DEFAULT_SCH_TASK_NUMBER  500
 #define QW_DEFAULT_SHORT_RUN_TIMES  2
 #define QW_DEFAULT_HEARTBEAT_MSEC   5000
 #define QW_SCH_TIMEOUT_MSEC         180000

source/libs/qworker/src/qwUtil.c

@@ -74,6 +74,8 @@ int32_t qwAddSchedulerImpl(SQWorker *mgmt, uint64_t sId, int32_t rwType) {
   SQWSchStatus newSch = {0};
   newSch.tasksHash =
       taosHashInit(mgmt->cfg.maxSchTaskNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
+  newSch.hbBrokenTs = taosGetTimestampMs();
+
   if (NULL == newSch.tasksHash) {
     QW_SCH_ELOG("taosHashInit %d failed", mgmt->cfg.maxSchTaskNum);
     QW_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
@@ -463,6 +465,8 @@ void qwDestroyImpl(void *pMgmt) {
   int8_t    nodeType = mgmt->nodeType;
   int32_t   nodeId = mgmt->nodeId;
 
+  int32_t taskCount = 0;
+  int32_t schStatusCount = 0;
   qDebug("start to destroy qworker, type:%d, id:%d, handle:%p", nodeType, nodeId, mgmt);
 
   taosTmrStop(mgmt->hbTimer);
@@ -472,6 +476,7 @@ void qwDestroyImpl(void *pMgmt) {
   uint64_t qId, tId;
   int32_t  eId;
   void    *pIter = taosHashIterate(mgmt->ctxHash, NULL);
+
   while (pIter) {
     SQWTaskCtx *ctx = (SQWTaskCtx *)pIter;
     void       *key = taosHashGetKey(pIter, NULL);
@@ -480,6 +485,7 @@ void qwDestroyImpl(void *pMgmt) {
     qwFreeTaskCtx(ctx);
     QW_TASK_DLOG_E("task ctx freed");
     pIter = taosHashIterate(mgmt->ctxHash, pIter);
+    taskCount++;
   }
   taosHashCleanup(mgmt->ctxHash);
 
@@ -487,7 +493,9 @@ void qwDestroyImpl(void *pMgmt) {
   while (pIter) {
     SQWSchStatus *sch = (SQWSchStatus *)pIter;
     qwDestroySchStatus(sch);
+
     pIter = taosHashIterate(mgmt->schHash, pIter);
+    schStatusCount++;
   }
   taosHashCleanup(mgmt->schHash);
 
@@ -499,7 +507,8 @@ void qwDestroyImpl(void *pMgmt) {
 
   qwCloseRef();
 
-  qDebug("qworker destroyed, type:%d, id:%d, handle:%p", nodeType, nodeId, mgmt);
+  qDebug("qworker destroyed, type:%d, id:%d, handle:%p, taskCount:%d, schStatusCount: %d", nodeType, nodeId, mgmt,
+         taskCount, schStatusCount);
 }
 
 int32_t qwOpenRef(void) {