Merge branch 'main' of https://github.com/taosdata/TDengine into mark/sml

2023-06-25 15:16:04 +08:00 · 2023-06-25 15:16:04 +08:00 · 57d567b074
parent 978f639851 3b394b7299
commit 57d567b074
111 changed files with 7982 additions and 1820 deletions
--- a/.gitignore
+++ b/.gitignore
@ -16,7 +16,6 @@ debug/
 release/
 target/
 debs/
-deps/
 rpms/
 mac/
 *.pyc
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -15,11 +15,15 @@ SET(TD_COMMUNITY_DIR ${PROJECT_SOURCE_DIR})
 set(TD_SUPPORT_DIR "${TD_SOURCE_DIR}/cmake")
 set(TD_CONTRIB_DIR "${TD_SOURCE_DIR}/contrib")

+
+
+
 include(${TD_SUPPORT_DIR}/cmake.platform)
 include(${TD_SUPPORT_DIR}/cmake.define)
 include(${TD_SUPPORT_DIR}/cmake.options)
 include(${TD_SUPPORT_DIR}/cmake.version)

+
 # contrib
 add_subdirectory(contrib)

--- a/README-CN.md
+++ b/README-CN.md
@ -68,14 +68,14 @@ sudo apt install build-essential libjansson-dev libsnappy-dev liblzma-dev libz-d
 ```bash
 sudo yum install epel-release
 sudo yum update
-sudo yum install -y gcc gcc-c++ make cmake3 git openssl-devel
+sudo yum install -y gcc gcc-c++ make cmake3 gflags git openssl-devel
 sudo ln -sf /usr/bin/cmake3 /usr/bin/cmake
 ```

 ### CentOS 8/Fedora/Rocky Linux

 ```bash
-sudo dnf install -y gcc gcc-c++ make cmake epel-release git openssl-devel
+sudo dnf install -y gcc gcc-c++ gflags make cmake epel-release git openssl-devel
 ```

 #### 在 CentOS 上构建 taosTools 安装依赖软件
@ -117,7 +117,7 @@ scl enable devtoolset-9 -- bash
 ### macOS

 ```
-brew install argp-standalone pkgconfig
+brew install argp-standalone gflags pkgconfig
 ```

 ### 设置 golang 开发环境
--- a/README.md
+++ b/README.md
@ -76,14 +76,14 @@ sudo apt install build-essential libjansson-dev libsnappy-dev liblzma-dev libz-d
 ```bash
 sudo yum install epel-release
 sudo yum update
-sudo yum install -y gcc gcc-c++ make cmake3 git openssl-devel
+sudo yum install -y gcc gcc-c++ make cmake3 gflags git openssl-devel
 sudo ln -sf /usr/bin/cmake3 /usr/bin/cmake
 ```

 ### CentOS 8/Fedora/Rocky Linux

 ```bash
-sudo dnf install -y gcc gcc-c++ make cmake epel-release git openssl-devel
+sudo dnf install -y gcc gcc-c++ make cmake epel-release gflags git openssl-devel
 ```

 #### Install build dependencies for taosTools on CentOS
@ -124,7 +124,7 @@ scl enable devtoolset-9 -- bash
 ### macOS

 ```
-brew install argp-standalone pkgconfig
+brew install argp-standalone gflags pkgconfig
 ```

 ### Setup golang environment
--- a/cmake/cmake.define
+++ b/cmake/cmake.define
@ -115,18 +115,6 @@ ELSE ()
        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${GCC_COVERAGE_COMPILE_FLAGS} ${GCC_COVERAGE_LINK_FLAGS}")
    ENDIF ()

-    IF (${BUILD_SANITIZER})
-        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}     -Werror -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize=undefined -fsanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=shift-base -fno-sanitize=alignment -g3 -Wformat=0")
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-literal-suffix -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize=undefined -fsanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=shift-base -fno-sanitize=alignment -g3 -Wformat=0")
-	      MESSAGE(STATUS "Compile with Address Sanitizer!")
-    ELSEIF (${BUILD_RELEASE})
-        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Werror=return-type -fPIC -O3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wno-reserved-user-defined-literal -Wno-literal-suffix -Werror=return-type -fPIC -O3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
-    ELSE ()
-        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Werror=return-type -fPIC -g3 -gdwarf-2 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-reserved-user-defined-literal -g3 -Wno-literal-suffix -Werror=return-type -fPIC -gdwarf-2 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
-    ENDIF ()
-
    # disable all assert
    IF ((${DISABLE_ASSERT} MATCHES "true") OR (${DISABLE_ASSERTS} MATCHES "true"))
        ADD_DEFINITIONS(-DDISABLE_ASSERT)
@ -168,4 +156,20 @@ ELSE ()
        MESSAGE(STATUS "SIMD instructions (FMA/AVX/AVX2) is ACTIVATED")
    ENDIF()

+    # build mode
+    SET(CMAKE_C_FLAGS_REL "${CMAKE_C_FLAGS} -Werror -Werror=return-type -fPIC -O3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
+    SET(CMAKE_CXX_FLAGS_REL "${CMAKE_CXX_FLAGS} -Werror -Wno-reserved-user-defined-literal -Wno-literal-suffix -Werror=return-type -fPIC -O3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
+
+    IF (${BUILD_SANITIZER})
+        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}     -Werror -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize=undefined -fsanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=shift-base -fno-sanitize=alignment -g3 -Wformat=0")
+        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-literal-suffix -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize=undefined -fsanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=shift-base -fno-sanitize=alignment -g3 -Wformat=0")
+	      MESSAGE(STATUS "Compile with Address Sanitizer!")
+    ELSEIF (${BUILD_RELEASE})
+        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS_REL}")
+        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_REL}")
+    ELSE ()
+        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Werror=return-type -fPIC -g3 -gdwarf-2 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
+        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-reserved-user-defined-literal -g3 -Wno-literal-suffix -Werror=return-type -fPIC -gdwarf-2 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
+    ENDIF ()
+
 ENDIF ()
--- a/cmake/cmake.options
+++ b/cmake/cmake.options
@ -189,3 +189,9 @@ option(
   "If build release version"
   OFF
 )
+
+option(
+   BUILD_CONTRIB
+   "If build thirdpart from source"
+   OFF
+)
--- a/cmake/cmake.platform
+++ b/cmake/cmake.platform
@ -172,5 +172,15 @@ ENDIF()

 MESSAGE(STATUS "Platform arch:" ${PLATFORM_ARCH_STR})

+set(TD_DEPS_DIR "x86")
+if (TD_LINUX)
+  IF (TD_ARM_64 OR TD_ARM_32)
+    set(TD_DEPS_DIR "arm")
+  ELSE() 
+    set(TD_DEPS_DIR "x86")
+  ENDIF()
+endif()
+MESSAGE(STATUS "DEPS_DIR" ${TD_DEPS_DIR})
+
 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})")
--- a/cmake/cmake.version
+++ b/cmake/cmake.version
@ -2,7 +2,7 @@
 IF (DEFINED VERNUMBER)
  SET(TD_VER_NUMBER ${VERNUMBER})
 ELSE ()
-  SET(TD_VER_NUMBER "3.0.5.0")
+  SET(TD_VER_NUMBER "3.0.5.2.alpha")
 ENDIF ()

 IF (DEFINED VERCOMPATIBLE)
--- a/cmake/rocksdb_CMakeLists.txt.in
+++ b/cmake/rocksdb_CMakeLists.txt.in
@ -1,11 +1,29 @@

 # rocksdb
-ExternalProject_Add(rocksdb
-        GIT_REPOSITORY https://github.com/facebook/rocksdb.git
-        GIT_TAG v8.1.1
-        SOURCE_DIR "${TD_CONTRIB_DIR}/rocksdb"
-        CONFIGURE_COMMAND ""
-        BUILD_COMMAND ""
-        INSTALL_COMMAND ""
-        TEST_COMMAND ""
+if (${BUILD_CONTRIB})
+        ExternalProject_Add(rocksdb
+	        URL https://github.com/facebook/rocksdb/archive/refs/tags/v8.1.1.tar.gz
+  	        URL_HASH MD5=3b4c97ee45df9c8a5517308d31ab008b
+  	        DOWNLOAD_NO_PROGRESS 1
+	        DOWNLOAD_DIR "${TD_CONTRIB_DIR}/deps-download" 
+	        SOURCE_DIR "${TD_CONTRIB_DIR}/rocksdb" 
+            CONFIGURE_COMMAND ""
+            BUILD_COMMAND ""
+            INSTALL_COMMAND ""
+            TEST_COMMAND ""
        )
+else()
+    if (NOT ${TD_LINUX})
+        ExternalProject_Add(rocksdb
+	        URL https://github.com/facebook/rocksdb/archive/refs/tags/v8.1.1.tar.gz
+  	        URL_HASH MD5=3b4c97ee45df9c8a5517308d31ab008b
+  	        DOWNLOAD_NO_PROGRESS 1
+	        DOWNLOAD_DIR "${TD_CONTRIB_DIR}/deps-download" 
+	        SOURCE_DIR "${TD_CONTRIB_DIR}/rocksdb" 
+            CONFIGURE_COMMAND ""
+            BUILD_COMMAND ""
+            INSTALL_COMMAND ""
+            TEST_COMMAND ""
+        )
+    endif()
+endif()
--- a/cmake/taosadapter_CMakeLists.txt.in
+++ b/cmake/taosadapter_CMakeLists.txt.in
@ -2,7 +2,7 @@
 # taosadapter
 ExternalProject_Add(taosadapter
        GIT_REPOSITORY https://github.com/taosdata/taosadapter.git
-        GIT_TAG 3.0
+        GIT_TAG main
        SOURCE_DIR "${TD_SOURCE_DIR}/tools/taosadapter"
        BINARY_DIR ""
        #BUILD_IN_SOURCE TRUE
--- a/contrib/CMakeLists.txt
+++ b/contrib/CMakeLists.txt
@ -77,11 +77,25 @@ if(${BUILD_WITH_LEVELDB})
    cat("${TD_SUPPORT_DIR}/leveldb_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
 endif(${BUILD_WITH_LEVELDB})

-# rocksdb
-if(${BUILD_WITH_ROCKSDB})
-    cat("${TD_SUPPORT_DIR}/rocksdb_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
-    add_definitions(-DUSE_ROCKSDB)
-endif(${BUILD_WITH_ROCKSDB})
+
+if (${BUILD_CONTRIB})
+    if(${BUILD_WITH_ROCKSDB})
+        cat("${TD_SUPPORT_DIR}/rocksdb_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
+        add_definitions(-DUSE_ROCKSDB)
+    endif()
+else() 
+    if (NOT ${TD_LINUX})
+        if(${BUILD_WITH_ROCKSDB})
+            cat("${TD_SUPPORT_DIR}/rocksdb_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
+            add_definitions(-DUSE_ROCKSDB)
+        endif(${BUILD_WITH_ROCKSDB})
+    else()
+        if(${BUILD_WITH_ROCKSDB})
+            add_definitions(-DUSE_ROCKSDB)
+        endif(${BUILD_WITH_ROCKSDB})
+    endif()
+endif()
+

 # canonical-raft
 if(${BUILD_WITH_CRAFT})
@ -175,8 +189,8 @@ if(${BUILD_TEST})
            PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/cpp-stub/src_darwin>
        )
    endif(${TD_DARWIN})
-    
-    
+
+
 endif(${BUILD_TEST})

 # cJson
@ -227,63 +241,113 @@ endif(${BUILD_WITH_LEVELDB})

 # rocksdb
 # To support rocksdb build on ubuntu: sudo apt-get install libgflags-dev
-if(${BUILD_WITH_ROCKSDB})
+if (${BUILD_WITH_UV})
    if(${TD_LINUX})
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error=maybe-uninitialized -Wno-error=unused-but-set-variable -Wno-error=unused-variable -Wno-error=unused-function -Wno-errno=unused-private-field -Wno-error=unused-result")
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS_REL}")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_REL}")
+        IF ("${CMAKE_BUILD_TYPE}" STREQUAL "")
+            SET(CMAKE_BUILD_TYPE Release)
+        endif()
    endif(${TD_LINUX})
-    MESSAGE(STATUS "CXXXX STATUS CONFIG: " ${CMAKE_CXX_FLAGS})
+endif (${BUILD_WITH_UV})

-    if(${TD_DARWIN})
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error=maybe-uninitialized")
-    endif(${TD_DARWIN})
+if (${BUILD_WITH_ROCKSDB})
+    if (${BUILD_CONTRIB})
+        if(${TD_LINUX})
+            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_REL} -Wno-error=maybe-uninitialized -Wno-error=unused-but-set-variable -Wno-error=unused-variable -Wno-error=unused-function -Wno-errno=unused-private-field -Wno-error=unused-result")
+            if ("${CMAKE_BUILD_TYPE}" STREQUAL "")
+                SET(CMAKE_BUILD_TYPE Release)
+            endif()
+        endif(${TD_LINUX})
+        MESSAGE(STATUS "CXXXX STATUS CONFIG: " ${CMAKE_CXX_FLAGS})

-    if (${TD_DARWIN_ARM64})
-        set(HAS_ARMV8_CRC true)
-    endif(${TD_DARWIN_ARM64})
+        if(${TD_DARWIN})
+            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error=maybe-uninitialized")
+        endif(${TD_DARWIN})

-    if (${TD_WINDOWS})
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4244 /wd4819")  
-    endif(${TD_WINDOWS})
+        if (${TD_DARWIN_ARM64})
+            set(HAS_ARMV8_CRC true)
+        endif(${TD_DARWIN_ARM64})
+
+        if (${TD_WINDOWS})
+            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4244 /wd4819")
+            option(WITH_JNI "" OFF)
+            option(WITH_MD_LIBRARY "build with MD" OFF)
+            set(SYSTEM_LIBS ${SYSTEM_LIBS} shlwapi.lib rpcrt4.lib)
+        endif(${TD_WINDOWS})


-    if(${TD_DARWIN})
-        option(HAVE_THREAD_LOCAL "" OFF)
-        option(WITH_IOSTATS_CONTEXT "" OFF)
-        option(WITH_PERF_CONTEXT "" OFF)
-    endif(${TD_DARWIN})
+        if(${TD_DARWIN})
+            option(HAVE_THREAD_LOCAL "" OFF)
+            option(WITH_IOSTATS_CONTEXT "" OFF)
+            option(WITH_PERF_CONTEXT "" OFF)
+        endif(${TD_DARWIN})

-    if(${TD_WINDOWS})
-	    option(WITH_JNI "" OFF)
-    endif(${TD_WINDOWS})
+        option(WITH_FALLOCATE "" OFF)
+        option(WITH_JEMALLOC "" OFF)
+        option(WITH_GFLAGS "" OFF)
+        option(PORTABLE "" ON)
+        option(WITH_LIBURING "" OFF)
+        option(FAIL_ON_WARNINGS OFF)

-    if(${TD_WINDOWS})
-        option(WITH_MD_LIBRARY "build with MD" OFF)
-        set(SYSTEM_LIBS ${SYSTEM_LIBS} shlwapi.lib rpcrt4.lib)
-    endif(${TD_WINDOWS})
-    
-    
-    option(WITH_FALLOCATE "" OFF)
-    option(WITH_JEMALLOC "" OFF)
-    option(WITH_GFLAGS "" OFF)
-    option(PORTABLE "" ON)
-    option(WITH_LIBURING "" OFF)
-    option(FAIL_ON_WARNINGS OFF)
+        option(WITH_TESTS "" OFF)
+        option(WITH_BENCHMARK_TOOLS "" OFF)
+        option(WITH_TOOLS "" OFF)
+        option(WITH_LIBURING "" OFF)

-    option(WITH_TESTS "" OFF)
-    option(WITH_BENCHMARK_TOOLS "" OFF)
-    option(WITH_TOOLS "" OFF)
-    option(WITH_LIBURING "" OFF)
-    IF (TD_LINUX) 
-    option(ROCKSDB_BUILD_SHARED "Build shared versions of the RocksDB libraries" OFF)
-    ELSE()
-    option(ROCKSDB_BUILD_SHARED "Build shared versions of the RocksDB libraries" OFF)
-    ENDIF()
-    add_subdirectory(rocksdb EXCLUDE_FROM_ALL)
-    target_include_directories(
-        rocksdb
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/rocksdb/include>
-    )
-endif(${BUILD_WITH_ROCKSDB})
+        option(ROCKSDB_BUILD_SHARED "Build shared versions of the RocksDB libraries" OFF)
+        add_subdirectory(rocksdb EXCLUDE_FROM_ALL)
+        target_include_directories(
+            rocksdb
+            PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/rocksdb/include>
+        )
+    else() 
+        if (NOT ${TD_LINUX})
+            MESSAGE(STATUS "CXXXX STATUS CONFIG: " ${CMAKE_CXX_FLAGS})
+            if(${TD_DARWIN})
+                SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error=maybe-uninitialized")
+            endif(${TD_DARWIN})
+
+            if (${TD_DARWIN_ARM64})
+                set(HAS_ARMV8_CRC true)
+            endif(${TD_DARWIN_ARM64})
+
+            if (${TD_WINDOWS})
+                SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4244 /wd4819")
+                option(WITH_JNI "" OFF)
+                option(WITH_MD_LIBRARY "build with MD" OFF)
+                set(SYSTEM_LIBS ${SYSTEM_LIBS} shlwapi.lib rpcrt4.lib)
+            endif(${TD_WINDOWS})
+
+
+            if(${TD_DARWIN})
+                option(HAVE_THREAD_LOCAL "" OFF)
+                option(WITH_IOSTATS_CONTEXT "" OFF)
+                option(WITH_PERF_CONTEXT "" OFF)
+            endif(${TD_DARWIN})
+
+            option(WITH_FALLOCATE "" OFF)
+            option(WITH_JEMALLOC "" OFF)
+            option(WITH_GFLAGS "" OFF)
+            option(PORTABLE "" ON)
+            option(WITH_LIBURING "" OFF)
+            option(FAIL_ON_WARNINGS OFF)
+
+            option(WITH_TESTS "" OFF)
+            option(WITH_BENCHMARK_TOOLS "" OFF)
+            option(WITH_TOOLS "" OFF)
+            option(WITH_LIBURING "" OFF)
+
+            option(ROCKSDB_BUILD_SHARED "Build shared versions of the RocksDB libraries" OFF)
+            add_subdirectory(rocksdb EXCLUDE_FROM_ALL)
+            target_include_directories(
+                rocksdb
+                PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/rocksdb/include>
+            )
+        endif() 
+      
+    endif()
+endif()

 # lucene
 # To support build on ubuntu: sudo apt-get install libboost-all-dev
@ -291,10 +355,10 @@ if(${BUILD_WITH_LUCENE})
    option(ENABLE_TEST "Enable the tests" OFF)
    add_subdirectory(lucene EXCLUDE_FROM_ALL)
    target_include_directories(
-      lucene++ 
+      lucene++
      PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/lucene/include>
-    ) 
-     
+    )
+
 endif(${BUILD_WITH_LUCENE})

 # NuRaft
@ -354,7 +418,7 @@ if(${BUILD_MSVCREGEX})
    target_include_directories(msvcregex
        PRIVATE "msvcregex"
    )
-    target_link_libraries(msvcregex 
+    target_link_libraries(msvcregex
        INTERFACE Shell32
    )
    SET_TARGET_PROPERTIES(msvcregex PROPERTIES OUTPUT_NAME msvcregex)
@ -414,8 +478,8 @@ if(${BUILD_WITH_BDB})
        IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/bdb/libdb.a"
        INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/bdb"
    )
-    target_link_libraries(bdb 
-        INTERFACE pthread 
+    target_link_libraries(bdb
+        INTERFACE pthread
    )
 endif(${BUILD_WITH_BDB})

@ -427,12 +491,12 @@ if(${BUILD_WITH_SQLITE})
        IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/sqlite/.libs/libsqlite3.a"
        INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/sqlite"
    )
-    target_link_libraries(sqlite 
-        INTERFACE m 
-        INTERFACE pthread 
+    target_link_libraries(sqlite
+        INTERFACE m
+        INTERFACE pthread
    )
    if(NOT TD_WINDOWS)
-        target_link_libraries(sqlite 
+        target_link_libraries(sqlite
            INTERFACE dl
        )
    endif(NOT TD_WINDOWS)
@ -440,22 +504,22 @@ endif(${BUILD_WITH_SQLITE})

 # addr2line
 if(${BUILD_ADDR2LINE})
-    if(NOT ${TD_WINDOWS})    
-        check_include_file( "sys/types.h"     HAVE_SYS_TYPES_H) 
-        check_include_file( "sys/stat.h"      HAVE_SYS_STAT_H ) 
-        check_include_file( "inttypes.h"      HAVE_INTTYPES_H   ) 
-        check_include_file( "stddef.h"        HAVE_STDDEF_H   ) 
-        check_include_file( "stdlib.h"        HAVE_STDLIB_H   ) 
-        check_include_file( "string.h"        HAVE_STRING_H   ) 
-        check_include_file( "memory.h"        HAVE_MEMORY_H   ) 
-        check_include_file( "strings.h"       HAVE_STRINGS_H  ) 
+    if(NOT ${TD_WINDOWS})
+        check_include_file( "sys/types.h"     HAVE_SYS_TYPES_H)
+        check_include_file( "sys/stat.h"      HAVE_SYS_STAT_H )
+        check_include_file( "inttypes.h"      HAVE_INTTYPES_H   )
+        check_include_file( "stddef.h"        HAVE_STDDEF_H   )
+        check_include_file( "stdlib.h"        HAVE_STDLIB_H   )
+        check_include_file( "string.h"        HAVE_STRING_H   )
+        check_include_file( "memory.h"        HAVE_MEMORY_H   )
+        check_include_file( "strings.h"       HAVE_STRINGS_H  )
        check_include_file( "stdint.h"        HAVE_STDINT_H   )
        check_include_file( "unistd.h"        HAVE_UNISTD_H   )
        check_include_file( "sgidefs.h"       HAVE_SGIDEFS_H  )
        check_include_file( "stdafx.h"        HAVE_STDAFX_H   )
-        check_include_file( "elf.h"           HAVE_ELF_H      ) 
-        check_include_file( "libelf.h"        HAVE_LIBELF_H   ) 
-        check_include_file( "libelf/libelf.h" HAVE_LIBELF_LIBELF_H) 
+        check_include_file( "elf.h"           HAVE_ELF_H      )
+        check_include_file( "libelf.h"        HAVE_LIBELF_H   )
+        check_include_file( "libelf/libelf.h" HAVE_LIBELF_LIBELF_H)
        check_include_file( "alloca.h"        HAVE_ALLOCA_H   )
        check_include_file( "elfaccess.h"     HAVE_ELFACCESS_H)
        check_include_file( "sys/elf_386.h"   HAVE_SYS_ELF_386_H  )
@ -463,7 +527,7 @@ if(${BUILD_ADDR2LINE})
        check_include_file( "sys/elf_sparc.h" HAVE_SYS_ELF_SPARC_H)
        check_include_file( "sys/ia64/elf.h"  HAVE_SYS_IA64_ELF_H )
        set(VERSION 0.3.1)
-        set(PACKAGE_VERSION "\"${VERSION}\"") 
+        set(PACKAGE_VERSION "\"${VERSION}\"")
        configure_file(libdwarf/cmake/config.h.cmake config.h)
        file(GLOB_RECURSE LIBDWARF_SOURCES "libdwarf/src/lib/libdwarf/*.c")
        add_library(libdwarf STATIC ${LIBDWARF_SOURCES})
@ -485,8 +549,16 @@ endif(${BUILD_ADDR2LINE})

 # geos
 if(${BUILD_GEOS})
+    if(${TD_LINUX})
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS_REL}")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_REL}")
+        IF ("${CMAKE_BUILD_TYPE}" STREQUAL "")
+            SET(CMAKE_BUILD_TYPE Release)
+        endif()
+    endif(${TD_LINUX})
    option(BUILD_SHARED_LIBS "Build GEOS with shared libraries" OFF)
    add_subdirectory(geos EXCLUDE_FROM_ALL)
+    unset(CMAKE_CXX_STANDARD CACHE) # undo libgeos's setting of global CMAKE_CXX_STANDARD
    target_include_directories(
        geos_c
        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/geos/include>
--- a/deps/arm/rocksdb_static/librocksdb.a
+++ b/deps/arm/rocksdb_static/librocksdb.a
--- a/deps/arm/rocksdb_static/rocksdb/c.h
+++ b/deps/arm/rocksdb_static/rocksdb/c.h
--- a/deps/x86/rocksdb_static/librocksdb.a
+++ b/deps/x86/rocksdb_static/librocksdb.a
--- a/deps/x86/rocksdb_static/rocksdb/c.h
+++ b/deps/x86/rocksdb_static/rocksdb/c.h
--- a/docs/assets/TDengine-logo-trans-small.png
+++ b/docs/assets/TDengine-logo-trans-small.png
--- a/docs/assets/TDengine-logo-trans.png
+++ b/docs/assets/TDengine-logo-trans.png
--- a/docs/en/05-get-started/03-package.md
+++ b/docs/en/05-get-started/03-package.md
@ -20,6 +20,19 @@ The standard server installation package includes `taos`, `taosd`, `taosAdapter`

 The TDengine Community Edition is released as Deb and RPM packages. The Deb package can be installed on Debian, Ubuntu, and derivative systems. The RPM package can be installed on CentOS, RHEL, SUSE, and derivative systems. A .tar.gz package is also provided for enterprise customers, and you can install TDengine over `apt-get` as well. The .tar.tz package includes `taosdump` and the TDinsight installation script. If you want to use these utilities with the Deb or RPM package, download and install taosTools separately. TDengine can also be installed on x64 Windows and x64/m1 macOS.

+## Operating environment requirements
+In the Linux system, the minimum requirements for the operating environment are as follows:
+
+linux core version - 3.10.0-1160.83.1.el7.x86_64;
+
+glibc version - 2.17;
+
+If compiling and installing through clone source code, it is also necessary to meet the following requirements:
+
+cmake version - 3.26.4 or above;
+
+gcc version - 9.3.1 or above;
+
 ## Installation

 <Tabs>
--- a/docs/en/07-develop/08-cache.md
+++ b/docs/en/07-develop/08-cache.md
@ -10,10 +10,10 @@ TDengine uses various kinds of caching techniques to efficiently write and query

 TDengine uses an insert-driven cache management policy, known as first in, first out (FIFO). This policy differs from read-driven "least recently used (LRU)" cache management. A FIFO policy stores the latest data in cache and flushes the oldest data from cache to disk when the cache usage reaches a threshold. In IoT use cases, the most recent data or the current state is most important. The cache policy in TDengine, like much of the design and architecture of TDengine, is based on the nature of IoT data.

-When you create a database, you can configure the size of the write cache on each vnode. The **vgroups** parameter determines the number of vgroups that process data in the database, and the **buffer** parameter determines the size of the write cache for each vnode.
+When you create a database, you can configure the size of the write cache on each vnode. The **vgroups** parameter determines the number of vgroups that process data in the database, and the **buffer** parameter determines the size of the write cache for each vnode. The unit of buffer is MB.

 ```sql
-create database db0 vgroups 100 buffer 16MB
+create database db0 vgroups 100 buffer 16
 ```

 In theory, larger cache sizes are always better. However, at a certain point, it becomes impossible to improve performance by increasing cache size. In most scenarios, you can retain the default cache settings.
@ -28,10 +28,10 @@ When you create a database, you can configure whether the latest data from every

 ## Metadata Cache

-To improve query and write performance, each vnode caches the metadata that it receives. When you create a database, you can configure the size of the metadata cache through the *pages* and *pagesize* parameters.
+To improve query and write performance, each vnode caches the metadata that it receives. When you create a database, you can configure the size of the metadata cache through the *pages* and *pagesize* parameters. The unit of pagesize is kb.

 ```sql
-create database db0 pages 128 pagesize 16kb
+create database db0 pages 128 pagesize 16
 ```

 The preceding SQL statement creates 128 pages on each vnode in the `db0` database. Each page has a 16 KB metadata cache.
--- a/docs/en/12-taos-sql/22-meta.md
+++ b/docs/en/12-taos-sql/22-meta.md
@ -81,7 +81,7 @@ Provides information about user-created databases. Similar to SHOW DATABASES.
 | 3   |       ntables        | INT              | Number of standard tables and subtables (not including supertables) |
 | 4   |       vgroups        | INT              | Number of vgroups. It should be noted that `vnodes` is a TDengine keyword and needs to be escaped with ` when used as a column name.                            |
 | 6   |       replica        | INT              | Number of replicas. It should be noted that `replica` is a TDengine keyword and needs to be escaped with ` when used as a column name.                                            |
-| 7   |        strict        | BINARY(3)        | Strong consistency. It should be noted that `strict` is a TDengine keyword and needs to be escaped with ` when used as a column name.                                          |
+| 7   |        strict        | BINARY(4)        | Obsoleted |
 | 8   |       duration       | INT              | Duration for storage of single files. It should be noted that `duration` is a TDengine keyword and needs to be escaped with ` when used as a column name.                          |
 | 9   |         keep         | INT              | Data retention period. It should be noted that `keep` is a TDengine keyword and needs to be escaped with ` when used as a column name.                                      |
 | 10  |        buffer        | INT              | Write cache size per vnode, in MB. It should be noted that `buffer` is a TDengine keyword and needs to be escaped with ` when used as a column name.            |
--- a/docs/en/14-reference/03-connector/04-java.mdx
+++ b/docs/en/14-reference/03-connector/04-java.mdx
@ -288,6 +288,7 @@ The configuration parameters in the URL are as follows:
 - httpSocketTimeout: socket timeout in milliseconds, the default value is 5000 ms. It only takes effect when batchfetch is false.
 - messageWaitTimeout: message transmission timeout in milliseconds, the default value is 3000 ms. It only takes effect when batchfetch is true.
 - useSSL: connecting Securely Using SSL. true: using SSL connection, false: not using SSL connection.
+- httpPoolSize: size of REST concurrent requests. The default value is 20.

 **Note**: Some configuration items (e.g., locale, timezone) do not work in the REST connection.

@ -355,6 +356,7 @@ The configuration parameters in properties are as follows.
 - TSDBDriver.HTTP_SOCKET_TIMEOUT: socket timeout in milliseconds, the default value is 5000 ms. It only takes effect when using JDBC REST connection and batchfetch is false.
 - TSDBDriver.PROPERTY_KEY_MESSAGE_WAIT_TIMEOUT: message transmission timeout in milliseconds, the default value is 3000 ms. It only takes effect when using JDBC REST connection and batchfetch is true.
 - TSDBDriver.PROPERTY_KEY_USE_SSL: connecting Securely Using SSL. true: using SSL connection, false: not using SSL connection. It only takes effect when using JDBC REST connection.
+- TSDBDriver.HTTP_POOL_SIZE: size of REST concurrent requests. The default value is 20.
  For JDBC native connections, you can specify other parameters, such as log level, SQL length, etc., by specifying URL and Properties. For more detailed configuration, please refer to [Client Configuration](/reference/config/#Client-Only).

 ### Priority of configuration parameters
@ -419,6 +421,19 @@ while(resultSet.next()){

 > The query is consistent with operating a relational database. When using subscripts to get the contents of the returned fields, you have to start from 1. However, we recommend using the field names to get the values of the fields in the result set.

+### execute SQL with reqId
+
+This reqId can be used to request link tracing.
+
+```java
+AbstractStatement aStmt = (AbstractStatement) connection.createStatement();
+aStmt.execute("create database if not exists db", 1L);
+aStmt.executeUpdate("use db", 2L);
+try (ResultSet rs = aStmt.executeQuery("select * from tb", 3L)) {
+    Timestamp ts = rs.getTimestamp(1);
+}
+```
+
 ### Writing data via parameter binding

 TDengine has significantly improved the bind APIs to support data writing (INSERT) scenarios. Writing data in this way avoids the resource consumption of SQL syntax parsing, resulting in significant write performance improvements in many cases.
@ -936,6 +951,14 @@ public class SchemalessWsTest {
 </TabItem>
 </Tabs>

+### Schemaless with reqId
+
+This reqId can be used to request link tracing.
+
+```java
+writer.write(lineDemo, SchemalessProtocolType.LINE, SchemalessTimestampType.NANO_SECONDS, 1L);
+```
+
 ### Data Subscription

 The TDengine Java Connector supports subscription functionality with the following application API.
@ -993,7 +1016,7 @@ while(true) {

 #### Assignment subscription Offset

-```
+```java
 long position(TopicPartition partition) throws SQLException;
 Map<TopicPartition, Long> position(String topic) throws SQLException;
 Map<TopicPartition, Long> beginningOffsets(String topic) throws SQLException;
@ -1002,6 +1025,29 @@ Map<TopicPartition, Long> endOffsets(String topic) throws SQLException;
 void seek(TopicPartition partition, long offset) throws SQLException;
 ```

+Example usage is as follows.
+
+```java
+String topic = "offset_seek_test";
+Map<TopicPartition, Long> offset = null;
+try (TaosConsumer<ResultBean> consumer = new TaosConsumer<>(properties)) {
+    consumer.subscribe(Collections.singletonList(topic));
+    for (int i = 0; i < 10; i++) {
+        if (i == 3) {
+            // Saving consumption position
+            offset = consumer.position(topic);
+        }
+        if (i == 5) {
+            // reset consumption to the previously saved position
+            for (Map.Entry<TopicPartition, Long> entry : offset.entrySet()) {
+                consumer.seek(entry.getKey(), entry.getValue());
+            }
+        }
+        ConsumerRecords<ResultBean> records = consumer.poll(Duration.ofMillis(500));
+    }
+}
+```
+
 #### Close subscriptions

 ```java
@ -1308,3 +1354,7 @@ For additional troubleshooting, see [FAQ](../../../train-faq/faq).
 ## API Reference

 [taos-jdbcdriver doc](https://docs.taosdata.com/api/taos-jdbcdriver)
+
+```
+
+```
--- a/docs/en/14-reference/03-connector/index.mdx
+++ b/docs/en/14-reference/03-connector/index.mdx
@ -48,7 +48,6 @@ Comparing the connector support for TDengine functional features as follows.
 | **Parameter Binding**         | Support       | Support    | Support       | Support       | Support       | Support       |
 | **Subscription (TMQ)**        | Support       | Support    | Support       | Support       | Support       | Support       |
 | **Schemaless**                | Support       | Support    | Support       | Support       | Support       | Support       |
-| **DataFrame**                 | Not Supported | Support    | Not Supported | Not Supported | Not Supported | Not Supported |

 :::info
 The different database framework specifications for various programming languages do not mean that all C/C++ interfaces need a wrapper.
@ -60,11 +59,10 @@ The different database framework specifications for various programming language
 | -------------------------------------- | ------------- | --------------- | ------------- | ------------- | ------------- | ------------- |
 | **Connection Management**              | Support       | Support         | Support       | Support       | Support       | Support       |
 | **Regular Query**                      | Support       | Support         | Support       | Support       | Support       | Support       |
-| **Parameter Binding**                  | Not Supported | Not Supported   | Support       | Support       | Not Supported | Support       |
+| **Parameter Binding**                  | Supported | Not Supported   | Support       | Support       | Not Supported | Support       |
 | **Subscription (TMQ) **                | Supported     | Support         | Support       | Not Supported | Not Supported | Support       |
-| **Schemaless**                         | Not Supported | Not Supported   | Not Supported | Not Supported | Not Supported | Not Supported |
+| **Schemaless**                         | Supported | Not Supported   | Supported | Not Supported | Not Supported | Not Supported |
 | **Bulk Pulling (based on WebSocket) ** | Support       | Support         | Support       | Support       | Support       | Support       |
-| **DataFrame**                          | Not Supported | Support         | Not Supported | Not Supported | Not Supported | Not Supported |

 :::warning

--- a/docs/en/14-reference/12-config/index.md
+++ b/docs/en/14-reference/12-config/index.md
@ -19,16 +19,20 @@ taosd -C

 ## Configuration File on Client Side

-TDengine CLI `taos` is the tool for users to interact with TDengine. It can share same configuration file as `taosd` or use a separate configuration file. When launching `taos`, parameter `-c` can be used to specify the location where its configuration file is. For example `taos -c /home/cfg` means `/home/cfg/taos.cfg` will be used. If `-c` is not used, the default location of the configuration file is `/etc/taos`. For more details please use `taos --help` to get.
+TDengine CLI `taos` is the tool for users to interact with TDengine. It can share same configuration file as `taosd` or use a separate configuration file. When launching `taos`, parameter `-c` can be used to specify the location where its configuration file is. For example:
+
+```
+taos -c /home/cfg
+```
+
+means `/home/cfg/taos.cfg` will be used. If `-c` is not used, the default location of the configuration file is `/etc/taos`. For more details please use `taos --help` to get.
+
+Parameter `-C` can be used on the CLI of `taos` to show its configuration, like below:

 ```bash
 taos -C
 ```

-```bash
-taos --dump-config
-```
-
 ## Configuration Parameters

 :::note
@ -77,8 +81,9 @@ The parameters described in this document by the effect that they have on the sy
 | Default Value | 6030                                                  |

 :::note
- Ensure that your firewall rules do not block TCP port 6042  on any host in the cluster. Below table describes the ports used by TDengine in details.
+Ensure that your firewall rules do not block TCP port 6042  on any host in the cluster. Below table describes the ports used by TDengine in details.
 :::
+
 | Protocol | Default Port | Description                                                                                               | How to configure                                                                               |
 | :------- | :----------- | :-------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------- |
 | TCP      | 6030         | Communication between client and server. In a multi-node cluster, communication between nodes. serverPort |
@ -120,6 +125,8 @@ The parameters described in this document by the effect that they have on the sy
 :::note
 Please note the `taoskeeper` needs to be installed and running to create the `log` database and receiving metrics sent by `taosd` as the full monitoring solution.

+:::
+
 ### monitor

 | Attribute   | Description                                                                                                                                                                                                                                                                                                           |
--- a/docs/en/27-train-faq/01-faq.md
+++ b/docs/en/27-train-faq/01-faq.md
@ -56,7 +56,7 @@ This error indicates that the client could not connect to the server. Perform th

 7. If you are using the Python, Java, Go, Rust, C#, or Node.js connector on Linux to connect to the server, verify that `libtaos.so` is in the `/usr/local/taos/driver` directory and `/usr/local/taos/driver` is in the `LD_LIBRARY_PATH` environment variable.

-8. If you are using macOS, verify that `libtaos.dylib` is in the `/usr/local/lib` directory and `/usr/local/lib` is in the `LD_LIBRARY_PATH` environment variable..
+8. If you are using macOS, verify that `libtaos.dylib` is in the `/usr/local/lib` directory and `/usr/local/lib` is in the `DYLD_LIBRARY_PATH` environment variable..

 9. If you are using Windows, verify that `C:\TDengine\driver\taos.dll` is in the `PATH` environment variable. If possible, move `taos.dll` to the `C:\Windows\System32` directory.

--- a/docs/en/28-releases/01-tdengine.md
+++ b/docs/en/28-releases/01-tdengine.md
@ -10,6 +10,10 @@ For TDengine 2.x installation packages by version, please visit [here](https://w

 import Release from "/components/ReleaseV3";

+## 3.0.5.1
+
+<Release type="tdengine" version="3.0.5.1" />
+
 ## 3.0.5.0

 <Release type="tdengine" version="3.0.5.0" />
--- a/docs/en/28-releases/02-tools.md
+++ b/docs/en/28-releases/02-tools.md
@ -10,6 +10,10 @@ For other historical version installers, please visit [here](https://www.taosdat

 import Release from "/components/ReleaseV3";

+## 2.5.2
+
+<Release type="tools" version="2.5.2" />
+
 ## 2.5.1

 <Release type="tools" version="2.5.1" />
--- a/docs/zh/05-get-started/03-package.md
+++ b/docs/zh/05-get-started/03-package.md
@ -16,6 +16,20 @@ TDengine 完整的软件包包括服务端（taosd）、应用驱动（taosc）

 在 Linux 系统上，TDengine 社区版提供 Deb 和 RPM 格式安装包，用户可以根据自己的运行环境选择合适的安装包。其中 Deb 支持 Debian/Ubuntu 及其衍生系统，RPM 支持 CentOS/RHEL/SUSE 及其衍生系统。同时我们也为企业用户提供 tar.gz 格式安装包，也支持通过 `apt-get` 工具从线上进行安装。需要注意的是，RPM 和 Deb 包不含 `taosdump` 和 TDinsight 安装脚本，这些工具需要通过安装 taosTools 包获得。TDengine 也提供 Windows x64 平台和 macOS x64/m1 平台的安装包。

+## 运行环境要求
+在linux系统中，运行环境最低要求如下:
+
+linux 内核版本 - 3.10.0-1160.83.1.el7.x86_64;
+
+glibc 版本    -  2.17;
+
+如果通过clone源码进行编译安装，还需要满足:
+
+cmake版本 - 3.26.4或以上;
+
+gcc 版本  - 9.3.1或以上;
+
+
 ## 安装

 <Tabs>
--- a/docs/zh/07-develop/08-cache.md
+++ b/docs/zh/07-develop/08-cache.md
@ -10,10 +10,10 @@ description: "TDengine 内部的缓存设计"

 TDengine 采用时间驱动缓存管理策略（First-In-First-Out，FIFO），又称为写驱动的缓存管理机制。这种策略有别于读驱动的数据缓存模式（Least-Recent-Used，LRU），直接将最近写入的数据保存在系统的缓存中。当缓存达到临界值的时候，将最早的数据批量写入磁盘。一般意义上来说，对于物联网数据的使用，用户最为关心最近产生的数据，即当前状态。TDengine 充分利用了这一特性，将最近到达的（当前状态）数据保存在缓存中。

-每个 vnode 的写入缓存大小在创建数据库时决定，创建数据库时的两个关键参数 vgroups 和 buffer 分别决定了该数据库中的数据由多少个 vgroup 处理，以及向其中的每个 vnode 分配多少写入缓存。
+每个 vnode 的写入缓存大小在创建数据库时决定，创建数据库时的两个关键参数 vgroups 和 buffer 分别决定了该数据库中的数据由多少个 vgroup 处理，以及向其中的每个 vnode 分配多少写入缓存。buffer 的单位是MB。

 ```sql
-create database db0 vgroups 100 buffer 16MB
+create database db0 vgroups 100 buffer 16
 ```

 理论上缓存越大越好，但超过一定阈值后再增加缓存对写入性能提升并无帮助，一般情况下使用默认值即可。
@ -28,10 +28,10 @@ create database db0 vgroups 100 buffer 16MB

 ## 元数据缓存

-为了更高效地处理查询和写入，每个 vnode 都会缓存自己曾经获取到的元数据。元数据缓存由创建数据库时的两个参数 pages 和 pagesize 决定。
+为了更高效地处理查询和写入，每个 vnode 都会缓存自己曾经获取到的元数据。元数据缓存由创建数据库时的两个参数 pages 和 pagesize 决定。pagesize 的单位是 kb。

 ```sql
-create database db0 pages 128 pagesize 16kb
+create database db0 pages 128 pagesize 16
 ```

 上述语句会为数据库 db0 的每个 vnode 创建 128 个 page，每个 page 16kb 的元数据缓存。
--- a/docs/zh/08-connector/14-java.mdx
+++ b/docs/zh/08-connector/14-java.mdx
@ -291,6 +291,7 @@ url 中的配置参数如下：
 - httpSocketTimeout: socket 超时时间，单位 ms，默认值为 5000。仅在 batchfetch 设置为 false 时生效。
 - messageWaitTimeout: 消息超时时间, 单位 ms， 默认值为 3000。 仅在 batchfetch 设置为 true 时生效。
 - useSSL: 连接中是否使用 SSL。
+- httpPoolSize: REST 并发请求大小，默认 20。

 **注意**：部分配置项（比如：locale、timezone）在 REST 连接中不生效。

@ -358,6 +359,7 @@ properties 中的配置参数如下：
 - TSDBDriver.HTTP_SOCKET_TIMEOUT: socket 超时时间，单位 ms，默认值为 5000。仅在 REST 连接且 batchfetch 设置为 false 时生效。
 - TSDBDriver.PROPERTY_KEY_MESSAGE_WAIT_TIMEOUT: 消息超时时间, 单位 ms， 默认值为 3000。 仅在 REST 连接且 batchfetch 设置为 true 时生效。
 - TSDBDriver.PROPERTY_KEY_USE_SSL: 连接中是否使用 SSL。仅在 REST 连接时生效。
+- TSDBDriver.HTTP_POOL_SIZE: REST 并发请求大小，默认 20。
  此外对 JDBC 原生连接，通过指定 URL 和 Properties 还可以指定其他参数，比如日志级别、SQL 长度等。更多详细配置请参考[客户端配置](/reference/config/#仅客户端适用)。

 ### 配置参数的优先级
@ -422,6 +424,19 @@ while(resultSet.next()){

 > 查询和操作关系型数据库一致，使用下标获取返回字段内容时从 1 开始，建议使用字段名称获取。

+### 执行带有 reqId 的 SQL
+
+此 reqId 可用于请求链路追踪。
+
+```java
+AbstractStatement aStmt = (AbstractStatement) connection.createStatement();
+aStmt.execute("create database if not exists db", 1L);
+aStmt.executeUpdate("use db", 2L);
+try (ResultSet rs = aStmt.executeQuery("select * from tb", 3L)) {
+    Timestamp ts = rs.getTimestamp(1);
+}
+```
+
 ### 通过参数绑定写入数据

 TDengine 的 JDBC 原生连接实现大幅改进了参数绑定方式对数据写入（INSERT）场景的支持。采用这种方式写入数据时，能避免 SQL 语法解析的资源消耗，从而在很多情况下显著提升写入性能。
@ -939,6 +954,14 @@ public class SchemalessWsTest {
 </TabItem>
 </Tabs>

+### 执行带有 reqId 的无模式写入
+
+此 reqId 可用于请求链路追踪。
+
+```java
+writer.write(lineDemo, SchemalessProtocolType.LINE, SchemalessTimestampType.NANO_SECONDS, 1L);
+```
+
 ### 数据订阅

 TDengine Java 连接器支持订阅功能，应用 API 如下：
@ -996,7 +1019,7 @@ while(true) {

 #### 指定订阅 Offset

-```
+```java
 long position(TopicPartition partition) throws SQLException;
 Map<TopicPartition, Long> position(String topic) throws SQLException;
 Map<TopicPartition, Long> beginningOffsets(String topic) throws SQLException;
@ -1005,6 +1028,29 @@ Map<TopicPartition, Long> endOffsets(String topic) throws SQLException;
 void seek(TopicPartition partition, long offset) throws SQLException;
 ```

+示例代码：
+
+```java
+String topic = "offset_seek_test";
+Map<TopicPartition, Long> offset = null;
+try (TaosConsumer<ResultBean> consumer = new TaosConsumer<>(properties)) {
+    consumer.subscribe(Collections.singletonList(topic));
+    for (int i = 0; i < 10; i++) {
+        if (i == 3) {
+            // Saving consumption position
+            offset = consumer.position(topic);
+        }
+        if (i == 5) {
+            // reset consumption to the previously saved position
+            for (Map.Entry<TopicPartition, Long> entry : offset.entrySet()) {
+                consumer.seek(entry.getKey(), entry.getValue());
+            }
+        }
+        ConsumerRecords<ResultBean> records = consumer.poll(Duration.ofMillis(500));
+    }
+}
+```
+
 #### 关闭订阅

 ```java
--- a/docs/zh/08-connector/index.md
+++ b/docs/zh/08-connector/index.md
@ -45,9 +45,8 @@ TDengine 版本更新往往会增加新的功能特性，列表中的连接器
 | **连接管理**        | 支持     | 支持       | 支持   | 支持   | 支持        | 支持     |
 | **普通查询**        | 支持     | 支持       | 支持   | 支持   | 支持        | 支持     |
 | **参数绑定**        | 支持     | 支持       | 支持   | 支持   | 支持        | 支持     |
-| **数据订阅（TMQ）** | 暂不支持 | 支持       | 支持   | 支持   | 支持        | 支持     |
+| **数据订阅（TMQ）** | 支持 | 支持       | 支持   | 支持   | 支持        | 支持     |
 | **Schemaless**      | 支持     | 支持       | 支持   | 支持   | 支持        | 支持     |
-| **DataFrame**       | 不支持   | 支持       | 不支持 | 不支持 | 不支持      | 不支持   |

 :::info
 由于不同编程语言数据库框架规范不同，并不意味着所有 C/C++ 接口都需要对应封装支持。
@ -59,11 +58,10 @@ TDengine 版本更新往往会增加新的功能特性，列表中的连接器
 | ------------------------------ | -------- | ---------- | -------- | -------- | ----------- | -------- |
 | **连接管理**                   | 支持     | 支持       | 支持     | 支持     | 支持        | 支持     |
 | **普通查询**                   | 支持     | 支持       | 支持     | 支持     | 支持        | 支持     |
-| **参数绑定**                   | 暂不支持 | 暂不支持   | 支持     | 支持     | 暂不支持    | 支持     |
+| **参数绑定**                   | 支持 | 暂不支持   | 支持     | 支持     | 暂不支持    | 支持     |
 | **数据订阅（TMQ）**            | 支持     | 支持       | 支持     | 暂不支持 | 暂不支持    | 支持     |
-| **Schemaless**                 | 支持     | 暂不支持   | 暂不支持 | 暂不支持 | 暂不支持    | 暂不支持 |
+| **Schemaless**                 | 支持     | 暂不支持   | 支持 | 暂不支持 | 暂不支持    | 支持 |
 | **批量拉取（基于 WebSocket）** | 支持     | 支持       | 支持     | 支持     | 支持        | 支持     |
-| **DataFrame**                  | 不支持   | 支持       | 不支持   | 不支持   | 不支持      | 不支持   |

 :::warning

--- a/docs/zh/12-taos-sql/22-meta.md
+++ b/docs/zh/12-taos-sql/22-meta.md
@ -81,7 +81,7 @@ TDengine 内置了一个名为 `INFORMATION_SCHEMA` 的数据库，提供对数
 | 3   |       ntables        | INT              | 数据库中表的数量，包含子表和普通表但不包含超级表 |
 | 4   |       vgroups        | INT              | 数据库中有多少个 vgroup。需要注意，`vgroups` 为 TDengine 关键字，作为列名使用时需要使用 ` 进行转义。                          |
 | 6   |       replica        | INT              | 副本数。需要注意，`replica` 为 TDengine 关键字，作为列名使用时需要使用 ` 进行转义。                                           |
-| 7   |        strict        | BINARY(3)        | 强一致性。需要注意，`strict` 为 TDengine 关键字，作为列名使用时需要使用 ` 进行转义。                                         |
+| 7   |        strict        | BINARY(4)        | 废弃参数 |
 | 8   |       duration       | INT              | 单文件存储数据的时间跨度。需要注意，`duration` 为 TDengine 关键字，作为列名使用时需要使用 ` 进行转义。                         |
 | 9   |         keep         | INT              | 数据保留时长。需要注意，`keep` 为 TDengine 关键字，作为列名使用时需要使用 ` 进行转义。                                     |
 | 10  |        buffer        | INT              | 每个 vnode 写缓存的内存块大小，单位 MB。需要注意，`buffer` 为 TDengine 关键字，作为列名使用时需要使用 ` 进行转义。           |
--- a/docs/zh/14-reference/12-config/index.md
+++ b/docs/zh/14-reference/12-config/index.md
@ -19,15 +19,19 @@ taosd -C

 ## 为客户端指定配置文件

-TDengine 系统的前台交互客户端应用程序为 taos，以及应用驱动，它可以与 taosd 共享同一个配置文件 taos.cfg，也可以使用单独指定配置文件。运行 taos 时，使用参数-c 指定配置文件目录，如 taos -c /home/cfg，表示使用/home/cfg/目录下的 taos.cfg 配置文件中的参数，缺省目录是/etc/taos。更多 taos 的使用方法请见帮助信息 `taos --help`。
+TDengine 系统的前台交互客户端应用程序为 taos，以及应用驱动，它可以与 taosd 共享同一个配置文件 taos.cfg，也可以使用单独指定配置文件。运行 taos 时，使用参数-c 指定配置文件目录，如：
+
+```
+taos -c /home/cfg
+```
+
+表示使用/home/cfg/目录下的 taos.cfg 配置文件中的参数，缺省目录是/etc/taos。 另外可以使用 `-C` 显示当前服务器配置参数：

 ```bash
 taos -C
 ```

-```bash
-taos --dump-config
-```
+更多 taos 的使用方法请见帮助信息 `taos --help`。

 ## 配置参数详细列表

@ -139,6 +143,8 @@ taos --dump-config
 :::note
 请注意，完整的监控功能需要安装并运行 `taoskeeper` 服务。taoskeeper 负责接收监控指标数据并创建 `log` 库。

+:::
+
 ### monitor

 | 属性     | 说明                                                                                                                                                                                               |
--- a/docs/zh/21-tdinternal/01-arch.md
+++ b/docs/zh/21-tdinternal/01-arch.md
@ -165,9 +165,7 @@ Vnode 会保持一个数据版本号（version），对内存数据进行持久

 ### 同步复制

-对于数据一致性要求更高的场景，异步数据复制提供的最终一致性无法满足要求。因此 TDengine 提供同步复制的机制供用户选择。在创建数据库时，除指定副本数 `replica` 之外，用户还需要指定新的参数 `strict`。如果 `strict` 等于 1，它表示每次 leader 转发给副本时，需要等待半数以上副本达成一致后，才能通知应用，数据在 follower 已经写入成功。如果在一定的时间内，得不到半数以上副本的确认，leader vnode 将返回错误给应用。
-
-采用同步复制，系统的性能会有所下降，而且 latency 会增加。因为元数据要强一致，mnode 之间的数据同步缺省就是采用的同步复制。
+对于数据一致性要求更高的场景，异步数据复制提供的最终一致性无法满足要求。因此 TDengine 3.0 使用了同步复制的机制（参照 RAFT 协议的标准实现）。每次 leader vnode 转发给其他副本时，需要等待半数以上（包含自己）副本达成一致后，才能通知应用写入成功。如果在一定的时间内，得不到半数以上副本的确认，leader vnode 将返回错误给应用。

 ## 缓存与持久化

--- a/docs/zh/28-releases/01-tdengine.md
+++ b/docs/zh/28-releases/01-tdengine.md
@ -10,6 +10,10 @@ TDengine 2.x 各版本安装包请访问[这里](https://www.taosdata.com/all-do

 import Release from "/components/ReleaseV3";

+## 3.0.5.1
+
+<Release type="tdengine" version="3.0.5.1" />
+
 ## 3.0.5.0

 <Release type="tdengine" version="3.0.5.0" />
--- a/docs/zh/28-releases/02-tools.md
+++ b/docs/zh/28-releases/02-tools.md
@ -10,6 +10,10 @@ taosTools 各版本安装包下载链接如下：

 import Release from "/components/ReleaseV3";

+## 2.5.2
+
+<Release type="tools" version="2.5.2" />
+
 ## 2.5.1

 <Release type="tools" version="2.5.1" />
--- a/examples/JDBC/consumer-demo/pom.xml
+++ b/examples/JDBC/consumer-demo/pom.xml
@ -22,7 +22,7 @@
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
-            <version>30.1.1-jre</version>
+            <version>32.0.0-jre</version>
        </dependency>
    </dependencies>

--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@ -3354,6 +3354,17 @@ static FORCE_INLINE void tDeleteSMqAskEpRsp(SMqAskEpRsp* pRsp) {
  taosArrayDestroyEx(pRsp->topics, (FDelete)tDeleteMqSubTopicEp);
 }

+typedef struct {
+  int32_t      vgId;
+  STqOffsetVal offset;
+  int64_t      rows;
+}OffsetRows;
+
+typedef struct{
+  char       topicName[TSDB_TOPIC_FNAME_LEN];
+  SArray*    offsetRows;
+}TopicOffsetRows;
+
 #define TD_AUTO_CREATE_TABLE 0x1
 typedef struct {
  int64_t       suid;
--- a/include/common/tmsgdef.h
+++ b/include/common/tmsgdef.h
@ -310,6 +310,7 @@ enum {
  TD_DEF_MSG_TYPE(TDMT_VND_TMQ_ADD_CHECKINFO, "vnode-tmq-add-checkinfo", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_VND_TMQ_DEL_CHECKINFO, "vnode-del-checkinfo", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_VND_TMQ_CONSUME, "vnode-tmq-consume", SMqPollReq, SMqDataBlkRsp)
+  TD_DEF_MSG_TYPE(TDMT_VND_TMQ_CONSUME_PUSH, "vnode-tmq-consume-push", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_VND_TMQ_VG_WALINFO, "vnode-tmq-vg-walinfo", SMqPollReq, SMqDataBlkRsp)
  TD_DEF_MSG_TYPE(TDMT_VND_TMQ_MAX_MSG, "vnd-tmq-max", NULL, NULL)

--- a/include/libs/function/functionMgt.h
+++ b/include/libs/function/functionMgt.h
@ -216,7 +216,7 @@ bool fmIsUserDefinedFunc(int32_t funcId);
 bool fmIsDistExecFunc(int32_t funcId);
 bool fmIsForbidFillFunc(int32_t funcId);
 bool fmIsForbidStreamFunc(int32_t funcId);
-bool fmIsForbidSuperTableFunc(int32_t funcId);
+bool fmIsForbidSysTableFunc(int32_t funcId);
 bool fmIsIntervalInterpoFunc(int32_t funcId);
 bool fmIsInterpFunc(int32_t funcId);
 bool fmIsLastRowFunc(int32_t funcId);
--- a/include/libs/wal/wal.h
+++ b/include/libs/wal/wal.h
@ -214,7 +214,6 @@ int32_t walSkipFetchBody(SWalReader *pRead, const SWalCkHead *pHead);

 void walRefFirstVer(SWal *, SWalRef *);
 void walRefLastVer(SWal *, SWalRef *);
-SWalRef *walRefCommittedVer(SWal *);

 SWalRef *walOpenRef(SWal *);
 void     walCloseRef(SWal *pWal, int64_t refId);
--- a/include/util/talgo.h
+++ b/include/util/talgo.h
@ -31,7 +31,7 @@ typedef void *(*__array_item_dup_fn_t)(void *);

 typedef void (*FDelete)(void *);
 typedef int32_t (*FEncode)(void **buf, const void *dst);
-typedef void *(*FDecode)(const void *buf, void *dst);
+typedef void *(*FDecode)(const void *buf, void *dst, int8_t sver);

 #define TD_EQ 0x1
 #define TD_GT 0x2
--- a/include/util/taoserror.h
+++ b/include/util/taoserror.h
@ -704,6 +704,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_INVALID_TAGS_PC           TAOS_DEF_ERROR_CODE(0, 0x2665)
 #define TSDB_CODE_PAR_INVALID_TIMELINE_QUERY    TAOS_DEF_ERROR_CODE(0, 0x2666)
 #define TSDB_CODE_PAR_INVALID_OPTR_USAGE        TAOS_DEF_ERROR_CODE(0, 0x2667)
+#define TSDB_CODE_PAR_SYSTABLE_NOT_ALLOWED_FUNC TAOS_DEF_ERROR_CODE(0, 0x2668)
 #define TSDB_CODE_PAR_INTERNAL_ERROR            TAOS_DEF_ERROR_CODE(0, 0x26FF)

 //planner
--- a/include/util/tarray.h
+++ b/include/util/tarray.h
@ -244,7 +244,7 @@ int32_t taosArraySearchIdx(const SArray* pArray, const void* key, __compar_fn_t
 void taosArraySortPWithExt(SArray* pArray, __ext_compar_fn_t fn, const void* param);

 int32_t taosEncodeArray(void** buf, const SArray* pArray, FEncode encode);
-void*   taosDecodeArray(const void* buf, SArray** pArray, FDecode decode, int32_t dataSz);
+void* taosDecodeArray(const void* buf, SArray** pArray, FDecode decode, int32_t dataSz, int8_t sver);

 #ifdef __cplusplus
 }
--- a/include/util/tlrucache.h
+++ b/include/util/tlrucache.h
@ -24,7 +24,8 @@ extern "C" {

 typedef struct SLRUCache SLRUCache;

-typedef void (*_taos_lru_deleter_t)(const void *key, size_t keyLen, void *value);
+typedef void (*_taos_lru_deleter_t)(const void *key, size_t keyLen, void *value, void *ud);
+typedef int (*_taos_lru_functor_t)(const void *key, size_t keyLen, void *value, void *ud);

 typedef struct LRUHandle LRUHandle;

@ -41,10 +42,11 @@ SLRUCache *taosLRUCacheInit(size_t capacity, int numShardBits, double highPriPoo
 void       taosLRUCacheCleanup(SLRUCache *cache);

 LRUStatus  taosLRUCacheInsert(SLRUCache *cache, const void *key, size_t keyLen, void *value, size_t charge,
-                              _taos_lru_deleter_t deleter, LRUHandle **handle, LRUPriority priority);
+                              _taos_lru_deleter_t deleter, LRUHandle **handle, LRUPriority priority, void *ud);
 LRUHandle *taosLRUCacheLookup(SLRUCache *cache, const void *key, size_t keyLen);
 void       taosLRUCacheErase(SLRUCache *cache, const void *key, size_t keyLen);

+void taosLRUCacheApply(SLRUCache *cache, _taos_lru_functor_t functor, void *ud);
 void taosLRUCacheEraseUnrefEntries(SLRUCache *cache);

 bool taosLRUCacheRef(SLRUCache *cache, LRUHandle *handle);
--- a/packaging/checkPackageRuning.py
+++ b/packaging/checkPackageRuning.py
@ -42,8 +42,8 @@ else:
 # os.system("rm -rf /var/lib/taos/*")
 # os.system("systemctl restart taosd ")

-# wait a moment ,at least 5 seconds
-time.sleep(5)
+# wait a moment ,at least 10 seconds
+time.sleep(10)

 # prepare data by taosBenchmark 

--- a/packaging/deb/makedeb.sh
+++ b/packaging/deb/makedeb.sh
@ -124,12 +124,12 @@ if [ -f ${compile_dir}/build/bin/jemalloc-config ]; then
        cp ${compile_dir}/build/lib/libjemalloc.so.2 ${pkg_dir}${install_user_local_path}/lib/
        ln -sf libjemalloc.so.2 ${pkg_dir}${install_user_local_path}/lib/libjemalloc.so
    fi
-    if [ -f ${compile_dir}/build/lib/libjemalloc.a ]; then
-        cp ${compile_dir}/build/lib/libjemalloc.a ${pkg_dir}${install_user_local_path}/lib/
-    fi
-    if [ -f ${compile_dir}/build/lib/libjemalloc_pic.a ]; then
-        cp ${compile_dir}/build/lib/libjemalloc_pic.a ${pkg_dir}${install_user_local_path}/lib/
-    fi
+    # if [ -f ${compile_dir}/build/lib/libjemalloc.a ]; then
+    #     cp ${compile_dir}/build/lib/libjemalloc.a ${pkg_dir}${install_user_local_path}/lib/
+    # fi
+    # if [ -f ${compile_dir}/build/lib/libjemalloc_pic.a ]; then
+    #     cp ${compile_dir}/build/lib/libjemalloc_pic.a ${pkg_dir}${install_user_local_path}/lib/
+    # fi
    if [ -f ${compile_dir}/build/lib/pkgconfig/jemalloc.pc ]; then
        cp ${compile_dir}/build/lib/pkgconfig/jemalloc.pc ${pkg_dir}${install_user_local_path}/lib/pkgconfig/
    fi
--- a/packaging/rpm/tdengine.spec
+++ b/packaging/rpm/tdengine.spec
@ -123,12 +123,12 @@ if [ -f %{_compiledir}/build/bin/jemalloc-config ]; then
        cp %{_compiledir}/build/lib/libjemalloc.so.2 %{buildroot}%{homepath}/jemalloc/lib
        ln -sf libjemalloc.so.2 %{buildroot}%{homepath}/jemalloc/lib/libjemalloc.so
    fi
-    if [ -f %{_compiledir}/build/lib/libjemalloc.a ]; then
-        cp %{_compiledir}/build/lib/libjemalloc.a %{buildroot}%{homepath}/jemalloc/lib
-    fi
-    if [ -f %{_compiledir}/build/lib/libjemalloc_pic.a ]; then
-        cp %{_compiledir}/build/lib/libjemalloc_pic.a %{buildroot}%{homepath}/jemalloc/lib
-    fi
+#    if [ -f %{_compiledir}/build/lib/libjemalloc.a ]; then
+#        cp %{_compiledir}/build/lib/libjemalloc.a %{buildroot}%{homepath}/jemalloc/lib
+#    fi
+#    if [ -f %{_compiledir}/build/lib/libjemalloc_pic.a ]; then
+#        cp %{_compiledir}/build/lib/libjemalloc_pic.a %{buildroot}%{homepath}/jemalloc/lib
+#    fi
    if [ -f %{_compiledir}/build/lib/pkgconfig/jemalloc.pc ]; then
        cp %{_compiledir}/build/lib/pkgconfig/jemalloc.pc %{buildroot}%{homepath}/jemalloc/lib/pkgconfig
    fi
--- a/packaging/tools/install.sh
+++ b/packaging/tools/install.sh
@ -315,13 +315,13 @@ function install_jemalloc() {
      ${csudo}/usr/bin/install -c -m 755 ${jemalloc_dir}/lib/libjemalloc.so.2 /usr/local/lib
      ${csudo}ln -sf libjemalloc.so.2 /usr/local/lib/libjemalloc.so
      ${csudo}/usr/bin/install -c -d /usr/local/lib
-      if [ -f ${jemalloc_dir}/lib/libjemalloc.a ]; then
-        ${csudo}/usr/bin/install -c -m 755 ${jemalloc_dir}/lib/libjemalloc.a /usr/local/lib
-      fi
-      if [ -f ${jemalloc_dir}/lib/libjemalloc_pic.a ]; then
-        ${csudo}/usr/bin/install -c -m 755 ${jemalloc_dir}/lib/libjemalloc_pic.a /usr/local/lib
-      fi
-      if [ -f ${jemalloc_dir}/lib/libjemalloc_pic.a ]; then
+      # if [ -f ${jemalloc_dir}/lib/libjemalloc.a ]; then
+      #   ${csudo}/usr/bin/install -c -m 755 ${jemalloc_dir}/lib/libjemalloc.a /usr/local/lib
+      # fi
+      # if [ -f ${jemalloc_dir}/lib/libjemalloc_pic.a ]; then
+      #   ${csudo}/usr/bin/install -c -m 755 ${jemalloc_dir}/lib/libjemalloc_pic.a /usr/local/lib
+      # fi
+      if [ -f ${jemalloc_dir}/lib/pkgconfig/jemalloc.pc ]; then
        ${csudo}/usr/bin/install -c -d /usr/local/lib/pkgconfig
        ${csudo}/usr/bin/install -c -m 644 ${jemalloc_dir}/lib/pkgconfig/jemalloc.pc /usr/local/lib/pkgconfig
      fi
--- a/packaging/tools/install_client.sh
+++ b/packaging/tools/install_client.sh
@ -214,13 +214,13 @@ function install_jemalloc() {
            ${csudo}/usr/bin/install -c -m 755 ${jemalloc_dir}/lib/libjemalloc.so.2 /usr/local/lib
            ${csudo}ln -sf libjemalloc.so.2 /usr/local/lib/libjemalloc.so
            ${csudo}/usr/bin/install -c -d /usr/local/lib
-            if [ -f ${jemalloc_dir}/lib/libjemalloc.a ]; then
-                ${csudo}/usr/bin/install -c -m 755 ${jemalloc_dir}/lib/libjemalloc.a /usr/local/lib
-            fi
-            if [ -f ${jemalloc_dir}/lib/libjemalloc_pic.a ]; then
-                ${csudo}/usr/bin/install -c -m 755 ${jemalloc_dir}/lib/libjemalloc_pic.a /usr/local/lib
-            fi
-            if [ -f ${jemalloc_dir}/lib/libjemalloc_pic.a ]; then
+            # if [ -f ${jemalloc_dir}/lib/libjemalloc.a ]; then
+            #     ${csudo}/usr/bin/install -c -m 755 ${jemalloc_dir}/lib/libjemalloc.a /usr/local/lib
+            # fi
+            # if [ -f ${jemalloc_dir}/lib/libjemalloc_pic.a ]; then
+            #     ${csudo}/usr/bin/install -c -m 755 ${jemalloc_dir}/lib/libjemalloc_pic.a /usr/local/lib
+            # fi
+            if [ -f ${jemalloc_dir}/lib/pkgconfig/jemalloc.pc ]; then
                ${csudo}/usr/bin/install -c -d /usr/local/lib/pkgconfig
                ${csudo}/usr/bin/install -c -m 644 ${jemalloc_dir}/lib/pkgconfig/jemalloc.pc /usr/local/lib/pkgconfig
            fi
--- a/packaging/tools/make_install.sh
+++ b/packaging/tools/make_install.sh
@ -241,10 +241,10 @@ function install_jemalloc() {
      ${csudo}/usr/bin/install -c -m 755 ${binary_dir}/build/lib/libjemalloc.so.2 /usr/local/lib
      ${csudo}ln -sf libjemalloc.so.2 /usr/local/lib/libjemalloc.so > /dev/null 2>&1
      ${csudo}/usr/bin/install -c -d /usr/local/lib
-      [ -f ${binary_dir}/build/lib/libjemalloc.a ] &&
-        ${csudo}/usr/bin/install -c -m 755 ${binary_dir}/build/lib/libjemalloc.a /usr/local/lib
-      [ -f ${binary_dir}/build/lib/libjemalloc_pic.a ] &&
-        ${csudo}/usr/bin/install -c -m 755 ${binary_dir}/build/lib/libjemalloc_pic.a /usr/local/lib
+      # [ -f ${binary_dir}/build/lib/libjemalloc.a ] &&
+      #   ${csudo}/usr/bin/install -c -m 755 ${binary_dir}/build/lib/libjemalloc.a /usr/local/lib
+      # [ -f ${binary_dir}/build/lib/libjemalloc_pic.a ] &&
+      #   ${csudo}/usr/bin/install -c -m 755 ${binary_dir}/build/lib/libjemalloc_pic.a /usr/local/lib
      if [ -f "${binary_dir}/build/lib/pkgconfig/jemalloc.pc" ]; then
        ${csudo}/usr/bin/install -c -d /usr/local/lib/pkgconfig
        ${csudo}/usr/bin/install -c -m 644 ${binary_dir}/build/lib/pkgconfig/jemalloc.pc \
--- a/packaging/tools/makeclient.sh
+++ b/packaging/tools/makeclient.sh
@ -118,12 +118,12 @@ if [ -f ${build_dir}/bin/jemalloc-config ]; then
    cp ${build_dir}/lib/libjemalloc.so.2 ${install_dir}/jemalloc/lib
    ln -sf libjemalloc.so.2 ${install_dir}/jemalloc/lib/libjemalloc.so
  fi
-  if [ -f ${build_dir}/lib/libjemalloc.a ]; then
-    cp ${build_dir}/lib/libjemalloc.a ${install_dir}/jemalloc/lib
-  fi
-  if [ -f ${build_dir}/lib/libjemalloc_pic.a ]; then
-    cp ${build_dir}/lib/libjemalloc_pic.a ${install_dir}/jemalloc/lib
-  fi
+  # if [ -f ${build_dir}/lib/libjemalloc.a ]; then
+  #   cp ${build_dir}/lib/libjemalloc.a ${install_dir}/jemalloc/lib
+  # fi
+  # if [ -f ${build_dir}/lib/libjemalloc_pic.a ]; then
+  #   cp ${build_dir}/lib/libjemalloc_pic.a ${install_dir}/jemalloc/lib
+  # fi
  if [ -f ${build_dir}/lib/pkgconfig/jemalloc.pc ]; then
    cp ${build_dir}/lib/pkgconfig/jemalloc.pc ${install_dir}/jemalloc/lib/pkgconfig
  fi
--- a/packaging/tools/makepkg.sh
+++ b/packaging/tools/makepkg.sh
@ -217,12 +217,12 @@ if [ -f ${build_dir}/bin/jemalloc-config ]; then
    cp ${build_dir}/lib/libjemalloc.so.2 ${install_dir}/jemalloc/lib
    ln -sf libjemalloc.so.2 ${install_dir}/jemalloc/lib/libjemalloc.so
  fi
-  if [ -f ${build_dir}/lib/libjemalloc.a ]; then
-    cp ${build_dir}/lib/libjemalloc.a ${install_dir}/jemalloc/lib
-  fi
-  if [ -f ${build_dir}/lib/libjemalloc_pic.a ]; then
-    cp ${build_dir}/lib/libjemalloc_pic.a ${install_dir}/jemalloc/lib
-  fi
+  # if [ -f ${build_dir}/lib/libjemalloc.a ]; then
+  #   cp ${build_dir}/lib/libjemalloc.a ${install_dir}/jemalloc/lib
+  # fi
+  # if [ -f ${build_dir}/lib/libjemalloc_pic.a ]; then
+  #   cp ${build_dir}/lib/libjemalloc_pic.a ${install_dir}/jemalloc/lib
+  # fi
  if [ -f ${build_dir}/lib/pkgconfig/jemalloc.pc ]; then
    cp ${build_dir}/lib/pkgconfig/jemalloc.pc ${install_dir}/jemalloc/lib/pkgconfig
  fi
--- a/packaging/tools/post.sh
+++ b/packaging/tools/post.sh
@ -169,13 +169,13 @@ function install_jemalloc() {
      ${csudo}/usr/bin/install -c -m 755 ${jemalloc_dir}/lib/libjemalloc.so.2 /usr/local/lib
      ${csudo}ln -sf libjemalloc.so.2 /usr/local/lib/libjemalloc.so
      ${csudo}/usr/bin/install -c -d /usr/local/lib
-      if [ -f ${jemalloc_dir}/lib/libjemalloc.a ]; then
-        ${csudo}/usr/bin/install -c -m 755 ${jemalloc_dir}/lib/libjemalloc.a /usr/local/lib
-      fi
-      if [ -f ${jemalloc_dir}/lib/libjemalloc_pic.a ]; then
-        ${csudo}/usr/bin/install -c -m 755 ${jemalloc_dir}/lib/libjemalloc_pic.a /usr/local/lib
-      fi
-      if [ -f ${jemalloc_dir}/lib/libjemalloc_pic.a ]; then
+      # if [ -f ${jemalloc_dir}/lib/libjemalloc.a ]; then
+      #   ${csudo}/usr/bin/install -c -m 755 ${jemalloc_dir}/lib/libjemalloc.a /usr/local/lib
+      # fi
+      # if [ -f ${jemalloc_dir}/lib/libjemalloc_pic.a ]; then
+      #   ${csudo}/usr/bin/install -c -m 755 ${jemalloc_dir}/lib/libjemalloc_pic.a /usr/local/lib
+      # fi
+      if [ -f ${jemalloc_dir}/lib/pkgconfig/jemalloc.pc ]; then
        ${csudo}/usr/bin/install -c -d /usr/local/lib/pkgconfig
        ${csudo}/usr/bin/install -c -m 644 ${jemalloc_dir}/lib/pkgconfig/jemalloc.pc /usr/local/lib/pkgconfig
      fi
--- a/source/common/src/tdatablock.c
+++ b/source/common/src/tdatablock.c
@ -1590,18 +1590,35 @@ size_t blockDataGetCapacityInRow(const SSDataBlock* pBlock, size_t pageSize, int
  int32_t nRows = payloadSize / rowSize;
  ASSERT(nRows >= 1);

-  // the true value must be less than the value of nRows
-  int32_t additional = 0;
+  int32_t numVarCols = 0;
+  int32_t numFixCols = 0;
  for (int32_t i = 0; i < numOfCols; ++i) {
    SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, i);
    if (IS_VAR_DATA_TYPE(pCol->info.type)) {
-      additional += nRows * sizeof(int32_t);
+      ++numVarCols;
    } else {
-      additional += BitmapLen(nRows);
+      ++numFixCols;
    }
  }

-  int32_t newRows = (payloadSize - additional) / rowSize;
+  // find the data payload whose size is greater than payloadSize
+  int result = -1;
+  int start = 1;
+  int end = nRows;
+  while (start <= end) {
+    int mid = start + (end - start) / 2;
+    //data size + var data type columns offset + fixed data type columns bitmap len 
+    int midSize = rowSize * mid + numVarCols * sizeof(int32_t) * mid + numFixCols * BitmapLen(mid); 
+    if (midSize > payloadSize) {
+      result = mid;
+      end = mid - 1;
+    } else {
+      start = mid + 1;
+    }
+  }
+
+  int32_t newRows = (result != -1) ? result - 1 : nRows;
+  // the true value must be less than the value of nRows
  ASSERT(newRows <= nRows && newRows >= 1);

  return newRows;
--- a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
+++ b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
@ -712,6 +712,7 @@ SArray *vmGetMsgHandles() {
  if (dmSetMgmtHandle(pArray, TDMT_VND_TMQ_ADD_CHECKINFO, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_VND_TMQ_DEL_CHECKINFO, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_VND_TMQ_CONSUME, vmPutMsgToQueryQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_TMQ_CONSUME_PUSH, vmPutMsgToQueryQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_VND_TMQ_VG_WALINFO, vmPutMsgToFetchQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_VND_DELETE, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
  if (dmSetMgmtHandle(pArray, TDMT_VND_BATCH_DEL, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER;
--- a/source/dnode/mgmt/node_mgmt/src/dmTransport.c
+++ b/source/dnode/mgmt/node_mgmt/src/dmTransport.c
@ -23,10 +23,6 @@ static inline void dmBuildMnodeRedirectRsp(SDnode *pDnode, SRpcMsg *pMsg) {
  SEpSet epSet = {0};
  dmGetMnodeEpSetForRedirect(&pDnode->data, pMsg, &epSet);

-  if (epSet.numOfEps == 1) {
-    return;
-  }
-
  const int32_t contLen = tSerializeSEpSet(NULL, 0, &epSet);
  pMsg->pCont = rpcMallocCont(contLen);
  if (pMsg->pCont == NULL) {
--- a/source/dnode/mgmt/node_util/inc/dmUtil.h
+++ b/source/dnode/mgmt/node_util/inc/dmUtil.h
@ -105,6 +105,7 @@ typedef struct {
  SHashObj      *dnodeHash;
  TdThreadRwlock lock;
  SMsgCb         msgCb;
+  bool           validMnodeEps;
 } SDnodeData;

 typedef struct {
--- a/source/dnode/mgmt/node_util/src/dmEps.c
+++ b/source/dnode/mgmt/node_util/src/dmEps.c
@ -288,6 +288,8 @@ static void dmResetEps(SDnodeData *pData, SArray *dnodeEps) {
    taosHashPut(pData->dnodeHash, &pDnodeEp->id, sizeof(int32_t), pDnodeEp, sizeof(SDnodeEp));
  }

+  pData->validMnodeEps = true;
+
  dmPrintEps(pData);
 }

@ -348,6 +350,7 @@ void dmRotateMnodeEpSet(SDnodeData *pData) {
 }

 void dmGetMnodeEpSetForRedirect(SDnodeData *pData, SRpcMsg *pMsg, SEpSet *pEpSet) {
+  if(!pData->validMnodeEps) return;
  dmGetMnodeEpSet(pData, pEpSet);
  dTrace("msg is redirected, handle:%p num:%d use:%d", pMsg->info.handle, pEpSet->numOfEps, pEpSet->inUse);
  for (int32_t i = 0; i < pEpSet->numOfEps; ++i) {
--- a/source/dnode/mnode/impl/inc/mndDef.h
+++ b/source/dnode/mnode/impl/inc/mndDef.h
@ -467,6 +467,7 @@ typedef struct {
  int8_t         replica;
  int16_t        numOfColumns;
  int32_t        numOfRows;
+  int32_t        curIterPackedRows;
  void*          pIter;
  SMnode*        pMnode;
  STableMetaRsp* pMeta;
@ -559,24 +560,25 @@ void*           tDecodeSMqConsumerObj(const void* buf, SMqConsumerObj* pConsumer

 typedef struct {
  int32_t vgId;
-  char*   qmsg;  // SubPlanToString
+//  char*   qmsg;  // SubPlanToString
  SEpSet  epSet;
 } SMqVgEp;

 SMqVgEp* tCloneSMqVgEp(const SMqVgEp* pVgEp);
 void     tDeleteSMqVgEp(SMqVgEp* pVgEp);
 int32_t  tEncodeSMqVgEp(void** buf, const SMqVgEp* pVgEp);
-void*    tDecodeSMqVgEp(const void* buf, SMqVgEp* pVgEp);
+void*    tDecodeSMqVgEp(const void* buf, SMqVgEp* pVgEp, int8_t sver);

 typedef struct {
  int64_t consumerId;  // -1 for unassigned
  SArray* vgs;         // SArray<SMqVgEp*>
+  SArray* offsetRows; // SArray<OffsetRows*>
 } SMqConsumerEp;

 SMqConsumerEp* tCloneSMqConsumerEp(const SMqConsumerEp* pEp);
 void           tDeleteSMqConsumerEp(void* pEp);
 int32_t        tEncodeSMqConsumerEp(void** buf, const SMqConsumerEp* pEp);
-void*          tDecodeSMqConsumerEp(const void* buf, SMqConsumerEp* pEp);
+void*          tDecodeSMqConsumerEp(const void* buf, SMqConsumerEp* pEp, int8_t sver);

 typedef struct {
  char      key[TSDB_SUBSCRIBE_KEY_LEN];
@ -588,34 +590,36 @@ typedef struct {
  int64_t   stbUid;
  SHashObj* consumerHash;   // consumerId -> SMqConsumerEp
  SArray*   unassignedVgs;  // SArray<SMqVgEp*>
+  SArray*   offsetRows;
  char      dbName[TSDB_DB_FNAME_LEN];
+  char*     qmsg; // SubPlanToString
 } SMqSubscribeObj;

 SMqSubscribeObj* tNewSubscribeObj(const char key[TSDB_SUBSCRIBE_KEY_LEN]);
 SMqSubscribeObj* tCloneSubscribeObj(const SMqSubscribeObj* pSub);
 void             tDeleteSubscribeObj(SMqSubscribeObj* pSub);
 int32_t          tEncodeSubscribeObj(void** buf, const SMqSubscribeObj* pSub);
-void*            tDecodeSubscribeObj(const void* buf, SMqSubscribeObj* pSub);
+void*            tDecodeSubscribeObj(const void* buf, SMqSubscribeObj* pSub, int8_t sver);

-typedef struct {
-  int32_t epoch;
-  SArray* consumers;  // SArray<SMqConsumerEp*>
-} SMqSubActionLogEntry;
+//typedef struct {
+//  int32_t epoch;
+//  SArray* consumers;  // SArray<SMqConsumerEp*>
+//} SMqSubActionLogEntry;

-SMqSubActionLogEntry* tCloneSMqSubActionLogEntry(SMqSubActionLogEntry* pEntry);
-void                  tDeleteSMqSubActionLogEntry(SMqSubActionLogEntry* pEntry);
-int32_t               tEncodeSMqSubActionLogEntry(void** buf, const SMqSubActionLogEntry* pEntry);
-void*                 tDecodeSMqSubActionLogEntry(const void* buf, SMqSubActionLogEntry* pEntry);
-
-typedef struct {
-  char    key[TSDB_SUBSCRIBE_KEY_LEN];
-  SArray* logs;  // SArray<SMqSubActionLogEntry*>
-} SMqSubActionLogObj;
-
-SMqSubActionLogObj* tCloneSMqSubActionLogObj(SMqSubActionLogObj* pLog);
-void                tDeleteSMqSubActionLogObj(SMqSubActionLogObj* pLog);
-int32_t             tEncodeSMqSubActionLogObj(void** buf, const SMqSubActionLogObj* pLog);
-void*               tDecodeSMqSubActionLogObj(const void* buf, SMqSubActionLogObj* pLog);
+//SMqSubActionLogEntry* tCloneSMqSubActionLogEntry(SMqSubActionLogEntry* pEntry);
+//void                  tDeleteSMqSubActionLogEntry(SMqSubActionLogEntry* pEntry);
+//int32_t               tEncodeSMqSubActionLogEntry(void** buf, const SMqSubActionLogEntry* pEntry);
+//void*                 tDecodeSMqSubActionLogEntry(const void* buf, SMqSubActionLogEntry* pEntry);
+//
+//typedef struct {
+//  char    key[TSDB_SUBSCRIBE_KEY_LEN];
+//  SArray* logs;  // SArray<SMqSubActionLogEntry*>
+//} SMqSubActionLogObj;
+//
+//SMqSubActionLogObj* tCloneSMqSubActionLogObj(SMqSubActionLogObj* pLog);
+//void                tDeleteSMqSubActionLogObj(SMqSubActionLogObj* pLog);
+//int32_t             tEncodeSMqSubActionLogObj(void** buf, const SMqSubActionLogObj* pLog);
+//void*               tDecodeSMqSubActionLogObj(const void* buf, SMqSubActionLogObj* pLog);

 typedef struct {
  int32_t           oldConsumerNum;
@ -634,7 +638,7 @@ typedef struct {
  SArray*               removedConsumers;  // SArray<int64_t>
  SArray*               modifyConsumers;   // SArray<int64_t>
  SMqSubscribeObj*      pSub;
-  SMqSubActionLogEntry* pLogEntry;
+//  SMqSubActionLogEntry* pLogEntry;
 } SMqRebOutputObj;

 typedef struct {
--- a/source/dnode/mnode/impl/src/mndConsumer.c
+++ b/source/dnode/mnode/impl/src/mndConsumer.c
@ -644,7 +644,7 @@ int32_t mndProcessSubscribeReq(SRpcMsg *pMsg) {
  SCMSubscribeReq subscribe = {0};
  tDeserializeSCMSubscribeReq(msgStr, &subscribe);

-  uint64_t        consumerId = subscribe.consumerId;
+  int64_t        consumerId = subscribe.consumerId;
  char           *cgroup = subscribe.cgroup;
  SMqConsumerObj *pExistedConsumer = NULL;
  SMqConsumerObj *pConsumerNew = NULL;
--- a/source/dnode/mnode/impl/src/mndDef.c
+++ b/source/dnode/mnode/impl/src/mndDef.c
@ -187,14 +187,14 @@ SMqVgEp *tCloneSMqVgEp(const SMqVgEp *pVgEp) {
  SMqVgEp *pVgEpNew = taosMemoryMalloc(sizeof(SMqVgEp));
  if (pVgEpNew == NULL) return NULL;
  pVgEpNew->vgId = pVgEp->vgId;
-  pVgEpNew->qmsg = taosStrdup(pVgEp->qmsg);
+//  pVgEpNew->qmsg = taosStrdup(pVgEp->qmsg);
  pVgEpNew->epSet = pVgEp->epSet;
  return pVgEpNew;
 }

 void tDeleteSMqVgEp(SMqVgEp *pVgEp) {
  if (pVgEp) {
-    taosMemoryFreeClear(pVgEp->qmsg);
+//    taosMemoryFreeClear(pVgEp->qmsg);
    taosMemoryFree(pVgEp);
  }
 }
@ -202,14 +202,18 @@ void tDeleteSMqVgEp(SMqVgEp *pVgEp) {
 int32_t tEncodeSMqVgEp(void **buf, const SMqVgEp *pVgEp) {
  int32_t tlen = 0;
  tlen += taosEncodeFixedI32(buf, pVgEp->vgId);
-  tlen += taosEncodeString(buf, pVgEp->qmsg);
+//  tlen += taosEncodeString(buf, pVgEp->qmsg);
  tlen += taosEncodeSEpSet(buf, &pVgEp->epSet);
  return tlen;
 }

-void *tDecodeSMqVgEp(const void *buf, SMqVgEp *pVgEp) {
+void *tDecodeSMqVgEp(const void *buf, SMqVgEp *pVgEp, int8_t sver) {
  buf = taosDecodeFixedI32(buf, &pVgEp->vgId);
-  buf = taosDecodeString(buf, &pVgEp->qmsg);
+  if(sver == 1){
+    uint64_t size = 0;
+    buf = taosDecodeVariantU64(buf, &size);
+    buf = POINTER_SHIFT(buf, size);
+  }
  buf = taosDecodeSEpSet(buf, &pVgEp->epSet);
  return (void *)buf;
 }
@ -395,6 +399,22 @@ int32_t tEncodeSMqConsumerEp(void **buf, const SMqConsumerEp *pConsumerEp) {
  int32_t tlen = 0;
  tlen += taosEncodeFixedI64(buf, pConsumerEp->consumerId);
  tlen += taosEncodeArray(buf, pConsumerEp->vgs, (FEncode)tEncodeSMqVgEp);
+  int32_t szVgs = taosArrayGetSize(pConsumerEp->offsetRows);
+  tlen += taosEncodeFixedI32(buf, szVgs);
+  for (int32_t j= 0; j < szVgs; ++j) {
+    OffsetRows *offRows = taosArrayGet(pConsumerEp->offsetRows, j);
+    tlen += taosEncodeFixedI32(buf, offRows->vgId);
+    tlen += taosEncodeFixedI64(buf, offRows->rows);
+    tlen += taosEncodeFixedI8(buf, offRows->offset.type);
+    if (offRows->offset.type == TMQ_OFFSET__SNAPSHOT_DATA || offRows->offset.type == TMQ_OFFSET__SNAPSHOT_META) {
+      tlen += taosEncodeFixedI64(buf, offRows->offset.uid);
+      tlen += taosEncodeFixedI64(buf, offRows->offset.ts);
+    } else if (offRows->offset.type == TMQ_OFFSET__LOG) {
+      tlen += taosEncodeFixedI64(buf, offRows->offset.version);
+    } else {
+      // do nothing
+    }
+  }
 #if 0
  int32_t sz = taosArrayGetSize(pConsumerEp->vgs);
  tlen += taosEncodeFixedI32(buf, sz);
@ -406,9 +426,9 @@ int32_t tEncodeSMqConsumerEp(void **buf, const SMqConsumerEp *pConsumerEp) {
  return tlen;
 }

-void *tDecodeSMqConsumerEp(const void *buf, SMqConsumerEp *pConsumerEp) {
+void *tDecodeSMqConsumerEp(const void *buf, SMqConsumerEp *pConsumerEp, int8_t sver) {
  buf = taosDecodeFixedI64(buf, &pConsumerEp->consumerId);
-  buf = taosDecodeArray(buf, &pConsumerEp->vgs, (FDecode)tDecodeSMqVgEp, sizeof(SMqVgEp));
+  buf = taosDecodeArray(buf, &pConsumerEp->vgs, (FDecode)tDecodeSMqVgEp, sizeof(SMqVgEp), sver);
 #if 0
  int32_t sz;
  buf = taosDecodeFixedI32(buf, &sz);
@ -419,7 +439,28 @@ void *tDecodeSMqConsumerEp(const void *buf, SMqConsumerEp *pConsumerEp) {
    taosArrayPush(pConsumerEp->vgs, &pVgEp);
  }
 #endif
-
+  if (sver > 1){
+    int32_t szVgs = 0;
+    buf = taosDecodeFixedI32(buf, &szVgs);
+    if(szVgs > 0){
+      pConsumerEp->offsetRows = taosArrayInit(szVgs, sizeof(OffsetRows));
+      if (NULL == pConsumerEp->offsetRows) return NULL;
+      for (int32_t j= 0; j < szVgs; ++j) {
+        OffsetRows* offRows = taosArrayReserve(pConsumerEp->offsetRows, 1);
+        buf = taosDecodeFixedI32(buf, &offRows->vgId);
+        buf = taosDecodeFixedI64(buf, &offRows->rows);
+        buf = taosDecodeFixedI8(buf, &offRows->offset.type);
+        if (offRows->offset.type == TMQ_OFFSET__SNAPSHOT_DATA || offRows->offset.type == TMQ_OFFSET__SNAPSHOT_META) {
+          buf = taosDecodeFixedI64(buf, &offRows->offset.uid);
+          buf = taosDecodeFixedI64(buf, &offRows->offset.ts);
+        } else if (offRows->offset.type == TMQ_OFFSET__LOG) {
+          buf = taosDecodeFixedI64(buf, &offRows->offset.version);
+        } else {
+          // do nothing
+        }
+      }
+    }
+  }
  return (void *)buf;
 }

@ -468,7 +509,9 @@ SMqSubscribeObj *tCloneSubscribeObj(const SMqSubscribeObj *pSub) {
    taosHashPut(pSubNew->consumerHash, &newEp.consumerId, sizeof(int64_t), &newEp, sizeof(SMqConsumerEp));
  }
  pSubNew->unassignedVgs = taosArrayDup(pSub->unassignedVgs, (__array_item_dup_fn_t)tCloneSMqVgEp);
+  pSubNew->offsetRows = taosArrayDup(pSub->offsetRows, NULL);
  memcpy(pSubNew->dbName, pSub->dbName, TSDB_DB_FNAME_LEN);
+  pSubNew->qmsg = taosStrdup(pSub->qmsg);
  return pSubNew;
 }

@ -482,6 +525,8 @@ void tDeleteSubscribeObj(SMqSubscribeObj *pSub) {
  }
  taosHashCleanup(pSub->consumerHash);
  taosArrayDestroyP(pSub->unassignedVgs, (FDelete)tDeleteSMqVgEp);
+  taosMemoryFreeClear(pSub->qmsg);
+  taosArrayDestroy(pSub->offsetRows);
 }

 int32_t tEncodeSubscribeObj(void **buf, const SMqSubscribeObj *pSub) {
@ -508,10 +553,27 @@ int32_t tEncodeSubscribeObj(void **buf, const SMqSubscribeObj *pSub) {
  if (cnt != sz) return -1;
  tlen += taosEncodeArray(buf, pSub->unassignedVgs, (FEncode)tEncodeSMqVgEp);
  tlen += taosEncodeString(buf, pSub->dbName);
+  int32_t szVgs = taosArrayGetSize(pSub->offsetRows);
+  tlen += taosEncodeFixedI32(buf, szVgs);
+  for (int32_t j= 0; j < szVgs; ++j) {
+    OffsetRows *offRows = taosArrayGet(pSub->offsetRows, j);
+    tlen += taosEncodeFixedI32(buf, offRows->vgId);
+    tlen += taosEncodeFixedI64(buf, offRows->rows);
+    tlen += taosEncodeFixedI8(buf, offRows->offset.type);
+    if (offRows->offset.type == TMQ_OFFSET__SNAPSHOT_DATA || offRows->offset.type == TMQ_OFFSET__SNAPSHOT_META) {
+      tlen += taosEncodeFixedI64(buf, offRows->offset.uid);
+      tlen += taosEncodeFixedI64(buf, offRows->offset.ts);
+    } else if (offRows->offset.type == TMQ_OFFSET__LOG) {
+      tlen += taosEncodeFixedI64(buf, offRows->offset.version);
+    } else {
+      // do nothing
+    }
+  }
+  tlen += taosEncodeString(buf, pSub->qmsg);
  return tlen;
 }

-void *tDecodeSubscribeObj(const void *buf, SMqSubscribeObj *pSub) {
+void *tDecodeSubscribeObj(const void *buf, SMqSubscribeObj *pSub, int8_t sver) {
  //
  buf = taosDecodeStringTo(buf, pSub->key);
  buf = taosDecodeFixedI64(buf, &pSub->dbUid);
@ -526,74 +588,99 @@ void *tDecodeSubscribeObj(const void *buf, SMqSubscribeObj *pSub) {
  pSub->consumerHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK);
  for (int32_t i = 0; i < sz; i++) {
    SMqConsumerEp consumerEp = {0};
-    buf = tDecodeSMqConsumerEp(buf, &consumerEp);
+    buf = tDecodeSMqConsumerEp(buf, &consumerEp, sver);
    taosHashPut(pSub->consumerHash, &consumerEp.consumerId, sizeof(int64_t), &consumerEp, sizeof(SMqConsumerEp));
  }

-  buf = taosDecodeArray(buf, &pSub->unassignedVgs, (FDecode)tDecodeSMqVgEp, sizeof(SMqVgEp));
+  buf = taosDecodeArray(buf, &pSub->unassignedVgs, (FDecode)tDecodeSMqVgEp, sizeof(SMqVgEp), sver);
  buf = taosDecodeStringTo(buf, pSub->dbName);
+  if (sver > 1){
+    int32_t szVgs = 0;
+    buf = taosDecodeFixedI32(buf, &szVgs);
+    if(szVgs > 0){
+      pSub->offsetRows = taosArrayInit(szVgs, sizeof(OffsetRows));
+      if (NULL == pSub->offsetRows) return NULL;
+      for (int32_t j= 0; j < szVgs; ++j) {
+        OffsetRows* offRows = taosArrayReserve(pSub->offsetRows, 1);
+        buf = taosDecodeFixedI32(buf, &offRows->vgId);
+        buf = taosDecodeFixedI64(buf, &offRows->rows);
+        buf = taosDecodeFixedI8(buf, &offRows->offset.type);
+        if (offRows->offset.type == TMQ_OFFSET__SNAPSHOT_DATA || offRows->offset.type == TMQ_OFFSET__SNAPSHOT_META) {
+          buf = taosDecodeFixedI64(buf, &offRows->offset.uid);
+          buf = taosDecodeFixedI64(buf, &offRows->offset.ts);
+        } else if (offRows->offset.type == TMQ_OFFSET__LOG) {
+          buf = taosDecodeFixedI64(buf, &offRows->offset.version);
+        } else {
+          // do nothing
+        }
+      }
+    }
+    buf = taosDecodeString(buf, &pSub->qmsg);
+  }else{
+    pSub->qmsg = taosStrdup("");
+  }
  return (void *)buf;
 }

-SMqSubActionLogEntry *tCloneSMqSubActionLogEntry(SMqSubActionLogEntry *pEntry) {
-  SMqSubActionLogEntry *pEntryNew = taosMemoryMalloc(sizeof(SMqSubActionLogEntry));
-  if (pEntryNew == NULL) return NULL;
-  pEntryNew->epoch = pEntry->epoch;
-  pEntryNew->consumers = taosArrayDup(pEntry->consumers, (__array_item_dup_fn_t)tCloneSMqConsumerEp);
-  return pEntryNew;
-}
-
-void tDeleteSMqSubActionLogEntry(SMqSubActionLogEntry *pEntry) {
-  taosArrayDestroyEx(pEntry->consumers, (FDelete)tDeleteSMqConsumerEp);
-}
-
-int32_t tEncodeSMqSubActionLogEntry(void **buf, const SMqSubActionLogEntry *pEntry) {
-  int32_t tlen = 0;
-  tlen += taosEncodeFixedI32(buf, pEntry->epoch);
-  tlen += taosEncodeArray(buf, pEntry->consumers, (FEncode)tEncodeSMqSubActionLogEntry);
-  return tlen;
-}
-
-void *tDecodeSMqSubActionLogEntry(const void *buf, SMqSubActionLogEntry *pEntry) {
-  buf = taosDecodeFixedI32(buf, &pEntry->epoch);
-  buf = taosDecodeArray(buf, &pEntry->consumers, (FDecode)tDecodeSMqSubActionLogEntry, sizeof(SMqSubActionLogEntry));
-  return (void *)buf;
-}
-
-SMqSubActionLogObj *tCloneSMqSubActionLogObj(SMqSubActionLogObj *pLog) {
-  SMqSubActionLogObj *pLogNew = taosMemoryMalloc(sizeof(SMqSubActionLogObj));
-  if (pLogNew == NULL) return pLogNew;
-  memcpy(pLogNew->key, pLog->key, TSDB_SUBSCRIBE_KEY_LEN);
-  pLogNew->logs = taosArrayDup(pLog->logs, (__array_item_dup_fn_t)tCloneSMqConsumerEp);
-  return pLogNew;
-}
-
-void tDeleteSMqSubActionLogObj(SMqSubActionLogObj *pLog) {
-  taosArrayDestroyEx(pLog->logs, (FDelete)tDeleteSMqConsumerEp);
-}
-
-int32_t tEncodeSMqSubActionLogObj(void **buf, const SMqSubActionLogObj *pLog) {
-  int32_t tlen = 0;
-  tlen += taosEncodeString(buf, pLog->key);
-  tlen += taosEncodeArray(buf, pLog->logs, (FEncode)tEncodeSMqSubActionLogEntry);
-  return tlen;
-}
-
-void *tDecodeSMqSubActionLogObj(const void *buf, SMqSubActionLogObj *pLog) {
-  buf = taosDecodeStringTo(buf, pLog->key);
-  buf = taosDecodeArray(buf, &pLog->logs, (FDecode)tDecodeSMqSubActionLogEntry, sizeof(SMqSubActionLogEntry));
-  return (void *)buf;
-}
-
-int32_t tEncodeSMqOffsetObj(void **buf, const SMqOffsetObj *pOffset) {
-  int32_t tlen = 0;
-  tlen += taosEncodeString(buf, pOffset->key);
-  tlen += taosEncodeFixedI64(buf, pOffset->offset);
-  return tlen;
-}
-
-void *tDecodeSMqOffsetObj(void *buf, SMqOffsetObj *pOffset) {
-  buf = taosDecodeStringTo(buf, pOffset->key);
-  buf = taosDecodeFixedI64(buf, &pOffset->offset);
-  return buf;
-}
+//SMqSubActionLogEntry *tCloneSMqSubActionLogEntry(SMqSubActionLogEntry *pEntry) {
+//  SMqSubActionLogEntry *pEntryNew = taosMemoryMalloc(sizeof(SMqSubActionLogEntry));
+//  if (pEntryNew == NULL) return NULL;
+//  pEntryNew->epoch = pEntry->epoch;
+//  pEntryNew->consumers = taosArrayDup(pEntry->consumers, (__array_item_dup_fn_t)tCloneSMqConsumerEp);
+//  return pEntryNew;
+//}
+//
+//void tDeleteSMqSubActionLogEntry(SMqSubActionLogEntry *pEntry) {
+//  taosArrayDestroyEx(pEntry->consumers, (FDelete)tDeleteSMqConsumerEp);
+//}
+//
+//int32_t tEncodeSMqSubActionLogEntry(void **buf, const SMqSubActionLogEntry *pEntry) {
+//  int32_t tlen = 0;
+//  tlen += taosEncodeFixedI32(buf, pEntry->epoch);
+//  tlen += taosEncodeArray(buf, pEntry->consumers, (FEncode)tEncodeSMqSubActionLogEntry);
+//  return tlen;
+//}
+//
+//void *tDecodeSMqSubActionLogEntry(const void *buf, SMqSubActionLogEntry *pEntry) {
+//  buf = taosDecodeFixedI32(buf, &pEntry->epoch);
+//  buf = taosDecodeArray(buf, &pEntry->consumers, (FDecode)tDecodeSMqSubActionLogEntry, sizeof(SMqSubActionLogEntry));
+//  return (void *)buf;
+//}
+//
+//SMqSubActionLogObj *tCloneSMqSubActionLogObj(SMqSubActionLogObj *pLog) {
+//  SMqSubActionLogObj *pLogNew = taosMemoryMalloc(sizeof(SMqSubActionLogObj));
+//  if (pLogNew == NULL) return pLogNew;
+//  memcpy(pLogNew->key, pLog->key, TSDB_SUBSCRIBE_KEY_LEN);
+//  pLogNew->logs = taosArrayDup(pLog->logs, (__array_item_dup_fn_t)tCloneSMqConsumerEp);
+//  return pLogNew;
+//}
+//
+//void tDeleteSMqSubActionLogObj(SMqSubActionLogObj *pLog) {
+//  taosArrayDestroyEx(pLog->logs, (FDelete)tDeleteSMqConsumerEp);
+//}
+//
+//int32_t tEncodeSMqSubActionLogObj(void **buf, const SMqSubActionLogObj *pLog) {
+//  int32_t tlen = 0;
+//  tlen += taosEncodeString(buf, pLog->key);
+//  tlen += taosEncodeArray(buf, pLog->logs, (FEncode)tEncodeSMqSubActionLogEntry);
+//  return tlen;
+//}
+//
+//void *tDecodeSMqSubActionLogObj(const void *buf, SMqSubActionLogObj *pLog) {
+//  buf = taosDecodeStringTo(buf, pLog->key);
+//  buf = taosDecodeArray(buf, &pLog->logs, (FDecode)tDecodeSMqSubActionLogEntry, sizeof(SMqSubActionLogEntry));
+//  return (void *)buf;
+//}
+//
+//int32_t tEncodeSMqOffsetObj(void **buf, const SMqOffsetObj *pOffset) {
+//  int32_t tlen = 0;
+//  tlen += taosEncodeString(buf, pOffset->key);
+//  tlen += taosEncodeFixedI64(buf, pOffset->offset);
+//  return tlen;
+//}
+//
+//void *tDecodeSMqOffsetObj(void *buf, SMqOffsetObj *pOffset) {
+//  buf = taosDecodeStringTo(buf, pOffset->key);
+//  buf = taosDecodeFixedI64(buf, &pOffset->offset);
+//  return buf;
+//}
--- a/source/dnode/mnode/impl/src/mndProfile.c
+++ b/source/dnode/mnode/impl/src/mndProfile.c
@ -764,11 +764,101 @@ static int32_t mndRetrieveConns(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl
  return numOfRows;
 }

+/**
+ * @param pConn the conn queries pack from
+ * @param[out] pBlock the block data packed into
+ * @param offset skip [offset] queries in pConn
+ * @param rowsToPack at most rows to pack
+ * @return rows packed
+*/
+static int32_t packQueriesIntoBlock(SShowObj* pShow, SConnObj* pConn, SSDataBlock* pBlock, uint32_t offset, uint32_t rowsToPack) {
+  int32_t cols = 0;
+  taosRLockLatch(&pConn->queryLock);
+  int32_t numOfQueries = taosArrayGetSize(pConn->pQueries);
+  if (NULL == pConn->pQueries || numOfQueries <= offset) {
+    taosRUnLockLatch(&pConn->queryLock);
+    return 0;
+  }
+
+  int32_t i = offset;
+  for (; i < numOfQueries && (i - offset) < rowsToPack; ++i) {
+    int32_t curRowIndex = pBlock->info.rows;
+    SQueryDesc *pQuery = taosArrayGet(pConn->pQueries, i);
+    cols = 0;
+
+    char queryId[26 + VARSTR_HEADER_SIZE] = {0};
+    sprintf(&queryId[VARSTR_HEADER_SIZE], "%x:%" PRIx64, pConn->id, pQuery->reqRid);
+    varDataLen(queryId) = strlen(&queryId[VARSTR_HEADER_SIZE]);
+    SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataSetVal(pColInfo, curRowIndex, (const char *)queryId, false);
+
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->queryId, false);
+
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataSetVal(pColInfo, curRowIndex, (const char *)&pConn->id, false);
+
+    char app[TSDB_APP_NAME_LEN + VARSTR_HEADER_SIZE];
+    STR_TO_VARSTR(app, pConn->app);
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataSetVal(pColInfo, curRowIndex, (const char *)app, false);
+
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataSetVal(pColInfo, curRowIndex, (const char *)&pConn->pid, false);
+
+    char user[TSDB_USER_LEN + VARSTR_HEADER_SIZE] = {0};
+    STR_TO_VARSTR(user, pConn->user);
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataSetVal(pColInfo, curRowIndex, (const char *)user, false);
+
+    char endpoint[TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE] = {0};
+    sprintf(&endpoint[VARSTR_HEADER_SIZE], "%s:%d", taosIpStr(pConn->ip), pConn->port);
+    varDataLen(endpoint) = strlen(&endpoint[VARSTR_HEADER_SIZE]);
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataSetVal(pColInfo, curRowIndex, (const char *)endpoint, false);
+
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->stime, false);
+
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->useconds, false);
+
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->stableQuery, false);
+
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->subPlanNum, false);
+
+    char    subStatus[TSDB_SHOW_SUBQUERY_LEN + VARSTR_HEADER_SIZE] = {0};
+    int32_t strSize = sizeof(subStatus);
+    int32_t offset = VARSTR_HEADER_SIZE;
+    for (int32_t i = 0; i < pQuery->subPlanNum && offset < strSize; ++i) {
+      if (i) {
+        offset += snprintf(subStatus + offset, strSize - offset - 1, ",");
+      }
+      SQuerySubDesc *pDesc = taosArrayGet(pQuery->subDesc, i);
+      offset += snprintf(subStatus + offset, strSize - offset - 1, "%" PRIu64 ":%s", pDesc->tid, pDesc->status);
+    }
+    varDataLen(subStatus) = strlen(&subStatus[VARSTR_HEADER_SIZE]);
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataSetVal(pColInfo, curRowIndex, subStatus, false);
+
+    char sql[TSDB_SHOW_SQL_LEN + VARSTR_HEADER_SIZE] = {0};
+    STR_TO_VARSTR(sql, pQuery->sql);
+    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    colDataSetVal(pColInfo, curRowIndex, (const char *)sql, false);
+
+    pBlock->info.rows++;
+  }
+
+  taosRUnLockLatch(&pConn->queryLock);
+  return i - offset;
+}
+
 static int32_t mndRetrieveQueries(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
-  SMnode   *pMnode = pReq->info.node;
-  SSdb     *pSdb = pMnode->pSdb;
+  SMnode *  pMnode = pReq->info.node;
+  SSdb *    pSdb = pMnode->pSdb;
  int32_t   numOfRows = 0;
-  int32_t   cols = 0;
  SConnObj *pConn = NULL;

  if (pShow->pIter == NULL) {
@ -776,6 +866,16 @@ static int32_t mndRetrieveQueries(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *p
    pShow->pIter = taosCacheCreateIter(pMgmt->connCache);
  }

+  // means fetched some data last time for this conn
+  if (pShow->curIterPackedRows > 0) {
+    size_t len = 0;
+    pConn = taosCacheIterGetData(pShow->pIter, &len);
+    if (pConn && (taosArrayGetSize(pConn->pQueries) > pShow->curIterPackedRows)) {
+      numOfRows = packQueriesIntoBlock(pShow, pConn, pBlock, pShow->curIterPackedRows, rows);
+      pShow->curIterPackedRows += numOfRows;
+    }
+  }
+
  while (numOfRows < rows) {
    pConn = mndGetNextConn(pMnode, pShow->pIter);
    if (pConn == NULL) {
@ -783,85 +883,10 @@ static int32_t mndRetrieveQueries(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *p
      break;
    }

-    taosRLockLatch(&pConn->queryLock);
-    if (NULL == pConn->pQueries || taosArrayGetSize(pConn->pQueries) <= 0) {
-      taosRUnLockLatch(&pConn->queryLock);
-      continue;
-    }
-
-    int32_t numOfQueries = taosArrayGetSize(pConn->pQueries);
-    for (int32_t i = 0; i < numOfQueries && numOfRows < rows; ++i) {
-      SQueryDesc *pQuery = taosArrayGet(pConn->pQueries, i);
-      cols = 0;
-
-      char queryId[26 + VARSTR_HEADER_SIZE] = {0};
-      sprintf(&queryId[VARSTR_HEADER_SIZE], "%x:%" PRIx64, pConn->id, pQuery->reqRid);
-      varDataLen(queryId) = strlen(&queryId[VARSTR_HEADER_SIZE]);
-      SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)queryId, false);
-
-      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)&pQuery->queryId, false);
-
-      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)&pConn->id, false);
-
-      char app[TSDB_APP_NAME_LEN + VARSTR_HEADER_SIZE];
-      STR_TO_VARSTR(app, pConn->app);
-      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)app, false);
-
-      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)&pConn->pid, false);
-
-      char user[TSDB_USER_LEN + VARSTR_HEADER_SIZE] = {0};
-      STR_TO_VARSTR(user, pConn->user);
-      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)user, false);
-
-      char endpoint[TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE] = {0};
-      sprintf(&endpoint[VARSTR_HEADER_SIZE], "%s:%d", taosIpStr(pConn->ip), pConn->port);
-      varDataLen(endpoint) = strlen(&endpoint[VARSTR_HEADER_SIZE]);
-      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)endpoint, false);
-
-      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)&pQuery->stime, false);
-
-      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)&pQuery->useconds, false);
-
-      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)&pQuery->stableQuery, false);
-
-      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)&pQuery->subPlanNum, false);
-
-      char    subStatus[TSDB_SHOW_SUBQUERY_LEN + VARSTR_HEADER_SIZE] = {0};
-      int32_t strSize = sizeof(subStatus);
-      int32_t offset = VARSTR_HEADER_SIZE;
-      for (int32_t i = 0; i < pQuery->subPlanNum && offset < strSize; ++i) {
-        if (i) {
-          offset += snprintf(subStatus + offset, strSize - offset - 1, ",");
-        }
-        SQuerySubDesc *pDesc = taosArrayGet(pQuery->subDesc, i);
-        offset += snprintf(subStatus + offset, strSize - offset - 1, "%" PRIu64 ":%s", pDesc->tid, pDesc->status);
-      }
-      varDataLen(subStatus) = strlen(&subStatus[VARSTR_HEADER_SIZE]);
-      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, subStatus, false);
-
-      char sql[TSDB_SHOW_SQL_LEN + VARSTR_HEADER_SIZE] = {0};
-      STR_TO_VARSTR(sql, pQuery->sql);
-      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)sql, false);
-
-      numOfRows++;
-    }
-
-    taosRUnLockLatch(&pConn->queryLock);
+    int32_t packedRows = packQueriesIntoBlock(pShow, pConn, pBlock, 0, rows - numOfRows);
+    pShow->curIterPackedRows = packedRows;
+    numOfRows += packedRows;
  }
-
  pShow->numOfRows += numOfRows;
  return numOfRows;
 }
--- a/source/dnode/mnode/impl/src/mndScheduler.c
+++ b/source/dnode/mnode/impl/src/mndScheduler.c
@ -570,25 +570,21 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib

    mDebug("init subscription %s for topic:%s assign vgId:%d", pSub->key, pTopic->name, pVgEp->vgId);

-    if (pSubplan) {
-      int32_t msgLen;
-
-      pSubplan->execNode.epSet = pVgEp->epSet;
-      pSubplan->execNode.nodeId = pVgEp->vgId;
-
-      if (qSubPlanToString(pSubplan, &pVgEp->qmsg, &msgLen) < 0) {
-        sdbRelease(pSdb, pVgroup);
-        qDestroyQueryPlan(pPlan);
-        terrno = TSDB_CODE_QRY_INVALID_INPUT;
-        return -1;
-      }
-    } else {
-      pVgEp->qmsg = taosStrdup("");
-    }
-
    sdbRelease(pSdb, pVgroup);
  }

+  if (pSubplan) {
+    int32_t msgLen;
+
+    if (qSubPlanToString(pSubplan, &pSub->qmsg, &msgLen) < 0) {
+      qDestroyQueryPlan(pPlan);
+      terrno = TSDB_CODE_QRY_INVALID_INPUT;
+      return -1;
+    }
+  } else {
+    pSub->qmsg = taosStrdup("");
+  }
+
  qDestroyQueryPlan(pPlan);
  return 0;
 }
--- a/source/dnode/mnode/impl/src/mndSubscribe.c
+++ b/source/dnode/mnode/impl/src/mndSubscribe.c
@ -24,7 +24,7 @@
 #include "tcompare.h"
 #include "tname.h"

-#define MND_SUBSCRIBE_VER_NUMBER   1
+#define MND_SUBSCRIBE_VER_NUMBER   2
 #define MND_SUBSCRIBE_RESERVE_SIZE 64

 #define MND_SUBSCRIBE_REBALANCE_CNT 3
@ -99,13 +99,23 @@ static SMqSubscribeObj *mndCreateSubscription(SMnode *pMnode, const SMqTopicObj
  return pSub;
 }

-static int32_t mndBuildSubChangeReq(void **pBuf, int32_t *pLen, const SMqSubscribeObj *pSub,
-                                    const SMqRebOutputVg *pRebVg) {
+static int32_t mndBuildSubChangeReq(void **pBuf, int32_t *pLen, SMqSubscribeObj *pSub,
+                                    const SMqRebOutputVg *pRebVg, SSubplan* pPlan) {
  SMqRebVgReq req = {0};
  req.oldConsumerId = pRebVg->oldConsumerId;
  req.newConsumerId = pRebVg->newConsumerId;
  req.vgId = pRebVg->pVgEp->vgId;
-  req.qmsg = pRebVg->pVgEp->qmsg;
+  if(pPlan){
+    pPlan->execNode.epSet = pRebVg->pVgEp->epSet;
+    pPlan->execNode.nodeId = pRebVg->pVgEp->vgId;
+    int32_t msgLen;
+    if (qSubPlanToString(pPlan, &req.qmsg, &msgLen) < 0) {
+      terrno = TSDB_CODE_QRY_INVALID_INPUT;
+      return -1;
+    }
+  }else{
+    req.qmsg = taosStrdup("");
+  }
  req.subType = pSub->subType;
  req.withMeta = pSub->withMeta;
  req.suid = pSub->stbUid;
@ -115,6 +125,7 @@ static int32_t mndBuildSubChangeReq(void **pBuf, int32_t *pLen, const SMqSubscri
  int32_t ret = 0;
  tEncodeSize(tEncodeSMqRebVgReq, &req, tlen, ret);
  if (ret < 0) {
+    taosMemoryFree(req.qmsg);
    return -1;
  }

@ -122,6 +133,7 @@ static int32_t mndBuildSubChangeReq(void **pBuf, int32_t *pLen, const SMqSubscri
  void   *buf = taosMemoryMalloc(tlen);
  if (buf == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    taosMemoryFree(req.qmsg);
    return -1;
  }

@ -135,17 +147,19 @@ static int32_t mndBuildSubChangeReq(void **pBuf, int32_t *pLen, const SMqSubscri
  if (tEncodeSMqRebVgReq(&encoder, &req) < 0) {
    taosMemoryFreeClear(buf);
    tEncoderClear(&encoder);
+    taosMemoryFree(req.qmsg);
    return -1;
  }
  tEncoderClear(&encoder);
  *pBuf = buf;
  *pLen = tlen;

+  taosMemoryFree(req.qmsg);
  return 0;
 }

-static int32_t mndPersistSubChangeVgReq(SMnode *pMnode, STrans *pTrans, const SMqSubscribeObj *pSub,
-                                        const SMqRebOutputVg *pRebVg) {
+static int32_t mndPersistSubChangeVgReq(SMnode *pMnode, STrans *pTrans, SMqSubscribeObj *pSub,
+                                        const SMqRebOutputVg *pRebVg, SSubplan* pPlan) {
 //  if (pRebVg->oldConsumerId == pRebVg->newConsumerId) {
 //    terrno = TSDB_CODE_MND_INVALID_SUB_OPTION;
 //    return -1;
@ -153,7 +167,7 @@ static int32_t mndPersistSubChangeVgReq(SMnode *pMnode, STrans *pTrans, const SM

  void   *buf;
  int32_t tlen;
-  if (mndBuildSubChangeReq(&buf, &tlen, pSub, pRebVg) < 0) {
+  if (mndBuildSubChangeReq(&buf, &tlen, pSub, pRebVg, pPlan) < 0) {
    return -1;
  }

@ -255,7 +269,7 @@ static void doAddNewConsumers(SMqRebOutputObj *pOutput, const SMqRebInputObj *pI
  for (int32_t i = 0; i < numOfNewConsumers; i++) {
    int64_t consumerId = *(int64_t *)taosArrayGet(pInput->pRebInfo->newConsumers, i);

-    SMqConsumerEp newConsumerEp;
+    SMqConsumerEp newConsumerEp = {0};
    newConsumerEp.consumerId = consumerId;
    newConsumerEp.vgs = taosArrayInit(0, sizeof(void *));

@ -483,14 +497,25 @@ static int32_t mndDoRebalance(SMnode *pMnode, const SMqRebInputObj *pInput, SMqR
 }

 static int32_t mndPersistRebResult(SMnode *pMnode, SRpcMsg *pMsg, const SMqRebOutputObj *pOutput) {
+  struct SSubplan* pPlan = NULL;
+  if(strcmp(pOutput->pSub->qmsg, "") != 0){
+    int32_t code = qStringToSubplan(pOutput->pSub->qmsg, &pPlan);
+    if (code != TSDB_CODE_SUCCESS) {
+      terrno = code;
+      return -1;
+    }
+  }
+
  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_DB_INSIDE, pMsg, "tmq-reb");
  if (pTrans == NULL) {
+    nodesDestroyNode((SNode*)pPlan);
    return -1;
  }

  mndTransSetDbName(pTrans, pOutput->pSub->dbName, NULL);
  if (mndTrancCheckConflict(pMnode, pTrans) != 0) {
    mndTransDrop(pTrans);
+    nodesDestroyNode((SNode*)pPlan);
    return -1;
  }

@ -500,11 +525,13 @@ static int32_t mndPersistRebResult(SMnode *pMnode, SRpcMsg *pMsg, const SMqRebOu
  int32_t       vgNum = taosArrayGetSize(rebVgs);
  for (int32_t i = 0; i < vgNum; i++) {
    SMqRebOutputVg *pRebVg = taosArrayGet(rebVgs, i);
-    if (mndPersistSubChangeVgReq(pMnode, pTrans, pOutput->pSub, pRebVg) < 0) {
+    if (mndPersistSubChangeVgReq(pMnode, pTrans, pOutput->pSub, pRebVg, pPlan) < 0) {
      mndTransDrop(pTrans);
+      nodesDestroyNode((SNode*)pPlan);
      return -1;
    }
  }
+  nodesDestroyNode((SNode*)pPlan);

  // 2. redo log: subscribe and vg assignment
  // subscribe
@ -809,7 +836,7 @@ static SSdbRow *mndSubActionDecode(SSdbRaw *pRaw) {
  int8_t sver = 0;
  if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto SUB_DECODE_OVER;

-  if (sver != MND_SUBSCRIBE_VER_NUMBER) {
+  if (sver > MND_SUBSCRIBE_VER_NUMBER || sver < 1) {
    terrno = TSDB_CODE_SDB_INVALID_DATA_VER;
    goto SUB_DECODE_OVER;
  }
@ -828,7 +855,7 @@ static SSdbRow *mndSubActionDecode(SSdbRaw *pRaw) {
  SDB_GET_BINARY(pRaw, dataPos, buf, tlen, SUB_DECODE_OVER);
  SDB_GET_RESERVE(pRaw, dataPos, MND_SUBSCRIBE_RESERVE_SIZE, SUB_DECODE_OVER);

-  if (tDecodeSubscribeObj(buf, pSub) == NULL) {
+  if (tDecodeSubscribeObj(buf, pSub, sver) == NULL) {
    goto SUB_DECODE_OVER;
  }

--- a/source/dnode/vnode/CMakeLists.txt
+++ b/source/dnode/vnode/CMakeLists.txt
@ -80,14 +80,50 @@ IF (TD_VNODE_PLUGINS)
  )
 ENDIF ()

-target_include_directories(
-    vnode
-    PUBLIC "inc"
-    PUBLIC "src/inc"
-    PUBLIC "${TD_SOURCE_DIR}/include/libs/scalar"
-    PUBLIC "${TD_SOURCE_DIR}/contrib/rocksdb/include"
-)
-IF (TD_LINUX)
+# IF (NOT ${TD_LINUX})
+# target_include_directories(
+#     vnode
+#     PUBLIC "inc"
+#     PUBLIC "src/inc"
+#     PUBLIC "${TD_SOURCE_DIR}/include/libs/scalar"
+#     PUBLIC "${TD_SOURCE_DIR}/contrib/rocksdb/include"
+# )
+# ELSE()
+# target_include_directories(
+#     vnode
+#     PUBLIC "inc"
+#     PUBLIC "src/inc"
+#     PUBLIC "${TD_SOURCE_DIR}/include/libs/scalar"
+# )
+#ENDIF(NOT ${TD_LINUX})
+
+if (${BUILD_CONTRIB})
+    target_include_directories(
+        vnode
+        PUBLIC "inc"
+        PUBLIC "src/inc"
+        PUBLIC "${TD_SOURCE_DIR}/include/libs/scalar"
+        PUBLIC "${TD_SOURCE_DIR}/contrib/rocksdb/include"
+    )
+else()
+    target_include_directories(
+        vnode
+        PUBLIC "inc"
+        PUBLIC "src/inc"
+        PUBLIC "${TD_SOURCE_DIR}/include/libs/scalar"
+    )
+    if (${TD_LINUX})
+        target_include_directories(
+            vnode 
+            PUBLIC "${TD_SOURCE_DIR}/deps/${TD_DEPS_DIR}/rocksdb_static"
+        )
+        target_link_directories(
+            vnode 
+            PUBLIC "${TD_SOURCE_DIR}/deps/${TD_DEPS_DIR}/rocksdb_static"
+        )
+    endif()
+endif()
+
 target_link_libraries(
    vnode
    PUBLIC os
@ -108,28 +144,6 @@ target_link_libraries(
    PUBLIC stream
    PUBLIC index
 )
-ELSE()
-target_link_libraries(
-    vnode
-    PUBLIC os
-    PUBLIC util
-    PUBLIC common
-    PUBLIC tfs
-    PUBLIC wal
-    PUBLIC qworker
-    PUBLIC sync
-    PUBLIC executor
-    PUBLIC scheduler
-    PUBLIC tdb
-
-    # PUBLIC bdb
-    # PUBLIC scalar
-    PUBLIC rocksdb
-    PUBLIC transport
-    PUBLIC stream
-    PUBLIC index
-)
-ENDIF()

 IF (TD_GRANT)
  TARGET_LINK_LIBRARIES(vnode PUBLIC grant)
--- a/source/dnode/vnode/src/inc/tq.h
+++ b/source/dnode/vnode/src/inc/tq.h
@ -139,6 +139,7 @@ static STqMgmt tqMgmt = {0};

 int32_t tEncodeSTqHandle(SEncoder* pEncoder, const STqHandle* pHandle);
 int32_t tDecodeSTqHandle(SDecoder* pDecoder, STqHandle* pHandle);
+void    tqDestroyTqHandle(void* data);

 // tqRead
 int32_t tqScanTaosx(STQ* pTq, const STqHandle* pHandle, STaosxRsp* pRsp, SMqMetaRsp* pMetaRsp, STqOffsetVal* offset);
@ -161,6 +162,8 @@ int32_t tqMetaRestoreHandle(STQ* pTq);
 int32_t tqMetaSaveCheckInfo(STQ* pTq, const char* key, const void* value, int32_t vLen);
 int32_t tqMetaDeleteCheckInfo(STQ* pTq, const char* key);
 int32_t tqMetaRestoreCheckInfo(STQ* pTq);
+int32_t tqMetaGetHandle(STQ* pTq, const char* key);
+int32_t tqCreateHandle(STQ* pTq, SMqRebVgReq* req, STqHandle* handle);

 STqOffsetStore* tqOffsetOpen(STQ* pTq);
 void            tqOffsetClose(STqOffsetStore*);
--- a/source/dnode/vnode/src/inc/tsdb.h
+++ b/source/dnode/vnode/src/inc/tsdb.h
@ -357,19 +357,25 @@ typedef struct {
  STSchema                            *pTSchema;
 } SRocksCache;

+typedef struct {
+  STsdb *pTsdb;
+  int    flush_count;
+} SCacheFlushState;
+
 struct STsdb {
-  char          *path;
-  SVnode        *pVnode;
-  STsdbKeepCfg   keepCfg;
-  TdThreadRwlock rwLock;
-  SMemTable     *mem;
-  SMemTable     *imem;
-  STsdbFS        fs;
-  SLRUCache     *lruCache;
-  TdThreadMutex  lruMutex;
-  SLRUCache     *biCache;
-  TdThreadMutex  biMutex;
-  SRocksCache    rCache;
+  char            *path;
+  SVnode          *pVnode;
+  STsdbKeepCfg     keepCfg;
+  TdThreadRwlock   rwLock;
+  SMemTable       *mem;
+  SMemTable       *imem;
+  STsdbFS          fs;
+  SLRUCache       *lruCache;
+  SCacheFlushState flushState;
+  TdThreadMutex    lruMutex;
+  SLRUCache       *biCache;
+  TdThreadMutex    biMutex;
+  SRocksCache      rCache;
 };

 struct TSDBKEY {
--- a/source/dnode/vnode/src/inc/vnodeInt.h
+++ b/source/dnode/vnode/src/inc/vnodeInt.h
@ -226,6 +226,7 @@ int32_t tqProcessDeleteSubReq(STQ* pTq, int64_t version, char* msg, int32_t msgL
 int32_t tqProcessOffsetCommitReq(STQ* pTq, int64_t version, char* msg, int32_t msgLen);
 int32_t tqProcessSeekReq(STQ* pTq, int64_t sversion, char* msg, int32_t msgLen);
 int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg);
+int32_t tqProcessPollPush(STQ* pTq, SRpcMsg* pMsg);
 int32_t tqProcessVgWalInfoReq(STQ* pTq, SRpcMsg* pMsg);

 // tq-stream
--- a/source/dnode/vnode/src/meta/metaCache.c
+++ b/source/dnode/vnode/src/meta/metaCache.c
@ -151,7 +151,6 @@ int32_t metaCacheOpen(SMeta* pMeta) {
  taosHashSetFreeFp(pCache->sTagFilterResCache.pTableEntry, freeCacheEntryFp);
  taosThreadMutexInit(&pCache->sTagFilterResCache.lock, NULL);

-
  pCache->STbGroupResCache.pResCache = taosLRUCacheInit(5 * 1024 * 1024, -1, 0.5);
  if (pCache->STbGroupResCache.pResCache == NULL) {
    code = TSDB_CODE_OUT_OF_MEMORY;
@ -169,7 +168,6 @@ int32_t metaCacheOpen(SMeta* pMeta) {
  taosHashSetFreeFp(pCache->STbGroupResCache.pTableEntry, freeCacheEntryFp);
  taosThreadMutexInit(&pCache->STbGroupResCache.lock, NULL);

-
  pMeta->pCache = pCache;
  return code;

@ -486,14 +484,14 @@ static int checkAllEntriesInCache(const STagFilterResEntry* pEntry, SArray* pInv
 }

 static FORCE_INLINE void setMD5DigestInKey(uint64_t* pBuf, const char* key, int32_t keyLen) {
-//  ASSERT(keyLen == sizeof(int64_t) * 2);
+  //  ASSERT(keyLen == sizeof(int64_t) * 2);
  memcpy(&pBuf[2], key, keyLen);
 }

 // the format of key:
 // hash table address(8bytes) + suid(8bytes) + MD5 digest(16bytes)
 static void initCacheKey(uint64_t* buf, const SHashObj* pHashMap, uint64_t suid, const char* key, int32_t keyLen) {
-  buf[0] = (uint64_t) pHashMap;
+  buf[0] = (uint64_t)pHashMap;
  buf[1] = suid;
  setMD5DigestInKey(buf, key, keyLen);
  ASSERT(keyLen == sizeof(uint64_t) * 2);
@ -501,7 +499,7 @@ static void initCacheKey(uint64_t* buf, const SHashObj* pHashMap, uint64_t suid,

 int32_t metaGetCachedTableUidList(void* pVnode, tb_uid_t suid, const uint8_t* pKey, int32_t keyLen, SArray* pList1,
                                  bool* acquireRes) {
-  SMeta* pMeta = ((SVnode*)pVnode)->pMeta;
+  SMeta*  pMeta = ((SVnode*)pVnode)->pMeta;
  int32_t vgId = TD_VID(pMeta->pVnode);

  // generate the composed key for LRU cache
@ -541,7 +539,8 @@ int32_t metaGetCachedTableUidList(void* pVnode, tb_uid_t suid, const uint8_t* pK

  uint32_t acc = pMeta->pCache->sTagFilterResCache.accTimes;
  if ((*pEntry)->hitTimes % 5000 == 0 && (*pEntry)->hitTimes > 0) {
-    metaInfo("vgId:%d cache hit:%d, total acc:%d, rate:%.2f", vgId, (*pEntry)->hitTimes, acc, ((double)(*pEntry)->hitTimes) / acc);
+    metaInfo("vgId:%d cache hit:%d, total acc:%d, rate:%.2f", vgId, (*pEntry)->hitTimes, acc,
+             ((double)(*pEntry)->hitTimes) / acc);
  }

  taosLRUCacheRelease(pCache, pHandle, false);
@ -551,7 +550,8 @@ int32_t metaGetCachedTableUidList(void* pVnode, tb_uid_t suid, const uint8_t* pK
  return TSDB_CODE_SUCCESS;
 }

-static void freeUidCachePayload(const void* key, size_t keyLen, void* value) {
+static void freeUidCachePayload(const void* key, size_t keyLen, void* value, void* ud) {
+  (void)ud;
  if (value == NULL) {
    return;
  }
@ -607,7 +607,7 @@ static int32_t addNewEntry(SHashObj* pTableEntry, const void* pKey, int32_t keyL
 int32_t metaUidFilterCachePut(void* pVnode, uint64_t suid, const void* pKey, int32_t keyLen, void* pPayload,
                              int32_t payloadLen, double selectivityRatio) {
  int32_t code = 0;
-  SMeta* pMeta = ((SVnode*)pVnode)->pMeta;
+  SMeta*  pMeta = ((SVnode*)pVnode)->pMeta;
  int32_t vgId = TD_VID(pMeta->pVnode);

  if (selectivityRatio > tsSelectivityRatio) {
@ -640,7 +640,7 @@ int32_t metaUidFilterCachePut(void* pVnode, uint64_t suid, const void* pKey, int
    if (code != TSDB_CODE_SUCCESS) {
      goto _end;
    }
-  } else { // check if it exists or not
+  } else {  // check if it exists or not
    size_t size = listNEles(&(*pEntry)->list);
    if (size == 0) {
      tdListAppend(&(*pEntry)->list, pKey);
@ -659,7 +659,7 @@ int32_t metaUidFilterCachePut(void* pVnode, uint64_t suid, const void* pKey, int

  // add to cache.
  taosLRUCacheInsert(pCache, key, TAG_FILTER_RES_KEY_LEN, pPayload, payloadLen, freeUidCachePayload, NULL,
-                     TAOS_LRU_PRIORITY_LOW);
+                     TAOS_LRU_PRIORITY_LOW, NULL);
 _end:
  taosThreadMutexUnlock(pLock);
  metaDebug("vgId:%d, suid:%" PRIu64 " list cache added into cache, total:%d, tables:%d", vgId, suid,
@ -675,7 +675,7 @@ int32_t metaUidCacheClear(SMeta* pMeta, uint64_t suid) {
  SHashObj* pEntryHashMap = pMeta->pCache->sTagFilterResCache.pTableEntry;

  uint64_t dummy[2] = {0};
-  initCacheKey(p, pEntryHashMap, suid, (char*) &dummy[0], 16);
+  initCacheKey(p, pEntryHashMap, suid, (char*)&dummy[0], 16);

  TdThreadMutex* pLock = &pMeta->pCache->sTagFilterResCache.lock;
  taosThreadMutexLock(pLock);
@ -700,12 +700,12 @@ int32_t metaUidCacheClear(SMeta* pMeta, uint64_t suid) {
  tdListEmpty(&(*pEntry)->list);
  taosThreadMutexUnlock(pLock);

-  metaDebug("vgId:%d suid:%"PRId64" cached related tag filter uid list cleared", vgId, suid);
+  metaDebug("vgId:%d suid:%" PRId64 " cached related tag filter uid list cleared", vgId, suid);
  return TSDB_CODE_SUCCESS;
 }

 int32_t metaGetCachedTbGroup(void* pVnode, tb_uid_t suid, const uint8_t* pKey, int32_t keyLen, SArray** pList) {
-  SMeta* pMeta = ((SVnode*)pVnode)->pMeta;
+  SMeta*  pMeta = ((SVnode*)pVnode)->pMeta;
  int32_t vgId = TD_VID(pMeta->pVnode);

  // generate the composed key for LRU cache
@ -738,7 +738,8 @@ int32_t metaGetCachedTbGroup(void* pVnode, tb_uid_t suid, const uint8_t* pKey, i

  uint32_t acc = pMeta->pCache->STbGroupResCache.accTimes;
  if ((*pEntry)->hitTimes % 5000 == 0 && (*pEntry)->hitTimes > 0) {
-    metaInfo("vgId:%d tb group cache hit:%d, total acc:%d, rate:%.2f", vgId, (*pEntry)->hitTimes, acc, ((double)(*pEntry)->hitTimes) / acc);
+    metaInfo("vgId:%d tb group cache hit:%d, total acc:%d, rate:%.2f", vgId, (*pEntry)->hitTimes, acc,
+             ((double)(*pEntry)->hitTimes) / acc);
  }

  taosLRUCacheRelease(pCache, pHandle, false);
@ -748,8 +749,8 @@ int32_t metaGetCachedTbGroup(void* pVnode, tb_uid_t suid, const uint8_t* pKey, i
  return TSDB_CODE_SUCCESS;
 }

-
-static void freeTbGroupCachePayload(const void* key, size_t keyLen, void* value) {
+static void freeTbGroupCachePayload(const void* key, size_t keyLen, void* value, void* ud) {
+  (void)ud;
  if (value == NULL) {
    return;
  }
@ -778,8 +779,8 @@ static void freeTbGroupCachePayload(const void* key, size_t keyLen, void* value)
        taosMemoryFree(tmp);

        double el = (taosGetTimestampUs() - st) / 1000.0;
-        metaDebug("clear one item in tb group cache, remain cached item:%d, elapsed time:%.2fms", listNEles(&((*pEntry)->list)),
-                 el);
+        metaDebug("clear one item in tb group cache, remain cached item:%d, elapsed time:%.2fms",
+                  listNEles(&((*pEntry)->list)), el);
        break;
      }
    }
@ -788,11 +789,10 @@ static void freeTbGroupCachePayload(const void* key, size_t keyLen, void* value)
  taosArrayDestroy((SArray*)value);
 }

-
 int32_t metaPutTbGroupToCache(void* pVnode, uint64_t suid, const void* pKey, int32_t keyLen, void* pPayload,
                              int32_t payloadLen) {
  int32_t code = 0;
-  SMeta* pMeta = ((SVnode*)pVnode)->pMeta;
+  SMeta*  pMeta = ((SVnode*)pVnode)->pMeta;
  int32_t vgId = TD_VID(pMeta->pVnode);

  if (payloadLen > tsTagFilterResCacheSize) {
@ -817,7 +817,7 @@ int32_t metaPutTbGroupToCache(void* pVnode, uint64_t suid, const void* pKey, int
    if (code != TSDB_CODE_SUCCESS) {
      goto _end;
    }
-  } else { // check if it exists or not
+  } else {  // check if it exists or not
    size_t size = listNEles(&(*pEntry)->list);
    if (size == 0) {
      tdListAppend(&(*pEntry)->list, pKey);
@ -836,7 +836,7 @@ int32_t metaPutTbGroupToCache(void* pVnode, uint64_t suid, const void* pKey, int

  // add to cache.
  taosLRUCacheInsert(pCache, key, TAG_FILTER_RES_KEY_LEN, pPayload, payloadLen, freeTbGroupCachePayload, NULL,
-                     TAOS_LRU_PRIORITY_LOW);
+                     TAOS_LRU_PRIORITY_LOW, NULL);
 _end:
  taosThreadMutexUnlock(pLock);
  metaDebug("vgId:%d, suid:%" PRIu64 " tb group added into cache, total:%d, tables:%d", vgId, suid,
@ -852,7 +852,7 @@ int32_t metaTbGroupCacheClear(SMeta* pMeta, uint64_t suid) {
  SHashObj* pEntryHashMap = pMeta->pCache->STbGroupResCache.pTableEntry;

  uint64_t dummy[2] = {0};
-  initCacheKey(p, pEntryHashMap, suid, (char*) &dummy[0], 16);
+  initCacheKey(p, pEntryHashMap, suid, (char*)&dummy[0], 16);

  TdThreadMutex* pLock = &pMeta->pCache->STbGroupResCache.lock;
  taosThreadMutexLock(pLock);
@ -877,8 +877,6 @@ int32_t metaTbGroupCacheClear(SMeta* pMeta, uint64_t suid) {
  tdListEmpty(&(*pEntry)->list);
  taosThreadMutexUnlock(pLock);

-  metaDebug("vgId:%d suid:%"PRId64" cached related tb group cleared", vgId, suid);
+  metaDebug("vgId:%d suid:%" PRId64 " cached related tb group cleared", vgId, suid);
  return TSDB_CODE_SUCCESS;
 }
-
-
--- a/source/dnode/vnode/src/tq/tq.c
+++ b/source/dnode/vnode/src/tq/tq.c
@ -62,7 +62,7 @@ void tqCleanUp() {
  }
 }

-static void destroyTqHandle(void* data) {
+void tqDestroyTqHandle(void* data) {
  STqHandle* pData = (STqHandle*)data;
  qDestroyTask(pData->execHandle.task);

@ -102,7 +102,7 @@ STQ* tqOpen(const char* path, SVnode* pVnode) {
  pTq->walLogLastVer = pVnode->pWal->vers.lastVer;

  pTq->pHandle = taosHashInit(64, MurmurHash3_32, true, HASH_ENTRY_LOCK);
-  taosHashSetFreeFp(pTq->pHandle, destroyTqHandle);
+  taosHashSetFreeFp(pTq->pHandle, tqDestroyTqHandle);

  taosInitRWLatch(&pTq->lock);
  pTq->pPushMgr = taosHashInit(64, MurmurHash3_32, false, HASH_NO_LOCK);
@ -264,7 +264,7 @@ int32_t tqSendDataRsp(STqHandle* pHandle, const SRpcMsg* pMsg, const SMqPollReq*
  tFormatOffset(buf1, 80, &pRsp->reqOffset);
  tFormatOffset(buf2, 80, &pRsp->rspOffset);

-  tqDebug("vgId:%d consumer:0x%" PRIx64 " (epoch %d) send rsp, block num:%d, req:%s, rsp:%s, reqId:0x%" PRIx64, vgId,
+  tqDebug("tmq poll vgId:%d consumer:0x%" PRIx64 " (epoch %d) send rsp, block num:%d, req:%s, rsp:%s, reqId:0x%" PRIx64, vgId,
          pReq->consumerId, pReq->epoch, pRsp->blockNum, buf1, buf2, pReq->reqId);

  return 0;
@ -421,6 +421,35 @@ int32_t tqCheckColModifiable(STQ* pTq, int64_t tbUid, int32_t colId) {
  return 0;
 }

+int32_t tqProcessPollPush(STQ* pTq, SRpcMsg* pMsg) {
+  int32_t vgId = TD_VID(pTq->pVnode);
+  taosWLockLatch(&pTq->lock);
+  if (taosHashGetSize(pTq->pPushMgr) > 0) {
+    void* pIter = taosHashIterate(pTq->pPushMgr, NULL);
+
+    while (pIter) {
+      STqHandle* pHandle = *(STqHandle**)pIter;
+      tqDebug("vgId:%d start set submit for pHandle:%p, consumer:0x%" PRIx64, vgId, pHandle, pHandle->consumerId);
+
+      if (ASSERT(pHandle->msg != NULL)) {
+        tqError("pHandle->msg should not be null");
+        break;
+      }else{
+        SRpcMsg msg = {.msgType = TDMT_VND_TMQ_CONSUME, .pCont = pHandle->msg->pCont, .contLen = pHandle->msg->contLen, .info = pHandle->msg->info};
+        tmsgPutToQueue(&pTq->pVnode->msgCb, QUERY_QUEUE, &msg);
+        taosMemoryFree(pHandle->msg);
+        pHandle->msg = NULL;
+      }
+
+      pIter = taosHashIterate(pTq->pPushMgr, pIter);
+    }
+
+    taosHashClear(pTq->pPushMgr);
+  }
+  taosWUnLockLatch(&pTq->lock);
+  return 0;
+}
+
 int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg) {
  SMqPollReq req = {0};
  int        code = 0;
@ -661,103 +690,33 @@ int32_t tqProcessSubscribeReq(STQ* pTq, int64_t sversion, char* msg, int32_t msg
    return -1;
  }

-  SVnode* pVnode = pTq->pVnode;
-  int32_t vgId = TD_VID(pVnode);
-
-  tqDebug("vgId:%d, tq process sub req:%s, Id:0x%" PRIx64 " -> Id:0x%" PRIx64, pVnode->config.vgId, req.subKey,
+  tqDebug("vgId:%d, tq process sub req:%s, Id:0x%" PRIx64 " -> Id:0x%" PRIx64, pTq->pVnode->config.vgId, req.subKey,
          req.oldConsumerId, req.newConsumerId);

-  STqHandle* pHandle = taosHashGet(pTq->pHandle, req.subKey, strlen(req.subKey));
+  STqHandle* pHandle = NULL;
+  while(1){
+    pHandle = taosHashGet(pTq->pHandle, req.subKey, strlen(req.subKey));
+    if (pHandle || tqMetaGetHandle(pTq, req.subKey) < 0){
+      break;
+    }
+  }
+
  if (pHandle == NULL) {
    if (req.oldConsumerId != -1) {
      tqError("vgId:%d, build new consumer handle %s for consumer:0x%" PRIx64 ", but old consumerId:0x%" PRIx64,
              req.vgId, req.subKey, req.newConsumerId, req.oldConsumerId);
    }
-
    if (req.newConsumerId == -1) {
      tqError("vgId:%d, tq invalid re-balance request, new consumerId %" PRId64 "", req.vgId, req.newConsumerId);
      goto end;
    }
-
-    STqHandle tqHandle = {0};
-    pHandle = &tqHandle;
-
-    memcpy(pHandle->subKey, req.subKey, TSDB_SUBSCRIBE_KEY_LEN);
-    pHandle->consumerId = req.newConsumerId;
-    pHandle->epoch = -1;
-
-    pHandle->execHandle.subType = req.subType;
-    pHandle->fetchMeta = req.withMeta;
-
-    // TODO version should be assigned and refed during preprocess
-    SWalRef* pRef = walRefCommittedVer(pVnode->pWal);
-    if (pRef == NULL) {
-      ret = -1;
+    STqHandle handle = {0};
+    ret = tqCreateHandle(pTq, &req, &handle);
+    if(ret < 0){
+      tqDestroyTqHandle(&handle);
      goto end;
    }
-
-    int64_t ver = pRef->refVer;
-    pHandle->pRef = pRef;
-
-    SReadHandle handle = {.vnode = pVnode, .initTableReader = true, .initTqReader = true, .version = ver};
-    initStorageAPI(&handle.api);
-
-    pHandle->snapshotVer = ver;
-
-    if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
-      pHandle->execHandle.execCol.qmsg = taosStrdup(req.qmsg);
-
-      pHandle->execHandle.task = qCreateQueueExecTaskInfo(pHandle->execHandle.execCol.qmsg, &handle, vgId,
-                                                          &pHandle->execHandle.numOfCols, req.newConsumerId);
-      void* scanner = NULL;
-      qExtractStreamScanner(pHandle->execHandle.task, &scanner);
-      pHandle->execHandle.pTqReader = qExtractReaderFromStreamScanner(scanner);
-    } else if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__DB) {
-      pHandle->pWalReader = walOpenReader(pVnode->pWal, NULL);
-      pHandle->execHandle.pTqReader = tqReaderOpen(pVnode);
-
-      pHandle->execHandle.execDb.pFilterOutTbUid =
-          taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK);
-      buildSnapContext(handle.vnode, handle.version, 0, pHandle->execHandle.subType, pHandle->fetchMeta,
-                       (SSnapContext**)(&handle.sContext));
-
-      pHandle->execHandle.task = qCreateQueueExecTaskInfo(NULL, &handle, vgId, NULL, req.newConsumerId);
-    } else if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__TABLE) {
-      pHandle->pWalReader = walOpenReader(pVnode->pWal, NULL);
-      pHandle->execHandle.execTb.suid = req.suid;
-      pHandle->execHandle.execTb.qmsg = taosStrdup(req.qmsg);
-
-      if (strcmp(pHandle->execHandle.execTb.qmsg, "") != 0) {
-        if (nodesStringToNode(pHandle->execHandle.execTb.qmsg, &pHandle->execHandle.execTb.node) != 0) {
-          tqError("nodesStringToNode error in sub stable, since %s, vgId:%d, subkey:%s consumer:0x%" PRIx64, terrstr(),
-                  pVnode->config.vgId, req.subKey, pHandle->consumerId);
-          return -1;
-        }
-      }
-
-      buildSnapContext(handle.vnode, handle.version, req.suid, pHandle->execHandle.subType, pHandle->fetchMeta,
-                       (SSnapContext**)(&handle.sContext));
-      pHandle->execHandle.task = qCreateQueueExecTaskInfo(NULL, &handle, vgId, NULL, req.newConsumerId);
-
-      SArray* tbUidList = NULL;
-      ret = qGetTableList(req.suid, pVnode, pHandle->execHandle.execTb.node, &tbUidList, pHandle->execHandle.task);
-      if (ret != TDB_CODE_SUCCESS) {
-        tqError("qGetTableList error:%d vgId:%d, subkey:%s consumer:0x%" PRIx64, ret, pVnode->config.vgId, req.subKey,
-                pHandle->consumerId);
-        taosArrayDestroy(tbUidList);
-        goto end;
-      }
-      tqDebug("tq try to get ctb for stb subscribe, vgId:%d, subkey:%s consumer:0x%" PRIx64 " suid:%" PRId64,
-              pVnode->config.vgId, req.subKey, pHandle->consumerId, req.suid);
-      pHandle->execHandle.pTqReader = tqReaderOpen(pVnode);
-      tqReaderSetTbUidList(pHandle->execHandle.pTqReader, tbUidList, NULL);
-      taosArrayDestroy(tbUidList);
-    }
-
-    taosHashPut(pTq->pHandle, req.subKey, strlen(req.subKey), pHandle, sizeof(STqHandle));
-    tqDebug("try to persist handle %s consumer:0x%" PRIx64, req.subKey, pHandle->consumerId);
-    ret = tqMetaSaveHandle(pTq, req.subKey, pHandle);
-    goto end;
+    ret = tqMetaSaveHandle(pTq, req.subKey, &handle);
  } else {
    taosWLockLatch(&pTq->lock);

--- a/source/dnode/vnode/src/tq/tqMeta.c
+++ b/source/dnode/vnode/src/tq/tqMeta.c
@ -88,9 +88,9 @@ int32_t tqMetaOpen(STQ* pTq) {
    return -1;
  }

-  if (tqMetaRestoreHandle(pTq) < 0) {
-    return -1;
-  }
+//  if (tqMetaRestoreHandle(pTq) < 0) {
+//    return -1;
+//  }

  if (tqMetaRestoreCheckInfo(pTq) < 0) {
    return -1;
@ -274,6 +274,120 @@ int32_t tqMetaDeleteHandle(STQ* pTq, const char* key) {
  return 0;
 }

+static int buildHandle(STQ* pTq, STqHandle* handle){
+  SVnode* pVnode = pTq->pVnode;
+  int32_t vgId = TD_VID(pVnode);
+
+  handle->pRef = walOpenRef(pVnode->pWal);
+  if (handle->pRef == NULL) {
+    return -1;
+  }
+  walSetRefVer(handle->pRef, handle->snapshotVer);
+
+  SReadHandle reader = {
+      .vnode = pVnode,
+      .initTableReader = true,
+      .initTqReader = true,
+      .version = handle->snapshotVer,
+  };
+
+  initStorageAPI(&reader.api);
+
+  if (handle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
+    handle->execHandle.task =
+        qCreateQueueExecTaskInfo(handle->execHandle.execCol.qmsg, &reader, vgId, &handle->execHandle.numOfCols, handle->consumerId);
+    if (handle->execHandle.task == NULL) {
+      tqError("cannot create exec task for %s", handle->subKey);
+      return -1;
+    }
+    void* scanner = NULL;
+    qExtractStreamScanner(handle->execHandle.task, &scanner);
+    if (scanner == NULL) {
+      tqError("cannot extract stream scanner for %s", handle->subKey);
+      return -1;
+    }
+    handle->execHandle.pTqReader = qExtractReaderFromStreamScanner(scanner);
+    if (handle->execHandle.pTqReader == NULL) {
+      tqError("cannot extract exec reader for %s", handle->subKey);
+      return -1;
+    }
+  } else if (handle->execHandle.subType == TOPIC_SUB_TYPE__DB) {
+    handle->pWalReader = walOpenReader(pVnode->pWal, NULL);
+    handle->execHandle.pTqReader = tqReaderOpen(pVnode);
+
+    buildSnapContext(reader.vnode, reader.version, 0, handle->execHandle.subType, handle->fetchMeta,
+                     (SSnapContext**)(&reader.sContext));
+    handle->execHandle.task = qCreateQueueExecTaskInfo(NULL, &reader, vgId, NULL, handle->consumerId);
+  } else if (handle->execHandle.subType == TOPIC_SUB_TYPE__TABLE) {
+    handle->pWalReader = walOpenReader(pVnode->pWal, NULL);
+
+    if(handle->execHandle.execTb.qmsg != NULL && strcmp(handle->execHandle.execTb.qmsg, "") != 0) {
+      if (nodesStringToNode(handle->execHandle.execTb.qmsg, &handle->execHandle.execTb.node) != 0) {
+        tqError("nodesStringToNode error in sub stable, since %s", terrstr());
+        return -1;
+      }
+    }
+    buildSnapContext(reader.vnode, reader.version, handle->execHandle.execTb.suid, handle->execHandle.subType,
+                     handle->fetchMeta, (SSnapContext**)(&reader.sContext));
+    handle->execHandle.task = qCreateQueueExecTaskInfo(NULL, &reader, vgId, NULL, handle->consumerId);
+
+    SArray* tbUidList = NULL;
+    int ret = qGetTableList(handle->execHandle.execTb.suid, pVnode, handle->execHandle.execTb.node, &tbUidList, handle->execHandle.task);
+    if(ret != TDB_CODE_SUCCESS) {
+      tqError("qGetTableList error:%d handle %s consumer:0x%" PRIx64, ret, handle->subKey, handle->consumerId);
+      taosArrayDestroy(tbUidList);
+      return -1;
+    }
+    tqDebug("vgId:%d, tq try to get ctb for stb subscribe, suid:%" PRId64, pVnode->config.vgId, handle->execHandle.execTb.suid);
+    handle->execHandle.pTqReader = tqReaderOpen(pVnode);
+    tqReaderSetTbUidList(handle->execHandle.pTqReader, tbUidList, NULL);
+    taosArrayDestroy(tbUidList);
+  }
+  return 0;
+}
+
+static int restoreHandle(STQ* pTq, void* pVal, int vLen, STqHandle* handle){
+  int32_t  vgId = TD_VID(pTq->pVnode);
+  SDecoder decoder;
+  tDecoderInit(&decoder, (uint8_t*)pVal, vLen);
+  tDecodeSTqHandle(&decoder, handle);
+  tDecoderClear(&decoder);
+
+  if(buildHandle(pTq, handle) < 0){
+    return -1;
+  }
+  tqDebug("tq restore %s consumer %" PRId64 " vgId:%d", handle->subKey, handle->consumerId, vgId);
+  return taosHashPut(pTq->pHandle, handle->subKey, strlen(handle->subKey), handle, sizeof(STqHandle));
+}
+
+int32_t tqCreateHandle(STQ* pTq, SMqRebVgReq* req, STqHandle* handle){
+  int32_t  vgId = TD_VID(pTq->pVnode);
+
+  memcpy(handle->subKey, req->subKey, TSDB_SUBSCRIBE_KEY_LEN);
+  handle->consumerId = req->newConsumerId;
+  handle->epoch = -1;
+
+  handle->execHandle.subType = req->subType;
+  handle->fetchMeta = req->withMeta;
+  if(req->subType == TOPIC_SUB_TYPE__COLUMN){
+    handle->execHandle.execCol.qmsg = taosStrdup(req->qmsg);
+  }else if(req->subType == TOPIC_SUB_TYPE__DB){
+    handle->execHandle.execDb.pFilterOutTbUid =
+        taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK);
+  }else if(req->subType == TOPIC_SUB_TYPE__TABLE){
+    handle->execHandle.execTb.suid = req->suid;
+    handle->execHandle.execTb.qmsg = taosStrdup(req->qmsg);
+  }
+
+  handle->snapshotVer = walGetCommittedVer(pTq->pVnode->pWal);
+
+  if(buildHandle(pTq, handle) < 0){
+    return -1;
+  }
+  tqDebug("tq restore %s consumer %" PRId64 " vgId:%d", handle->subKey, handle->consumerId, vgId);
+  return taosHashPut(pTq->pHandle, handle->subKey, strlen(handle->subKey), handle, sizeof(STqHandle));
+}
+
 int32_t tqMetaRestoreHandle(STQ* pTq) {
  int  code = 0;
  TBC* pCur = NULL;
@ -281,97 +395,40 @@ int32_t tqMetaRestoreHandle(STQ* pTq) {
    return -1;
  }

-  int32_t  vgId = TD_VID(pTq->pVnode);
  void*    pKey = NULL;
  int      kLen = 0;
  void*    pVal = NULL;
  int      vLen = 0;
-  SDecoder decoder;

  tdbTbcMoveToFirst(pCur);

  while (tdbTbcNext(pCur, &pKey, &kLen, &pVal, &vLen) == 0) {
    STqHandle handle = {0};
-    tDecoderInit(&decoder, (uint8_t*)pVal, vLen);
-    tDecodeSTqHandle(&decoder, &handle);
-    tDecoderClear(&decoder);
-
-    handle.pRef = walOpenRef(pTq->pVnode->pWal);
-    if (handle.pRef == NULL) {
-      code = -1;
-      goto end;
+    code = restoreHandle(pTq, pVal, vLen, &handle);
+    if (code < 0) {
+      tqDestroyTqHandle(&handle);
+      break;
    }
-    walSetRefVer(handle.pRef, handle.snapshotVer);
-
-    SReadHandle reader = {
-        .vnode = pTq->pVnode,
-        .initTableReader = true,
-        .initTqReader = true,
-        .version = handle.snapshotVer
-    };
-
-    initStorageAPI(&reader.api);
-
-    if (handle.execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
-      handle.execHandle.task =
-          qCreateQueueExecTaskInfo(handle.execHandle.execCol.qmsg, &reader, vgId, &handle.execHandle.numOfCols, 0);
-      if (handle.execHandle.task == NULL) {
-        tqError("cannot create exec task for %s", handle.subKey);
-        code = -1;
-        goto end;
-      }
-      void* scanner = NULL;
-      qExtractStreamScanner(handle.execHandle.task, &scanner);
-      if (scanner == NULL) {
-        tqError("cannot extract stream scanner for %s", handle.subKey);
-        code = -1;
-        goto end;
-      }
-      handle.execHandle.pTqReader = qExtractReaderFromStreamScanner(scanner);
-      if (handle.execHandle.pTqReader == NULL) {
-        tqError("cannot extract exec reader for %s", handle.subKey);
-        code = -1;
-        goto end;
-      }
-    } else if (handle.execHandle.subType == TOPIC_SUB_TYPE__DB) {
-      handle.pWalReader = walOpenReader(pTq->pVnode->pWal, NULL);
-      handle.execHandle.pTqReader = tqReaderOpen(pTq->pVnode);
-
-      buildSnapContext(reader.vnode, reader.version, 0, handle.execHandle.subType, handle.fetchMeta,
-                       (SSnapContext**)(&reader.sContext));
-      handle.execHandle.task = qCreateQueueExecTaskInfo(NULL, &reader, vgId, NULL, 0);
-    } else if (handle.execHandle.subType == TOPIC_SUB_TYPE__TABLE) {
-      handle.pWalReader = walOpenReader(pTq->pVnode->pWal, NULL);
-
-      if(handle.execHandle.execTb.qmsg != NULL && strcmp(handle.execHandle.execTb.qmsg, "") != 0) {
-        if (nodesStringToNode(handle.execHandle.execTb.qmsg, &handle.execHandle.execTb.node) != 0) {
-          tqError("nodesStringToNode error in sub stable, since %s", terrstr());
-          return -1;
-        }
-      }
-      buildSnapContext(reader.vnode, reader.version, handle.execHandle.execTb.suid, handle.execHandle.subType,
-                       handle.fetchMeta, (SSnapContext**)(&reader.sContext));
-      handle.execHandle.task = qCreateQueueExecTaskInfo(NULL, &reader, vgId, NULL, 0);
-
-      SArray* tbUidList = NULL;
-      int ret = qGetTableList(handle.execHandle.execTb.suid, pTq->pVnode, handle.execHandle.execTb.node, &tbUidList, handle.execHandle.task);
-      if(ret != TDB_CODE_SUCCESS) {
-        tqError("qGetTableList error:%d handle %s consumer:0x%" PRIx64, ret, handle.subKey, handle.consumerId);
-        taosArrayDestroy(tbUidList);
-        goto end;
-      }
-      tqDebug("vgId:%d, tq try to get ctb for stb subscribe, suid:%" PRId64, pTq->pVnode->config.vgId, handle.execHandle.execTb.suid);
-      handle.execHandle.pTqReader = tqReaderOpen(pTq->pVnode);
-      tqReaderSetTbUidList(handle.execHandle.pTqReader, tbUidList, NULL);
-      taosArrayDestroy(tbUidList);
-    }
-    tqDebug("tq restore %s consumer %" PRId64 " vgId:%d", handle.subKey, handle.consumerId, vgId);
-    taosHashPut(pTq->pHandle, pKey, kLen, &handle, sizeof(STqHandle));
  }

-end:
  tdbFree(pKey);
  tdbFree(pVal);
  tdbTbcClose(pCur);
  return code;
 }
+
+int32_t tqMetaGetHandle(STQ* pTq, const char* key) {
+  void*    pVal = NULL;
+  int      vLen = 0;
+
+  if (tdbTbGet(pTq->pExecStore, key, (int)strlen(key), &pVal, &vLen) < 0) {
+    return -1;
+  }
+  STqHandle handle = {0};
+  int code = restoreHandle(pTq, pVal, vLen, &handle);
+  if (code < 0){
+    tqDestroyTqHandle(&handle);
+  }
+  tdbFree(pVal);
+  return code;
+}
--- a/source/dnode/vnode/src/tq/tqPush.c
+++ b/source/dnode/vnode/src/tq/tqPush.c
@ -17,35 +17,16 @@
 #include "vnd.h"

 int32_t tqProcessSubmitReqForSubscribe(STQ* pTq) {
-  int32_t vgId = TD_VID(pTq->pVnode);
-
-  taosWLockLatch(&pTq->lock);
-
-  if (taosHashGetSize(pTq->pPushMgr) > 0) {
-    void* pIter = taosHashIterate(pTq->pPushMgr, NULL);
-
-    while (pIter) {
-      STqHandle* pHandle = *(STqHandle**)pIter;
-      tqDebug("vgId:%d start set submit for pHandle:%p, consumer:0x%" PRIx64, vgId, pHandle, pHandle->consumerId);
-
-      if (ASSERT(pHandle->msg != NULL)) {
-        tqError("pHandle->msg should not be null");
-        break;
-      }else{
-        SRpcMsg msg = {.msgType = TDMT_VND_TMQ_CONSUME, .pCont = pHandle->msg->pCont, .contLen = pHandle->msg->contLen, .info = pHandle->msg->info};
-        tmsgPutToQueue(&pTq->pVnode->msgCb, QUERY_QUEUE, &msg);
-        taosMemoryFree(pHandle->msg);
-        pHandle->msg = NULL;
-      }
-
-      pIter = taosHashIterate(pTq->pPushMgr, pIter);
-    }
-
-    taosHashClear(pTq->pPushMgr);
+  if (taosHashGetSize(pTq->pPushMgr) <= 0) {
+    return 0;
  }
-
-  // unlock
-  taosWUnLockLatch(&pTq->lock);
+  SRpcMsg msg = {.msgType = TDMT_VND_TMQ_CONSUME_PUSH};
+  msg.pCont = rpcMallocCont(sizeof(SMsgHead));
+  msg.contLen = sizeof(SMsgHead);
+  SMsgHead *pHead = msg.pCont;
+  pHead->vgId = TD_VID(pTq->pVnode);
+  pHead->contLen = msg.contLen;
+  tmsgPutToQueue(&pTq->pVnode->msgCb, QUERY_QUEUE, &msg);
  return 0;
 }

--- a/source/dnode/vnode/src/tq/tqUtil.c
+++ b/source/dnode/vnode/src/tq/tqUtil.c
@ -176,24 +176,20 @@ static int32_t extractDataAndRspForNormalSubscribe(STQ* pTq, STqHandle* pHandle,
  if (terrno == TSDB_CODE_WAL_LOG_NOT_EXIST && dataRsp.blockNum == 0) {
    // lock
    taosWLockLatch(&pTq->lock);
-    code = tqRegisterPushHandle(pTq, pHandle, pMsg);
-    taosWUnLockLatch(&pTq->lock);
-    tDeleteMqDataRsp(&dataRsp);
-    return code;
+    int64_t ver = walGetCommittedVer(pTq->pVnode->pWal);
+    if (pOffset->version >= ver || dataRsp.rspOffset.version >= ver){   //check if there are data again to avoid lost data
+      code = tqRegisterPushHandle(pTq, pHandle, pMsg);
+      taosWUnLockLatch(&pTq->lock);
+      goto end;
+    }else{
+      taosWUnLockLatch(&pTq->lock);
+    }
  }

-  // NOTE: this pHandle->consumerId may have been changed already.
  code = tqSendDataRsp(pHandle, pMsg, pRequest, (SMqDataRsp*)&dataRsp, TMQ_MSG_TYPE__POLL_RSP, vgId);

-end : {
-  char buf[80] = {0};
-  tFormatOffset(buf, 80, &dataRsp.rspOffset);
-  tqDebug("tmq poll: consumer:0x%" PRIx64 ", subkey %s, vgId:%d, rsp block:%d, rsp offset type:%s, reqId:0x%" PRIx64
-          " code:%d",
-          consumerId, pHandle->subKey, vgId, dataRsp.blockNum, buf, pRequest->reqId, code);
+end :
  tDeleteMqDataRsp(&dataRsp);
-}
-
  return code;
 }

@ -428,4 +424,4 @@ int32_t tqDoSendDataRsp(const SRpcHandleInfo* pRpcHandleInfo, const SMqDataRsp*

  tmsgSendRsp(&rsp);
  return 0;
-}
+}
--- a/source/dnode/vnode/src/tsdb/tsdbCache.c
+++ b/source/dnode/vnode/src/tsdb/tsdbCache.c
@ -14,6 +14,8 @@
 */
 #include "tsdb.h"

+#define ROCKS_BATCH_SIZE (4096)
+
 static int32_t tsdbOpenBICache(STsdb *pTsdb) {
  int32_t    code = 0;
  SLRUCache *pCache = taosLRUCacheInit(10 * 1024 * 1024, 0, .5);
@ -226,13 +228,14 @@ static void rocksMayWrite(STsdb *pTsdb, bool force, bool read, bool lock) {
    wb = pTsdb->rCache.writebatch;
  }
  int count = rocksdb_writebatch_count(wb);
-  if ((force && count > 0) || count >= 1024) {
+  if ((force && count > 0) || count >= ROCKS_BATCH_SIZE) {
    char *err = NULL;
    rocksdb_write(pTsdb->rCache.db, pTsdb->rCache.writeoptions, wb, &err);
    if (NULL != err) {
      tsdbError("vgId:%d, %s failed at line %d, count: %d since %s", TD_VID(pTsdb->pVnode), __func__, __LINE__, count,
                err);
      rocksdb_free(err);
+      // pTsdb->flushState.flush_count = 0;
    }

    rocksdb_writebatch_clear(wb);
@ -244,23 +247,7 @@ static void rocksMayWrite(STsdb *pTsdb, bool force, bool read, bool lock) {
  }
 }

-int32_t tsdbCacheCommit(STsdb *pTsdb) {
-  int32_t code = 0;
-  char   *err = NULL;
-
-  rocksMayWrite(pTsdb, true, false, true);
-  rocksMayWrite(pTsdb, true, true, true);
-  rocksdb_flush(pTsdb->rCache.db, pTsdb->rCache.flushoptions, &err);
-  if (NULL != err) {
-    tsdbError("vgId:%d, %s failed at line %d since %s", TD_VID(pTsdb->pVnode), __func__, __LINE__, err);
-    rocksdb_free(err);
-    code = -1;
-  }
-
-  return code;
-}
-
-SLastCol *tsdbCacheDeserialize(char const *value) {
+static SLastCol *tsdbCacheDeserialize(char const *value) {
  if (!value) {
    return NULL;
  }
@ -278,7 +265,7 @@ SLastCol *tsdbCacheDeserialize(char const *value) {
  return pLastCol;
 }

-void tsdbCacheSerialize(SLastCol *pLastCol, char **value, size_t *size) {
+static void tsdbCacheSerialize(SLastCol *pLastCol, char **value, size_t *size) {
  SColVal *pColVal = &pLastCol->colVal;
  size_t   length = sizeof(*pLastCol);
  if (IS_VAR_DATA_TYPE(pColVal->type)) {
@ -300,6 +287,68 @@ void tsdbCacheSerialize(SLastCol *pLastCol, char **value, size_t *size) {
  *size = length;
 }

+int tsdbCacheFlushDirty(const void *key, size_t klen, void *value, void *ud) {
+  SLastCol *pLastCol = (SLastCol *)value;
+
+  if (pLastCol->dirty) {
+    SCacheFlushState     *state = (SCacheFlushState *)ud;
+    STsdb                *pTsdb = state->pTsdb;
+    SRocksCache          *rCache = &pTsdb->rCache;
+    rocksdb_writebatch_t *wb = rCache->writebatch;
+    char                 *rocks_value = NULL;
+    size_t                vlen = 0;
+
+    tsdbCacheSerialize(pLastCol, &rocks_value, &vlen);
+    rocksdb_writebatch_put(wb, (char *)key, klen, rocks_value, vlen);
+
+    taosMemoryFree(rocks_value);
+
+    if (++state->flush_count >= ROCKS_BATCH_SIZE) {
+      char *err = NULL;
+      rocksdb_write(rCache->db, rCache->writeoptions, wb, &err);
+      if (NULL != err) {
+        tsdbError("vgId:%d, %s failed at line %d, count: %d since %s", TD_VID(pTsdb->pVnode), __func__, __LINE__,
+                  state->flush_count, err);
+        rocksdb_free(err);
+      }
+
+      rocksdb_writebatch_clear(wb);
+
+      state->flush_count = 0;
+    }
+
+    pLastCol->dirty = 0;
+  }
+
+  return 0;
+}
+
+int32_t tsdbCacheCommit(STsdb *pTsdb) {
+  int32_t code = 0;
+  char   *err = NULL;
+
+  SLRUCache            *pCache = pTsdb->lruCache;
+  rocksdb_writebatch_t *wb = pTsdb->rCache.writebatch;
+
+  taosThreadMutexLock(&pTsdb->lruMutex);
+
+  taosLRUCacheApply(pCache, tsdbCacheFlushDirty, &pTsdb->flushState);
+
+  rocksMayWrite(pTsdb, true, false, false);
+  rocksMayWrite(pTsdb, true, true, false);
+  rocksdb_flush(pTsdb->rCache.db, pTsdb->rCache.flushoptions, &err);
+
+  taosThreadMutexUnlock(&pTsdb->lruMutex);
+
+  if (NULL != err) {
+    tsdbError("vgId:%d, %s failed at line %d since %s", TD_VID(pTsdb->pVnode), __func__, __LINE__, err);
+    rocksdb_free(err);
+    code = -1;
+  }
+
+  return code;
+}
+
 static SLastCol *tsdbCacheLookup(STsdb *pTsdb, tb_uid_t uid, int16_t cid, int8_t ltype) {
  SLastCol *pLastCol = NULL;

@ -329,21 +378,51 @@ static void reallocVarData(SColVal *pColVal) {
  }
 }

-static void tsdbCacheDeleter(const void *key, size_t keyLen, void *value) {
+static void tsdbCacheDeleter(const void *key, size_t klen, void *value, void *ud) {
+  (void)key;
+  (void)klen;
  SLastCol *pLastCol = (SLastCol *)value;

-  // TODO: add dirty flag to SLastCol
  if (pLastCol->dirty) {
-    // TODO: queue into dirty list, free it after save to backstore
-  } else {
-    if (IS_VAR_DATA_TYPE(pLastCol->colVal.type) /* && pLastCol->colVal.value.nData > 0*/) {
-      taosMemoryFree(pLastCol->colVal.value.pData);
-    }
+    SCacheFlushState     *state = (SCacheFlushState *)ud;
+    STsdb                *pTsdb = state->pTsdb;
+    SRocksCache          *rCache = &pTsdb->rCache;
+    rocksdb_writebatch_t *wb = rCache->writebatch;
+    char                 *rocks_value = NULL;
+    size_t                vlen = 0;

-    taosMemoryFree(value);
+    tsdbCacheSerialize(pLastCol, &rocks_value, &vlen);
+    rocksdb_writebatch_put(wb, (char *)key, klen, rocks_value, vlen);
+
+    taosMemoryFree(rocks_value);
+
+    if (++state->flush_count >= ROCKS_BATCH_SIZE) {
+      char *err = NULL;
+      rocksdb_write(rCache->db, rCache->writeoptions, wb, &err);
+      if (NULL != err) {
+        tsdbError("vgId:%d, %s failed at line %d, count: %d since %s", TD_VID(pTsdb->pVnode), __func__, __LINE__,
+                  state->flush_count, err);
+        rocksdb_free(err);
+      }
+
+      rocksdb_writebatch_clear(wb);
+
+      state->flush_count = 0;
+    }
  }
+
+  if (IS_VAR_DATA_TYPE(pLastCol->colVal.type) /* && pLastCol->colVal.value.nData > 0*/) {
+    taosMemoryFree(pLastCol->colVal.value.pData);
+  }
+
+  taosMemoryFree(value);
 }

+typedef struct {
+  int      idx;
+  SLastKey key;
+} SIdxKey;
+
 int32_t tsdbCacheUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, TSDBROW *pRow) {
  int32_t code = 0;

@ -370,113 +449,211 @@ int32_t tsdbCacheUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, TSDBROW *pRow
  tsdbRowClose(&iter);

  // 3, build keys & multi get from rocks
-  int     num_keys = TARRAY_SIZE(aColVal);
-  char  **keys_list = taosMemoryCalloc(num_keys * 2, sizeof(char *));
-  size_t *keys_list_sizes = taosMemoryCalloc(num_keys * 2, sizeof(size_t));
-  char   *key_list = taosMemoryMalloc(num_keys * ROCKS_KEY_LEN * 2);
+  int                   num_keys = TARRAY_SIZE(aColVal);
+  TSKEY                 keyTs = TSDBROW_TS(pRow);
+  rocksdb_writebatch_t *wb = pTsdb->rCache.writebatch;
+  SArray               *remainCols = NULL;
+  SLRUCache            *pCache = pTsdb->lruCache;
+
+  taosThreadMutexLock(&pTsdb->lruMutex);
  for (int i = 0; i < num_keys; ++i) {
    SColVal *pColVal = (SColVal *)taosArrayGet(aColVal, i);
    int16_t  cid = pColVal->cid;

-    memcpy(key_list + i * ROCKS_KEY_LEN, &(SLastKey){.ltype = 1, .uid = uid, .cid = cid}, ROCKS_KEY_LEN);
-    memcpy(key_list + i * ROCKS_KEY_LEN + num_keys * ROCKS_KEY_LEN, &(SLastKey){.ltype = 0, .uid = uid, .cid = cid},
-           ROCKS_KEY_LEN);
-    keys_list[i] = key_list + i * ROCKS_KEY_LEN;
-    keys_list[num_keys + i] = key_list + i * ROCKS_KEY_LEN + num_keys * ROCKS_KEY_LEN;
-    keys_list_sizes[i] = ROCKS_KEY_LEN;
-    keys_list_sizes[num_keys + i] = ROCKS_KEY_LEN;
-  }
-  char  **values_list = taosMemoryCalloc(num_keys * 2, sizeof(char *));
-  size_t *values_list_sizes = taosMemoryCalloc(num_keys * 2, sizeof(size_t));
-  char  **errs = taosMemoryCalloc(num_keys * 2, sizeof(char *));
-  taosThreadMutexLock(&pTsdb->rCache.rMutex);
-  rocksdb_multi_get(pTsdb->rCache.db, pTsdb->rCache.readoptions, num_keys * 2, (const char *const *)keys_list,
-                    keys_list_sizes, values_list, values_list_sizes, errs);
-  for (int i = 0; i < num_keys * 2; ++i) {
-    rocksdb_free(errs[i]);
-  }
-  taosMemoryFree(key_list);
-  taosMemoryFree(keys_list);
-  taosMemoryFree(keys_list_sizes);
-  taosMemoryFree(errs);
+    SLastKey  *key = &(SLastKey){.ltype = 0, .uid = uid, .cid = cid};
+    size_t     klen = ROCKS_KEY_LEN;
+    LRUHandle *h = taosLRUCacheLookup(pCache, key, klen);
+    if (h) {
+      SLastCol *pLastCol = (SLastCol *)taosLRUCacheValue(pCache, h);

-  TSKEY                 keyTs = TSDBROW_TS(pRow);
-  rocksdb_writebatch_t *wb = pTsdb->rCache.writebatch;
-  for (int i = 0; i < num_keys; ++i) {
-    SColVal *pColVal = (SColVal *)taosArrayGet(aColVal, i);
+      if (pLastCol->ts <= keyTs) {
+        uint8_t *pVal = NULL;
+        int      nData = pLastCol->colVal.value.nData;
+        if (IS_VAR_DATA_TYPE(pColVal->type)) {
+          pVal = pLastCol->colVal.value.pData;
+        }
+        pLastCol->ts = keyTs;
+        pLastCol->colVal = *pColVal;
+        if (IS_VAR_DATA_TYPE(pColVal->type)) {
+          if (nData < pColVal->value.nData) {
+            taosMemoryFree(pVal);
+            pLastCol->colVal.value.pData = taosMemoryCalloc(1, pColVal->value.nData);
+          } else {
+            pLastCol->colVal.value.pData = pVal;
+          }
+          if (pColVal->value.nData) {
+            memcpy(pLastCol->colVal.value.pData, pColVal->value.pData, pColVal->value.nData);
+          }
+        }

-    // if (!COL_VAL_IS_NONE(pColVal)) {
-    SLastCol *pLastCol = tsdbCacheDeserialize(values_list[i + num_keys]);
-
-    if (NULL == pLastCol || pLastCol->ts <= keyTs) {
-      char  *value = NULL;
-      size_t vlen = 0;
-      tsdbCacheSerialize(&(SLastCol){.ts = keyTs, .colVal = *pColVal}, &value, &vlen);
-      SLastKey key = (SLastKey){.ltype = 0, .uid = uid, .cid = pColVal->cid};
-      size_t   klen = ROCKS_KEY_LEN;
-      rocksdb_writebatch_put(wb, (char *)&key, klen, value, vlen);
-
-      pLastCol = (SLastCol *)value;
-      SLastCol *pTmpLastCol = taosMemoryCalloc(1, sizeof(SLastCol));
-      *pTmpLastCol = *pLastCol;
-      pLastCol = pTmpLastCol;
-
-      reallocVarData(&pLastCol->colVal);
-      size_t charge = sizeof(*pLastCol);
-      if (IS_VAR_DATA_TYPE(pLastCol->colVal.type)) {
-        charge += pLastCol->colVal.value.nData;
+        if (!pLastCol->dirty) {
+          pLastCol->dirty = 1;
+        }
+        /*
+        char  *value = NULL;
+        size_t vlen = 0;
+        tsdbCacheSerialize(pLastCol, &value, &vlen);
+        // tsdbCacheSerialize(&(SLastCol){.ts = keyTs, .colVal = *pColVal}, &value, &vlen);
+        rocksdb_writebatch_put(wb, (char *)key, klen, value, vlen);
+        taosMemoryFree(value);
+        */
      }

-      LRUStatus status = taosLRUCacheInsert(pTsdb->lruCache, &key, ROCKS_KEY_LEN, pLastCol, charge, tsdbCacheDeleter,
-                                            NULL, TAOS_LRU_PRIORITY_LOW);
-      if (status != TAOS_LRU_STATUS_OK) {
-        code = -1;
+      taosLRUCacheRelease(pCache, h, false);
+    } else {
+      if (!remainCols) {
+        remainCols = taosArrayInit(num_keys * 2, sizeof(SIdxKey));
      }
-
-      taosMemoryFree(value);
+      taosArrayPush(remainCols, &(SIdxKey){i, *key});
    }

    if (COL_VAL_IS_VALUE(pColVal)) {
-      SLastCol *pLastCol = tsdbCacheDeserialize(values_list[i]);
+      key->ltype = 1;
+      LRUHandle *h = taosLRUCacheLookup(pCache, key, klen);
+      if (h) {
+        SLastCol *pLastCol = (SLastCol *)taosLRUCacheValue(pCache, h);

-      if (NULL == pLastCol || pLastCol->ts <= keyTs) {
-        char  *value = NULL;
-        size_t vlen = 0;
-        tsdbCacheSerialize(&(SLastCol){.ts = keyTs, .colVal = *pColVal}, &value, &vlen);
-        SLastKey key = (SLastKey){.ltype = 1, .uid = uid, .cid = pColVal->cid};
+        if (pLastCol->ts <= keyTs) {
+          uint8_t *pVal = NULL;
+          int      nData = pLastCol->colVal.value.nData;
+          if (IS_VAR_DATA_TYPE(pColVal->type)) {
+            pVal = pLastCol->colVal.value.pData;
+          }
+          pLastCol->ts = keyTs;
+          pLastCol->colVal = *pColVal;
+          if (IS_VAR_DATA_TYPE(pColVal->type)) {
+            if (nData < pColVal->value.nData) {
+              taosMemoryFree(pVal);
+              pLastCol->colVal.value.pData = taosMemoryCalloc(1, pColVal->value.nData);
+            } else {
+              pLastCol->colVal.value.pData = pVal;
+            }
+            if (pColVal->value.nData) {
+              memcpy(pLastCol->colVal.value.pData, pColVal->value.pData, pColVal->value.nData);
+            }
+          }

-        rocksdb_writebatch_put(wb, (char *)&key, ROCKS_KEY_LEN, value, vlen);
-
-        pLastCol = (SLastCol *)value;
-        SLastCol *pTmpLastCol = taosMemoryCalloc(1, sizeof(SLastCol));
-        *pTmpLastCol = *pLastCol;
-        pLastCol = pTmpLastCol;
-
-        reallocVarData(&pLastCol->colVal);
-        size_t charge = sizeof(*pLastCol);
-        if (IS_VAR_DATA_TYPE(pLastCol->colVal.type)) {
-          charge += pLastCol->colVal.value.nData;
+          if (!pLastCol->dirty) {
+            pLastCol->dirty = 1;
+          }
+          /*
+            char  *value = NULL;
+            size_t vlen = 0;
+            tsdbCacheSerialize(pLastCol, &value, &vlen);
+            rocksdb_writebatch_put(wb, (char *)key, klen, value, vlen);
+            taosMemoryFree(value);
+          */
        }

-        LRUStatus status = taosLRUCacheInsert(pTsdb->lruCache, &key, ROCKS_KEY_LEN, pLastCol, charge, tsdbCacheDeleter,
-                                              NULL, TAOS_LRU_PRIORITY_LOW);
-        if (status != TAOS_LRU_STATUS_OK) {
-          code = -1;
+        taosLRUCacheRelease(pCache, h, false);
+      } else {
+        if (!remainCols) {
+          remainCols = taosArrayInit(num_keys * 2, sizeof(SIdxKey));
        }
-
-        taosMemoryFree(value);
+        taosArrayPush(remainCols, &(SIdxKey){i, *key});
      }
    }
-    //}
-
-    rocksdb_free(values_list[i]);
-    rocksdb_free(values_list[i + num_keys]);
  }
-  taosMemoryFree(values_list);
-  taosMemoryFree(values_list_sizes);
+
+  if (remainCols) {
+    num_keys = TARRAY_SIZE(remainCols);
+  }
+  if (remainCols && num_keys > 0) {
+    char  **keys_list = taosMemoryCalloc(num_keys, sizeof(char *));
+    size_t *keys_list_sizes = taosMemoryCalloc(num_keys, sizeof(size_t));
+    for (int i = 0; i < num_keys; ++i) {
+      SIdxKey *idxKey = &((SIdxKey *)TARRAY_DATA(remainCols))[i];
+
+      keys_list[i] = (char *)&idxKey->key;
+      keys_list_sizes[i] = ROCKS_KEY_LEN;
+    }
+    char  **values_list = taosMemoryCalloc(num_keys, sizeof(char *));
+    size_t *values_list_sizes = taosMemoryCalloc(num_keys, sizeof(size_t));
+    char  **errs = taosMemoryCalloc(num_keys, sizeof(char *));
+    rocksdb_multi_get(pTsdb->rCache.db, pTsdb->rCache.readoptions, num_keys, (const char *const *)keys_list,
+                      keys_list_sizes, values_list, values_list_sizes, errs);
+    for (int i = 0; i < num_keys; ++i) {
+      rocksdb_free(errs[i]);
+    }
+    taosMemoryFree(errs);
+    taosMemoryFree(keys_list);
+    taosMemoryFree(keys_list_sizes);
+    taosMemoryFree(values_list_sizes);
+
+    for (int i = 0; i < num_keys; ++i) {
+      SIdxKey *idxKey = &((SIdxKey *)TARRAY_DATA(remainCols))[i];
+      SColVal *pColVal = (SColVal *)TARRAY_DATA(aColVal) + idxKey->idx;
+      // SColVal *pColVal = (SColVal *)taosArrayGet(aColVal, idxKey->idx);
+
+      SLastCol *pLastCol = tsdbCacheDeserialize(values_list[i]);
+
+      if (idxKey->key.ltype == 0) {
+        if (NULL == pLastCol || pLastCol->ts <= keyTs) {
+          char  *value = NULL;
+          size_t vlen = 0;
+          tsdbCacheSerialize(&(SLastCol){.ts = keyTs, .colVal = *pColVal}, &value, &vlen);
+          // SLastKey key = (SLastKey){.ltype = 0, .uid = uid, .cid = pColVal->cid};
+          rocksdb_writebatch_put(wb, (char *)&idxKey->key, ROCKS_KEY_LEN, value, vlen);
+
+          pLastCol = (SLastCol *)value;
+          SLastCol *pTmpLastCol = taosMemoryCalloc(1, sizeof(SLastCol));
+          *pTmpLastCol = *pLastCol;
+          pLastCol = pTmpLastCol;
+
+          reallocVarData(&pLastCol->colVal);
+          size_t charge = sizeof(*pLastCol);
+          if (IS_VAR_DATA_TYPE(pLastCol->colVal.type)) {
+            charge += pLastCol->colVal.value.nData;
+          }
+
+          LRUStatus status = taosLRUCacheInsert(pTsdb->lruCache, &idxKey->key, ROCKS_KEY_LEN, pLastCol, charge,
+                                                tsdbCacheDeleter, NULL, TAOS_LRU_PRIORITY_LOW, &pTsdb->flushState);
+          if (status != TAOS_LRU_STATUS_OK) {
+            code = -1;
+          }
+
+          taosMemoryFree(value);
+        }
+      } else {
+        if (COL_VAL_IS_VALUE(pColVal)) {
+          if (NULL == pLastCol || pLastCol->ts <= keyTs) {
+            char  *value = NULL;
+            size_t vlen = 0;
+            tsdbCacheSerialize(&(SLastCol){.ts = keyTs, .colVal = *pColVal}, &value, &vlen);
+            // SLastKey key = (SLastKey){.ltype = 1, .uid = uid, .cid = pColVal->cid};
+            rocksdb_writebatch_put(wb, (char *)&idxKey->key, ROCKS_KEY_LEN, value, vlen);
+
+            pLastCol = (SLastCol *)value;
+            SLastCol *pTmpLastCol = taosMemoryCalloc(1, sizeof(SLastCol));
+            *pTmpLastCol = *pLastCol;
+            pLastCol = pTmpLastCol;
+
+            reallocVarData(&pLastCol->colVal);
+            size_t charge = sizeof(*pLastCol);
+            if (IS_VAR_DATA_TYPE(pLastCol->colVal.type)) {
+              charge += pLastCol->colVal.value.nData;
+            }
+
+            LRUStatus status = taosLRUCacheInsert(pTsdb->lruCache, &idxKey->key, ROCKS_KEY_LEN, pLastCol, charge,
+                                                  tsdbCacheDeleter, NULL, TAOS_LRU_PRIORITY_LOW, &pTsdb->flushState);
+            if (status != TAOS_LRU_STATUS_OK) {
+              code = -1;
+            }
+
+            taosMemoryFree(value);
+          }
+        }
+      }
+
+      rocksdb_free(values_list[i]);
+    }
+    taosMemoryFree(values_list);
+
+    taosArrayDestroy(remainCols);
+  }

  rocksMayWrite(pTsdb, true, false, false);
-  taosThreadMutexUnlock(&pTsdb->rCache.rMutex);
+  taosThreadMutexUnlock(&pTsdb->lruMutex);

 _exit:
  taosArrayDestroy(aColVal);
@ -651,11 +828,6 @@ static SLastCol *tsdbCacheLoadCol(STsdb *pTsdb, SCacheRowsReader *pr, int16_t sl
  return pLastCol;
 }

-typedef struct {
-  int      idx;
-  SLastKey key;
-} SIdxKey;
-
 static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArray, SArray *remainCols,
                                    SCacheRowsReader *pr, int8_t ltype) {
  int32_t               code = 0;
@ -712,7 +884,7 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr
    }

    LRUStatus status = taosLRUCacheInsert(pCache, &idxKey->key, ROCKS_KEY_LEN, pLastCol, charge, tsdbCacheDeleter, NULL,
-                                          TAOS_LRU_PRIORITY_LOW);
+                                          TAOS_LRU_PRIORITY_LOW, &pTsdb->flushState);
    if (status != TAOS_LRU_STATUS_OK) {
      code = -1;
    }
@ -787,7 +959,7 @@ static int32_t tsdbCacheLoadFromRocks(STsdb *pTsdb, tb_uid_t uid, SArray *pLastA
      }

      LRUStatus status = taosLRUCacheInsert(pCache, &idxKey->key, ROCKS_KEY_LEN, pLastCol, charge, tsdbCacheDeleter,
-                                            NULL, TAOS_LRU_PRIORITY_LOW);
+                                            NULL, TAOS_LRU_PRIORITY_LOW, &pTsdb->flushState);
      if (status != TAOS_LRU_STATUS_OK) {
        code = -1;
      }
@ -906,7 +1078,7 @@ int32_t tsdbCacheGet(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArray, SCacheRowsR
        }

        LRUStatus status = taosLRUCacheInsert(pCache, key, ROCKS_KEY_LEN, pLastCol, charge, tsdbCacheDeleter, &h,
-                                              TAOS_LRU_PRIORITY_LOW);
+                                              TAOS_LRU_PRIORITY_LOW, &pTsdb->flushState);
        if (status != TAOS_LRU_STATUS_OK) {
          code = -1;
        }
@ -1033,6 +1205,9 @@ int32_t tsdbOpenCache(STsdb *pTsdb) {

  taosThreadMutexInit(&pTsdb->lruMutex, NULL);

+  pTsdb->flushState.pTsdb = pTsdb;
+  pTsdb->flushState.flush_count = 0;
+
 _err:
  pTsdb->lruCache = pCache;
  return code;
@ -1062,7 +1237,8 @@ static void getTableCacheKey(tb_uid_t uid, int cacheType, char *key, int *len) {
  *len = sizeof(uint64_t);
 }

-static void deleteTableCacheLast(const void *key, size_t keyLen, void *value) {
+static void deleteTableCacheLast(const void *key, size_t keyLen, void *value, void *ud) {
+  (void)ud;
  SArray *pLastArray = (SArray *)value;
  int16_t nCol = taosArrayGetSize(pLastArray);
  for (int16_t iCol = 0; iCol < nCol; ++iCol) {
@ -3146,7 +3322,8 @@ int32_t tsdbCacheGetLastrowH(SLRUCache *pCache, tb_uid_t uid, SCacheRowsReader *

      size_t              charge = pArray->capacity * pArray->elemSize + sizeof(*pArray);
      _taos_lru_deleter_t deleter = deleteTableCacheLast;
-      LRUStatus status = taosLRUCacheInsert(pCache, key, keyLen, pArray, charge, deleter, &h, TAOS_LRU_PRIORITY_LOW);
+      LRUStatus           status =
+          taosLRUCacheInsert(pCache, key, keyLen, pArray, charge, deleter, &h, TAOS_LRU_PRIORITY_LOW, NULL);
      if (status != TAOS_LRU_STATUS_OK) {
        code = -1;
      }
@ -3186,7 +3363,7 @@ int32_t tsdbCacheGetLastH(SLRUCache *pCache, tb_uid_t uid, SCacheRowsReader *pr,
      size_t              charge = pLastArray->capacity * pLastArray->elemSize + sizeof(*pLastArray);
      _taos_lru_deleter_t deleter = deleteTableCacheLast;
      LRUStatus           status =
-          taosLRUCacheInsert(pCache, key, keyLen, pLastArray, charge, deleter, &h, TAOS_LRU_PRIORITY_LOW);
+          taosLRUCacheInsert(pCache, key, keyLen, pLastArray, charge, deleter, &h, TAOS_LRU_PRIORITY_LOW, NULL);
      if (status != TAOS_LRU_STATUS_OK) {
        code = -1;
      }
@ -3259,7 +3436,8 @@ static int32_t tsdbCacheLoadBlockIdx(SDataFReader *pFileReader, SArray **aBlockI
  return code;
 }

-static void deleteBICache(const void *key, size_t keyLen, void *value) {
+static void deleteBICache(const void *key, size_t keyLen, void *value, void *ud) {
+  (void)ud;
  SArray *pArray = (SArray *)value;

  taosArrayDestroy(pArray);
@ -3290,7 +3468,8 @@ int32_t tsdbCacheGetBlockIdx(SLRUCache *pCache, SDataFReader *pFileReader, LRUHa

      size_t              charge = pArray->capacity * pArray->elemSize + sizeof(*pArray);
      _taos_lru_deleter_t deleter = deleteBICache;
-      LRUStatus status = taosLRUCacheInsert(pCache, key, keyLen, pArray, charge, deleter, &h, TAOS_LRU_PRIORITY_LOW);
+      LRUStatus           status =
+          taosLRUCacheInsert(pCache, key, keyLen, pArray, charge, deleter, &h, TAOS_LRU_PRIORITY_LOW, NULL);
      if (status != TAOS_LRU_STATUS_OK) {
        code = -1;
      }
--- a/source/dnode/vnode/src/tsdb/tsdbRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbRead.c
@ -2846,18 +2846,18 @@ static int32_t buildComposedDataBlock(STsdbReader* pReader) {
      setBlockAllDumped(pDumpInfo, pBlock->maxKey.ts, pReader->order);
      return code;
    }
-    
+
    pBlockScanInfo = getTableBlockScanInfo(pReader->status.pTableMap, pBlockInfo->uid, pReader->idStr);
    if (pBlockScanInfo == NULL) {
      goto _end;
    }

-    TSDBKEY   keyInBuf = getCurrentKeyInBuf(pBlockScanInfo, pReader);
+    TSDBKEY keyInBuf = getCurrentKeyInBuf(pBlockScanInfo, pReader);

    // it is a clean block, load it directly
    if (isCleanFileDataBlock(pReader, pBlockInfo, pBlock, pBlockScanInfo, keyInBuf, pLastBlockReader) &&
        pBlock->nRow <= pReader->resBlockInfo.capacity) {
-      if (asc || (!hasDataInLastBlock(pLastBlockReader))) {
+      if (asc || (!hasDataInLastBlock(pLastBlockReader) && (pBlock->maxKey.ts > keyInBuf.ts))) {
        code = copyBlockDataToSDataBlock(pReader);
        if (code) {
          goto _end;
--- a/source/dnode/vnode/src/vnd/vnodeSvr.c
+++ b/source/dnode/vnode/src/vnd/vnodeSvr.c
@ -107,6 +107,10 @@ static int32_t vnodePreProcessCreateTableMsg(SVnode *pVnode, SRpcMsg *pMsg) {

 _exit:
  tDecoderClear(&dc);
+  if (code) {
+    vError("vgId:%d, %s:%d failed to preprocess submit request since %s, msg type:%s", TD_VID(pVnode), __func__, lino,
+           tstrerror(code), TMSG_INFO(pMsg->msgType));
+  }
  return code;
 }
 extern int64_t tsMaxKeyByPrecision[];
@ -238,11 +242,11 @@ static int32_t vnodePreProcessSubmitMsg(SVnode *pVnode, SRpcMsg *pMsg) {
  tEndDecode(pCoder);

 _exit:
-  if (code) {
-    vError("vgId:%d, failed to preprocess submit request since %s, msg type:%d", TD_VID(pVnode), tstrerror(code),
-           pMsg->msgType);
-  }
  tDecoderClear(pCoder);
+  if (code) {
+    vError("vgId:%d, %s:%d failed to preprocess submit request since %s, msg type:%s", TD_VID(pVnode), __func__, lino,
+           tstrerror(code), TMSG_INFO(pMsg->msgType));
+  }
  return code;
 }

@ -301,8 +305,8 @@ int32_t vnodePreProcessWriteMsg(SVnode *pVnode, SRpcMsg *pMsg) {

 _exit:
  if (code) {
-    vError("vgId:%d, failed to preprocess write request since %s, msg type:%d", TD_VID(pVnode), tstrerror(code),
-           pMsg->msgType);
+    vError("vgId:%d, failed to preprocess write request since %s, msg type:%s", TD_VID(pVnode), tstrerror(code),
+           TMSG_INFO(pMsg->msgType));
  }
  return code;
 }
@ -509,7 +513,7 @@ int32_t vnodePreprocessQueryMsg(SVnode *pVnode, SRpcMsg *pMsg) {

 int32_t vnodeProcessQueryMsg(SVnode *pVnode, SRpcMsg *pMsg) {
  vTrace("message in vnode query queue is processing");
-  if ((pMsg->msgType == TDMT_SCH_QUERY || pMsg->msgType == TDMT_VND_TMQ_CONSUME) && !syncIsReadyForRead(pVnode->sync)) {
+  if ((pMsg->msgType == TDMT_SCH_QUERY || pMsg->msgType == TDMT_VND_TMQ_CONSUME || pMsg->msgType == TDMT_VND_TMQ_CONSUME_PUSH) && !syncIsReadyForRead(pVnode->sync)) {
    vnodeRedirectRpcMsg(pVnode, pMsg, terrno);
    return 0;
  }
@ -530,6 +534,8 @@ int32_t vnodeProcessQueryMsg(SVnode *pVnode, SRpcMsg *pMsg) {
      return qWorkerProcessCQueryMsg(&handle, pVnode->pQuery, pMsg, 0);
    case TDMT_VND_TMQ_CONSUME:
      return tqProcessPollReq(pVnode->pTq, pMsg);
+    case TDMT_VND_TMQ_CONSUME_PUSH:
+      return tqProcessPollPush(pVnode->pTq, pMsg);
    default:
      vError("unknown msg type:%d in query queue", pMsg->msgType);
      return TSDB_CODE_APP_ERROR;
@ -563,8 +569,8 @@ int32_t vnodeProcessFetchMsg(SVnode *pVnode, SRpcMsg *pMsg, SQueueInfo *pInfo) {
      return vnodeGetTableCfg(pVnode, pMsg, true);
    case TDMT_VND_BATCH_META:
      return vnodeGetBatchMeta(pVnode, pMsg);
-    case TDMT_VND_TMQ_CONSUME:
-      return tqProcessPollReq(pVnode->pTq, pMsg);
+//    case TDMT_VND_TMQ_CONSUME:
+//      return tqProcessPollReq(pVnode->pTq, pMsg);
    case TDMT_VND_TMQ_VG_WALINFO:
      return tqProcessVgWalInfoReq(pVnode->pTq, pMsg);
    case TDMT_STREAM_TASK_RUN:
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@ -26,8 +26,8 @@
 #include "executil.h"
 #include "executorInt.h"
 #include "querytask.h"
-#include "tcompression.h"
 #include "storageapi.h"
+#include "tcompression.h"

 typedef struct tagFilterAssist {
  SHashObj* colHash;
@ -42,13 +42,13 @@ typedef enum {
 } FilterCondType;

 static FilterCondType checkTagCond(SNode* cond);
-static int32_t        optimizeTbnameInCond(void* metaHandle, int64_t suid, SArray* list, SNode* pTagCond, SStorageAPI* pAPI);
-static int32_t        optimizeTbnameInCondImpl(void* metaHandle, SArray* list, SNode* pTagCond, SStorageAPI* pStoreAPI);
+static int32_t optimizeTbnameInCond(void* metaHandle, int64_t suid, SArray* list, SNode* pTagCond, SStorageAPI* pAPI);
+static int32_t optimizeTbnameInCondImpl(void* metaHandle, SArray* list, SNode* pTagCond, SStorageAPI* pStoreAPI);

-static int32_t      getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond,
-                                 SNode* pTagIndexCond, STableListInfo* pListInfo, uint8_t* digest, const char* idstr, SStorageAPI* pStorageAPI);
-static SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, SArray* pUidTagList,
-                                               void* pVnode, SStorageAPI* pStorageAPI);
+static int32_t      getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, SNode* pTagIndexCond,
+                                 STableListInfo* pListInfo, uint8_t* digest, const char* idstr, SStorageAPI* pStorageAPI);
+static SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, SArray* pUidTagList, void* pVnode,
+                                               SStorageAPI* pStorageAPI);

 static int64_t getLimit(const SNode* pLimit) { return NULL == pLimit ? -1 : ((SLimitNode*)pLimit)->limit; }
 static int64_t getOffset(const SNode* pLimit) { return NULL == pLimit ? -1 : ((SLimitNode*)pLimit)->offset; }
@ -302,7 +302,7 @@ EDealRes doTranslateTagExpr(SNode** pNode, void* pContext) {
  return DEAL_RES_CONTINUE;
 }

-int32_t isQualifiedTable(STableKeyInfo* info, SNode* pTagCond, void* metaHandle, bool* pQualified, SStorageAPI *pAPI) {
+int32_t isQualifiedTable(STableKeyInfo* info, SNode* pTagCond, void* metaHandle, bool* pQualified, SStorageAPI* pAPI) {
  int32_t     code = TSDB_CODE_SUCCESS;
  SMetaReader mr = {0};

@ -495,7 +495,8 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf
    genTbGroupDigest((SNode*)listNode, digest, &context);
    nodesFree(listNode);

-    pAPI->metaFn.metaGetCachedTbGroup(pVnode, pTableListInfo->idInfo.suid, context.digest, tListLen(context.digest), &tableList);
+    pAPI->metaFn.metaGetCachedTbGroup(pVnode, pTableListInfo->idInfo.suid, context.digest, tListLen(context.digest),
+                                      &tableList);
    if (tableList) {
      taosArrayDestroy(pTableListInfo->pTableList);
      pTableListInfo->pTableList = tableList;
@ -632,7 +633,8 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf

  if (tsTagFilterCache) {
    tableList = taosArrayDup(pTableListInfo->pTableList, NULL);
-    pAPI->metaFn.metaPutTbGroupToCache(pVnode, pTableListInfo->idInfo.suid, context.digest, tListLen(context.digest), tableList, taosArrayGetSize(tableList) * sizeof(STableKeyInfo));
+    pAPI->metaFn.metaPutTbGroupToCache(pVnode, pTableListInfo->idInfo.suid, context.digest, tListLen(context.digest),
+                                       tableList, taosArrayGetSize(tableList) * sizeof(STableKeyInfo));
  }

  //  int64_t st2 = taosGetTimestampUs();
@ -776,7 +778,8 @@ static int32_t optimizeTbnameInCond(void* pVnode, int64_t suid, SArray* list, SN
 }

 // only return uid that does not contained in pExistedUidList
-static int32_t optimizeTbnameInCondImpl(void* pVnode, SArray* pExistedUidList, SNode* pTagCond, SStorageAPI* pStoreAPI) {
+static int32_t optimizeTbnameInCondImpl(void* pVnode, SArray* pExistedUidList, SNode* pTagCond,
+                                        SStorageAPI* pStoreAPI) {
  if (nodeType(pTagCond) != QUERY_NODE_OPERATOR) {
    return -1;
  }
@ -839,8 +842,8 @@ static int32_t optimizeTbnameInCondImpl(void* pVnode, SArray* pExistedUidList, S
  return -1;
 }

-static SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, SArray* pUidTagList,
-                                               void* pVnode, SStorageAPI* pStorageAPI) {
+static SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, SArray* pUidTagList, void* pVnode,
+                                               SStorageAPI* pStorageAPI) {
  SSDataBlock* pResBlock = createDataBlock();
  if (pResBlock == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
@ -1080,8 +1083,8 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S
      genTagFilterDigest(pTagCond, &context);

      bool acquired = false;
-      pStorageAPI->metaFn.getCachedTableList(pVnode, pScanNode->suid, context.digest, tListLen(context.digest), pUidList,
-                                &acquired);
+      pStorageAPI->metaFn.getCachedTableList(pVnode, pScanNode->suid, context.digest, tListLen(context.digest),
+                                             pUidList, &acquired);
      if (acquired) {
        digest[0] = 1;
        memcpy(digest + 1, context.digest, tListLen(context.digest));
@ -1097,13 +1100,15 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S
      if (pTagIndexCond) {
        void* pIndex = pStorageAPI->metaFn.getInvertIndex(pVnode);

-        SIndexMetaArg metaArg = {
-            .metaEx = pVnode, .idx = pStorageAPI->metaFn.storeGetIndexInfo(pVnode), .ivtIdx = pIndex, .suid = pScanNode->uid};
+        SIndexMetaArg metaArg = {.metaEx = pVnode,
+                                 .idx = pStorageAPI->metaFn.storeGetIndexInfo(pVnode),
+                                 .ivtIdx = pIndex,
+                                 .suid = pScanNode->uid};

        status = SFLT_NOT_INDEX;
        code = doFilterTag(pTagIndexCond, &metaArg, pUidList, &status, &pStorageAPI->metaFilter);
        if (code != 0 || status == SFLT_NOT_INDEX) {  // temporarily disable it for performance sake
-          qWarn("failed to get tableIds from index, suid:%" PRIu64, pScanNode->uid);
+          qDebug("failed to get tableIds from index, suid:%" PRIu64, pScanNode->uid);
          code = TSDB_CODE_SUCCESS;
        } else {
          qInfo("succ to get filter result, table num: %d", (int)taosArrayGetSize(pUidList));
@ -1128,7 +1133,8 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S
        memcpy(pPayload + sizeof(int32_t), taosArrayGet(pUidList, 0), numOfTables * sizeof(uint64_t));
      }

-//      metaUidFilterCachePut(metaHandle, pScanNode->suid, context.digest, tListLen(context.digest), pPayload, size, 1);
+      //      metaUidFilterCachePut(metaHandle, pScanNode->suid, context.digest, tListLen(context.digest), pPayload,
+      //      size, 1);
      digest[0] = 1;
      memcpy(digest + 1, context.digest, tListLen(context.digest));
    }
@ -1152,15 +1158,17 @@ _end:
  return code;
 }

-int32_t qGetTableList(int64_t suid, void* pVnode, void* node, SArray **tableList, void* pTaskInfo){
-  SSubplan *pSubplan = (SSubplan *)node;
+int32_t qGetTableList(int64_t suid, void* pVnode, void* node, SArray** tableList, void* pTaskInfo) {
+  SSubplan*      pSubplan = (SSubplan*)node;
  SScanPhysiNode pNode = {0};
  pNode.suid = suid;
  pNode.uid = suid;
  pNode.tableType = TSDB_SUPER_TABLE;
  STableListInfo* pTableListInfo = tableListCreate();
-  uint8_t digest[17] = {0};
-  int code = getTableList(pVnode, &pNode, pSubplan ? pSubplan->pTagCond : NULL, pSubplan ? pSubplan->pTagIndexCond : NULL, pTableListInfo, digest, "qGetTableList", &((SExecTaskInfo*)pTaskInfo)->storageAPI);
+  uint8_t         digest[17] = {0};
+  int             code =
+      getTableList(pVnode, &pNode, pSubplan ? pSubplan->pTagCond : NULL, pSubplan ? pSubplan->pTagIndexCond : NULL,
+                   pTableListInfo, digest, "qGetTableList", &((SExecTaskInfo*)pTaskInfo)->storageAPI);
  *tableList = pTableListInfo->pTableList;
  pTableListInfo->pTableList = NULL;
  tableListDestroy(pTableListInfo);
@ -1181,7 +1189,7 @@ size_t getTableTagsBufLen(const SNodeList* pGroups) {
 }

 int32_t getGroupIdFromTagsVal(void* pVnode, uint64_t uid, SNodeList* pGroupNode, char* keyBuf, uint64_t* pGroupId,
-    SStorageAPI* pAPI) {
+                              SStorageAPI* pAPI) {
  SMetaReader mr = {0};

  pAPI->metaReaderFn.initReader(&mr, pVnode, 0, &pAPI->metaFn);
@ -1560,7 +1568,8 @@ static int32_t setSelectValueColumnInfo(SqlFunctionCtx* pCtx, int32_t numOfOutpu
  return TSDB_CODE_SUCCESS;
 }

-SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, int32_t** rowEntryInfoOffset, SFunctionStateStore* pStore) {
+SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, int32_t** rowEntryInfoOffset,
+                                     SFunctionStateStore* pStore) {
  SqlFunctionCtx* pFuncCtx = (SqlFunctionCtx*)taosMemoryCalloc(numOfOutput, sizeof(SqlFunctionCtx));
  if (pFuncCtx == NULL) {
    return NULL;
@ -1849,7 +1858,7 @@ void getNextTimeWindow(const SInterval* pInterval, STimeWindow* tw, int32_t orde
  }

  struct tm tm;
-  time_t    t = (time_t) key;
+  time_t    t = (time_t)key;
  taosLocalTime(&t, &tm, NULL);

  int mon = (int)(tm.tm_year * 12 + tm.tm_mon + duration * factor);
@ -2079,8 +2088,8 @@ static int32_t sortTableGroup(STableListInfo* pTableListInfo) {
  return TSDB_CODE_SUCCESS;
 }

-int32_t buildGroupIdMapForAllTables(STableListInfo* pTableListInfo, SReadHandle* pHandle, SScanPhysiNode* pScanNode, SNodeList* group,
-                                    bool groupSort, uint8_t *digest, SStorageAPI* pAPI) {
+int32_t buildGroupIdMapForAllTables(STableListInfo* pTableListInfo, SReadHandle* pHandle, SScanPhysiNode* pScanNode,
+                                    SNodeList* group, bool groupSort, uint8_t* digest, SStorageAPI* pAPI) {
  int32_t code = TSDB_CODE_SUCCESS;

  bool   groupByTbname = groupbyTbname(group);
@ -2132,7 +2141,8 @@ int32_t createScanTableListInfo(SScanPhysiNode* pScanNode, SNodeList* pGroupTags
  }

  uint8_t digest[17] = {0};
-  int32_t code = getTableList(pHandle->vnode, pScanNode, pTagCond, pTagIndexCond, pTableListInfo, digest, idStr, &pTaskInfo->storageAPI);
+  int32_t code = getTableList(pHandle->vnode, pScanNode, pTagCond, pTagIndexCond, pTableListInfo, digest, idStr,
+                              &pTaskInfo->storageAPI);
  if (code != TSDB_CODE_SUCCESS) {
    qError("failed to getTableList, code: %s", tstrerror(code));
    return code;
@ -2150,7 +2160,8 @@ int32_t createScanTableListInfo(SScanPhysiNode* pScanNode, SNodeList* pGroupTags
    return TSDB_CODE_SUCCESS;
  }

-  code = buildGroupIdMapForAllTables(pTableListInfo, pHandle, pScanNode, pGroupTags, groupSort, digest, &pTaskInfo->storageAPI);
+  code = buildGroupIdMapForAllTables(pTableListInfo, pHandle, pScanNode, pGroupTags, groupSort, digest,
+                                     &pTaskInfo->storageAPI);
  if (code != TSDB_CODE_SUCCESS) {
    return code;
  }
--- a/source/libs/executor/src/filloperator.c
+++ b/source/libs/executor/src/filloperator.c
@ -187,6 +187,8 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) {
  // the scan order may be different from the output result order for agg interval operator.
  if (pDownstream->operatorType == QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL) {
    order = ((SIntervalAggOperatorInfo*) pDownstream->info)->resultTsOrder;
+  } else {
+    order = pInfo->pFillInfo->order;
  }

  doHandleRemainBlockFromNewGroup(pOperator, pInfo, pResultInfo, order);
--- a/source/libs/executor/src/scanoperator.c
+++ b/source/libs/executor/src/scanoperator.c
@ -55,7 +55,6 @@ typedef struct STableMergeScanSortSourceParam {
  int32_t        readerIdx;
  uint64_t       uid;
  SSDataBlock*   inputBlock;
-  bool           multiReader;
  STsdbReader*   dataReader;
 } STableMergeScanSortSourceParam;

@ -466,7 +465,12 @@ static STableCachedVal* createTableCacheVal(const SMetaReader* pMetaReader) {
 }

 // const void *key, size_t keyLen, void *value
-static void freeCachedMetaItem(const void* key, size_t keyLen, void* value) { freeTableCachedVal(value); }
+static void freeCachedMetaItem(const void* key, size_t keyLen, void* value, void* ud) {
+  (void)key;
+  (void)keyLen;
+  (void)ud;
+  freeTableCachedVal(value);
+}

 static void doSetNullValue(SSDataBlock* pBlock, const SExprInfo* pExpr, int32_t numOfExpr) {
  for (int32_t j = 0; j < numOfExpr; ++j) {
@ -501,7 +505,7 @@ int32_t addTagPseudoColumnData(SReadHandle* pHandle, const SExprInfo* pExpr, int

  // 1. check if it is existed in meta cache
  if (pCache == NULL) {
-    pHandle->api.metaReaderFn.initReader(&mr, pHandle->vnode, 0, &pHandle->api.metaFn);
+    pHandle->api.metaReaderFn.initReader(&mr, pHandle->vnode, META_READER_NOLOCK, &pHandle->api.metaFn);
    code = pHandle->api.metaReaderFn.getEntryGetUidCache(&mr, pBlock->info.id.uid);
    if (code != TSDB_CODE_SUCCESS) {
      // when encounter the TSDB_CODE_PAR_TABLE_NOT_EXIST error, we proceed.
@ -554,7 +558,7 @@ int32_t addTagPseudoColumnData(SReadHandle* pHandle, const SExprInfo* pExpr, int
      freeReader = true;

      int32_t ret = taosLRUCacheInsert(pCache->pTableMetaEntryCache, &pBlock->info.id.uid, sizeof(uint64_t), pVal,
-                                       sizeof(STableCachedVal), freeCachedMetaItem, NULL, TAOS_LRU_PRIORITY_LOW);
+                                       sizeof(STableCachedVal), freeCachedMetaItem, NULL, TAOS_LRU_PRIORITY_LOW, NULL);
      if (ret != TAOS_LRU_STATUS_OK) {
        qError("failed to put meta into lru cache, code:%d, %s", ret, idStr);
        freeTableCachedVal(pVal);
@ -2653,8 +2657,7 @@ static SSDataBlock* getTableDataBlockImpl(void* param) {
  int64_t      st = taosGetTimestampUs();
  void*        p = tableListGetInfo(pInfo->base.pTableListInfo, readIdx + pInfo->tableStartIndex);
  SReadHandle* pHandle = &pInfo->base.readHandle;
-
-  if (NULL == source->dataReader || !source->multiReader) {
+  if (NULL == source->dataReader) {
    code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, pQueryCond, p, 1, pBlock, (void**)&source->dataReader, GET_TASKID(pTaskInfo), false, NULL);
    if (code != 0) {
      T_LONG_JMP(pTaskInfo->env, code);
@ -2718,19 +2721,15 @@ static SSDataBlock* getTableDataBlockImpl(void* param) {
    pInfo->base.readRecorder.elapsedTime += (taosGetTimestampUs() - st) / 1000.0;

    qTrace("tsdb/read-table-data: %p, close reader", reader);
-    if (!source->multiReader) {
-      pAPI->tsdReader.tsdReaderClose(pInfo->base.dataReader);
-      source->dataReader = NULL;
-    }
    pInfo->base.dataReader = NULL;
    return pBlock;
  }

-  if (!source->multiReader) {
-    pAPI->tsdReader.tsdReaderClose(pInfo->base.dataReader);
-    source->dataReader = NULL;
-  }
+  pAPI->tsdReader.tsdReaderClose(source->dataReader);
+  source->dataReader = NULL;
  pInfo->base.dataReader = NULL;
+  blockDataDestroy(source->inputBlock);
+  source->inputBlock = NULL;
  return NULL;
 }

@ -2786,7 +2785,19 @@ int32_t startGroupTableMergeScan(SOperatorInfo* pOperator) {

  // todo the total available buffer should be determined by total capacity of buffer of this task.
  // the additional one is reserved for merge result
-  pInfo->sortBufSize = pInfo->bufPageSize * (tableEndIdx - tableStartIdx + 1 + 1);
+  // pInfo->sortBufSize = pInfo->bufPageSize * (tableEndIdx - tableStartIdx + 1 + 1);
+  int32_t kWay = (TSDB_MAX_BYTES_PER_ROW * 2) / (pInfo->pResBlock->info.rowSize);
+  if (kWay >= 128) {
+    kWay = 128;
+  } else if (kWay <= 2) {
+    kWay = 2;
+  } else {
+    int i = 2; 
+    while (i * 2 <= kWay) i = i * 2;
+    kWay = i;
+  }
+
+  pInfo->sortBufSize = pInfo->bufPageSize * (kWay + 1);
  int32_t numOfBufPage = pInfo->sortBufSize / pInfo->bufPageSize;
  pInfo->pSortHandle = tsortCreateSortHandle(pInfo->pSortInfo, SORT_MULTISOURCE_MERGE, pInfo->bufPageSize, numOfBufPage,
                                             pInfo->pSortInputBlock, pTaskInfo->id.str);
@ -2801,9 +2812,7 @@ int32_t startGroupTableMergeScan(SOperatorInfo* pOperator) {
    STableMergeScanSortSourceParam param = {0};
    param.readerIdx = i;
    param.pOperator = pOperator;
-    param.multiReader = (numOfTable <= MULTI_READER_MAX_TABLE_NUM) ? true : false;
    param.inputBlock = createOneDataBlock(pInfo->pResBlock, false);
-    blockDataEnsureCapacity(param.inputBlock, pOperator->resultInfo.capacity);

    taosArrayPush(pInfo->sortSourceParams, &param);

--- a/source/libs/executor/src/sysscanoperator.c
+++ b/source/libs/executor/src/sysscanoperator.c
@ -1593,6 +1593,8 @@ static SSDataBlock* doSysTableScan(SOperatorInfo* pOperator) {
  SSysTableScanInfo* pInfo = pOperator->info;
  char               dbName[TSDB_DB_NAME_LEN] = {0};

+  blockDataCleanup(pInfo->pRes);
+
  const char* name = tNameGetTableName(&pInfo->name);
  if (pInfo->showRewrite) {
    getDBNameFromCondition(pInfo->pCondition, dbName);
--- a/source/libs/executor/src/tsort.c
+++ b/source/libs/executor/src/tsort.c
@ -101,7 +101,11 @@ static int32_t sortComparCleanup(SMsortComparParam* cmpParam) {
  for (int32_t i = 0; i < cmpParam->numOfSources; ++i) {
    SSortSource* pSource = cmpParam->pSources[i];
    blockDataDestroy(pSource->src.pBlock);
+    if (pSource->pageIdList) {
+      taosArrayDestroy(pSource->pageIdList);
+    }
    taosMemoryFreeClear(pSource);
+    cmpParam->pSources[i] = NULL;
  }

  cmpParam->numOfSources = 0;
@ -123,9 +127,11 @@ void tsortClearOrderdSource(SArray* pOrderedSource, int64_t *fetchUs, int64_t *f
    // release pageIdList
    if ((*pSource)->pageIdList) {
      taosArrayDestroy((*pSource)->pageIdList);
+      (*pSource)->pageIdList = NULL;
    }
    if ((*pSource)->param && !(*pSource)->onlyRef) {
      taosMemoryFree((*pSource)->param);
+      (*pSource)->param = NULL;
    }

    if (!(*pSource)->onlyRef && (*pSource)->src.pBlock) {
--- a/source/libs/function/inc/functionMgtInt.h
+++ b/source/libs/function/inc/functionMgtInt.h
@ -51,6 +51,7 @@ extern "C" {
 #define FUNC_MGT_CUMULATIVE_FUNC        FUNC_MGT_FUNC_CLASSIFICATION_MASK(22)
 #define FUNC_MGT_INTERP_PC_FUNC         FUNC_MGT_FUNC_CLASSIFICATION_MASK(23)
 #define FUNC_MGT_GEOMETRY_FUNC          FUNC_MGT_FUNC_CLASSIFICATION_MASK(24)
+#define FUNC_MGT_FORBID_SYSTABLE_FUNC   FUNC_MGT_FUNC_CLASSIFICATION_MASK(25)

 #define FUNC_MGT_TEST_MASK(val, mask) (((val) & (mask)) != 0)

--- a/source/libs/function/src/builtins.c
+++ b/source/libs/function/src/builtins.c
@ -2348,7 +2348,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
  {
    .name = "leastsquares",
    .type = FUNCTION_TYPE_LEASTSQUARES,
-    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_TIMELINE_FUNC | FUNC_MGT_FORBID_STREAM_FUNC,
+    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_TIMELINE_FUNC | FUNC_MGT_FORBID_STREAM_FUNC | FUNC_MGT_FORBID_SYSTABLE_FUNC,
    .translateFunc = translateLeastSQR,
    .getEnvFunc   = getLeastSQRFuncEnv,
    .initFunc     = leastSQRFunctionSetup,
@ -2456,7 +2456,8 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
  {
    .name = "top",
    .type = FUNCTION_TYPE_TOP,
-    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_MULTI_ROWS_FUNC | FUNC_MGT_KEEP_ORDER_FUNC | FUNC_MGT_FORBID_STREAM_FUNC | FUNC_MGT_FORBID_FILL_FUNC,
+    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_MULTI_ROWS_FUNC | FUNC_MGT_KEEP_ORDER_FUNC |
+                      FUNC_MGT_FORBID_STREAM_FUNC | FUNC_MGT_FORBID_FILL_FUNC,
    .translateFunc = translateTopBot,
    .getEnvFunc   = getTopBotFuncEnv,
    .initFunc     = topBotFunctionSetup,
@ -2471,7 +2472,8 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
  {
    .name = "bottom",
    .type = FUNCTION_TYPE_BOTTOM,
-    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_MULTI_ROWS_FUNC | FUNC_MGT_KEEP_ORDER_FUNC | FUNC_MGT_FORBID_STREAM_FUNC | FUNC_MGT_FORBID_FILL_FUNC,
+    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_MULTI_ROWS_FUNC | FUNC_MGT_KEEP_ORDER_FUNC |
+                      FUNC_MGT_FORBID_STREAM_FUNC | FUNC_MGT_FORBID_FILL_FUNC,
    .translateFunc = translateTopBot,
    .getEnvFunc   = getTopBotFuncEnv,
    .initFunc     = topBotFunctionSetup,
@ -2528,7 +2530,8 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
  {
    .name = "elapsed",
    .type = FUNCTION_TYPE_ELAPSED,
-    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_TIMELINE_FUNC | FUNC_MGT_INTERVAL_INTERPO_FUNC | FUNC_MGT_FORBID_STREAM_FUNC | FUNC_MGT_SPECIAL_DATA_REQUIRED,
+    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_TIMELINE_FUNC | FUNC_MGT_INTERVAL_INTERPO_FUNC | FUNC_MGT_FORBID_STREAM_FUNC |
+                      FUNC_MGT_FORBID_SYSTABLE_FUNC | FUNC_MGT_SPECIAL_DATA_REQUIRED,
    .dataRequiredFunc = statisDataRequired,
    .translateFunc = translateElapsed,
    .getEnvFunc   = getElapsedFuncEnv,
@ -2568,7 +2571,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
    .name = "interp",
    .type = FUNCTION_TYPE_INTERP,
    .classification = FUNC_MGT_TIMELINE_FUNC | FUNC_MGT_INTERVAL_INTERPO_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC |
-                      FUNC_MGT_FORBID_STREAM_FUNC|FUNC_MGT_KEEP_ORDER_FUNC,
+                      FUNC_MGT_FORBID_STREAM_FUNC | FUNC_MGT_FORBID_SYSTABLE_FUNC | FUNC_MGT_KEEP_ORDER_FUNC,
    .translateFunc = translateInterp,
    .getEnvFunc    = getSelectivityFuncEnv,
    .initFunc      = functionSetup,
@ -2580,7 +2583,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
    .name = "derivative",
    .type = FUNCTION_TYPE_DERIVATIVE,
    .classification = FUNC_MGT_INDEFINITE_ROWS_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_TIMELINE_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC |
-                      FUNC_MGT_KEEP_ORDER_FUNC | FUNC_MGT_CUMULATIVE_FUNC | FUNC_MGT_FORBID_STREAM_FUNC,
+                      FUNC_MGT_KEEP_ORDER_FUNC | FUNC_MGT_CUMULATIVE_FUNC | FUNC_MGT_FORBID_STREAM_FUNC | FUNC_MGT_FORBID_SYSTABLE_FUNC,
    .translateFunc = translateDerivative,
    .getEnvFunc   = getDerivativeFuncEnv,
    .initFunc     = derivativeFuncSetup,
@ -2592,7 +2595,8 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
  {
    .name = "irate",
    .type = FUNCTION_TYPE_IRATE,
-    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_TIMELINE_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC | FUNC_MGT_FORBID_STREAM_FUNC,
+    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_TIMELINE_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC | FUNC_MGT_FORBID_STREAM_FUNC |
+                      FUNC_MGT_FORBID_SYSTABLE_FUNC,
    .translateFunc = translateIrate,
    .getEnvFunc   = getIrateFuncEnv,
    .initFunc     = irateFuncSetup,
@ -2603,7 +2607,8 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
  {
    .name = "last_row",
    .type = FUNCTION_TYPE_LAST_ROW,
-    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_MULTI_RES_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC | FUNC_MGT_KEEP_ORDER_FUNC,
+    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_MULTI_RES_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC |
+                      FUNC_MGT_KEEP_ORDER_FUNC | FUNC_MGT_FORBID_SYSTABLE_FUNC,
    .translateFunc = translateFirstLast,
    .dynDataRequiredFunc = lastDynDataReq,
    .getEnvFunc   = getFirstLastFuncEnv,
@ -2618,7 +2623,8 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
  {
    .name = "_cache_last_row",
    .type = FUNCTION_TYPE_CACHE_LAST_ROW,
-    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_MULTI_RES_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC | FUNC_MGT_FORBID_STREAM_FUNC,
+    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_MULTI_RES_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC |
+                      FUNC_MGT_FORBID_STREAM_FUNC | FUNC_MGT_FORBID_SYSTABLE_FUNC,
    .translateFunc = translateFirstLast,
    .getEnvFunc   = getFirstLastFuncEnv,
    .initFunc     = functionSetup,
@ -2628,7 +2634,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
  {
    .name = "_cache_last",
    .type = FUNCTION_TYPE_CACHE_LAST,
-    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_MULTI_RES_FUNC | FUNC_MGT_FORBID_STREAM_FUNC,
+    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_MULTI_RES_FUNC | FUNC_MGT_FORBID_STREAM_FUNC | FUNC_MGT_FORBID_SYSTABLE_FUNC,
    .translateFunc = translateFirstLast,
    .getEnvFunc   = getFirstLastFuncEnv,
    .initFunc     = functionSetup,
@ -2638,7 +2644,8 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
  {
    .name = "_last_row_partial",
    .type = FUNCTION_TYPE_LAST_PARTIAL,
-    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_MULTI_RES_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC,
+    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_MULTI_RES_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC |
+                      FUNC_MGT_FORBID_SYSTABLE_FUNC,
    .translateFunc = translateFirstLastPartial,
    .dynDataRequiredFunc = lastDynDataReq,
    .getEnvFunc   = getFirstLastFuncEnv,
@ -2649,7 +2656,8 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
  {
    .name = "_last_row_merge",
    .type = FUNCTION_TYPE_LAST_MERGE,
-    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_MULTI_RES_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC,
+    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_MULTI_RES_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC |
+                      FUNC_MGT_FORBID_SYSTABLE_FUNC,
    .translateFunc = translateFirstLastMerge,
    .getEnvFunc   = getFirstLastFuncEnv,
    .initFunc     = functionSetup,
@ -2659,7 +2667,8 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
  {
    .name = "first",
    .type = FUNCTION_TYPE_FIRST,
-    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_MULTI_RES_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC | FUNC_MGT_KEEP_ORDER_FUNC,
+    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_MULTI_RES_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC |
+                      FUNC_MGT_KEEP_ORDER_FUNC | FUNC_MGT_FORBID_SYSTABLE_FUNC,
    .translateFunc = translateFirstLast,
    .dynDataRequiredFunc = firstDynDataReq,
    .getEnvFunc   = getFirstLastFuncEnv,
@ -2674,7 +2683,8 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
  {
    .name = "_first_partial",
    .type = FUNCTION_TYPE_FIRST_PARTIAL,
-    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_MULTI_RES_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC,
+    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_MULTI_RES_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC |
+                      FUNC_MGT_FORBID_SYSTABLE_FUNC,
    .translateFunc = translateFirstLastPartial,
    .dynDataRequiredFunc = firstDynDataReq,
    .getEnvFunc   = getFirstLastFuncEnv,
@ -2686,7 +2696,8 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
  {
    .name = "_first_merge",
    .type = FUNCTION_TYPE_FIRST_MERGE,
-    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_MULTI_RES_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC,
+    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_MULTI_RES_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC |
+                      FUNC_MGT_FORBID_SYSTABLE_FUNC,
    .translateFunc = translateFirstLastMerge,
    .getEnvFunc   = getFirstLastFuncEnv,
    .initFunc     = functionSetup,
@ -2697,7 +2708,8 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
  {
    .name = "last",
    .type = FUNCTION_TYPE_LAST,
-    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_MULTI_RES_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC | FUNC_MGT_KEEP_ORDER_FUNC,
+    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_MULTI_RES_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC |
+                      FUNC_MGT_KEEP_ORDER_FUNC | FUNC_MGT_FORBID_SYSTABLE_FUNC,
    .translateFunc = translateFirstLast,
    .dynDataRequiredFunc = lastDynDataReq,
    .getEnvFunc   = getFirstLastFuncEnv,
@ -2712,7 +2724,8 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
  {
    .name = "_last_partial",
    .type = FUNCTION_TYPE_LAST_PARTIAL,
-    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_MULTI_RES_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC,
+    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_MULTI_RES_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC |
+                      FUNC_MGT_FORBID_SYSTABLE_FUNC,
    .translateFunc = translateFirstLastPartial,
    .dynDataRequiredFunc = lastDynDataReq,
    .getEnvFunc   = getFirstLastFuncEnv,
@ -2724,7 +2737,8 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
  {
    .name = "_last_merge",
    .type = FUNCTION_TYPE_LAST_MERGE,
-    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_MULTI_RES_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC,
+    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_MULTI_RES_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC |
+                      FUNC_MGT_FORBID_SYSTABLE_FUNC,
    .translateFunc = translateFirstLastMerge,
    .getEnvFunc   = getFirstLastFuncEnv,
    .initFunc     = functionSetup,
@ -2735,7 +2749,8 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
  {
    .name = "twa",
    .type = FUNCTION_TYPE_TWA,
-    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_TIMELINE_FUNC | FUNC_MGT_INTERVAL_INTERPO_FUNC | FUNC_MGT_FORBID_STREAM_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC,
+    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_TIMELINE_FUNC | FUNC_MGT_INTERVAL_INTERPO_FUNC | FUNC_MGT_FORBID_STREAM_FUNC |
+                      FUNC_MGT_IMPLICIT_TS_FUNC | FUNC_MGT_FORBID_SYSTABLE_FUNC,
    .translateFunc = translateInNumOutDou,
    .dataRequiredFunc = statisDataRequired,
    .getEnvFunc    = getTwaFuncEnv,
@ -2826,7 +2841,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
    .name = "diff",
    .type = FUNCTION_TYPE_DIFF,
    .classification = FUNC_MGT_INDEFINITE_ROWS_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_TIMELINE_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC |
-                      FUNC_MGT_KEEP_ORDER_FUNC | FUNC_MGT_FORBID_STREAM_FUNC | FUNC_MGT_CUMULATIVE_FUNC,
+                      FUNC_MGT_KEEP_ORDER_FUNC | FUNC_MGT_FORBID_STREAM_FUNC | FUNC_MGT_CUMULATIVE_FUNC | FUNC_MGT_FORBID_SYSTABLE_FUNC,
    .translateFunc = translateDiff,
    .getEnvFunc   = getDiffFuncEnv,
    .initFunc     = diffFunctionSetup,
@ -2839,7 +2854,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
    .name = "statecount",
    .type = FUNCTION_TYPE_STATE_COUNT,
    .classification = FUNC_MGT_INDEFINITE_ROWS_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_TIMELINE_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC |
-                      FUNC_MGT_FORBID_STREAM_FUNC,
+                      FUNC_MGT_FORBID_STREAM_FUNC | FUNC_MGT_FORBID_SYSTABLE_FUNC,
    .translateFunc = translateStateCount,
    .getEnvFunc   = getStateFuncEnv,
    .initFunc     = functionSetup,
@ -2851,7 +2866,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
    .name = "stateduration",
    .type = FUNCTION_TYPE_STATE_DURATION,
    .classification = FUNC_MGT_INDEFINITE_ROWS_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_TIMELINE_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC |
-                      FUNC_MGT_FORBID_STREAM_FUNC,
+                      FUNC_MGT_FORBID_STREAM_FUNC | FUNC_MGT_FORBID_SYSTABLE_FUNC,
    .translateFunc = translateStateDuration,
    .getEnvFunc   = getStateFuncEnv,
    .initFunc     = functionSetup,
@ -2863,7 +2878,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
    .name = "csum",
    .type = FUNCTION_TYPE_CSUM,
    .classification = FUNC_MGT_INDEFINITE_ROWS_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_TIMELINE_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC |
-                      FUNC_MGT_FORBID_STREAM_FUNC | FUNC_MGT_CUMULATIVE_FUNC | FUNC_MGT_KEEP_ORDER_FUNC,
+                      FUNC_MGT_FORBID_STREAM_FUNC | FUNC_MGT_CUMULATIVE_FUNC | FUNC_MGT_KEEP_ORDER_FUNC | FUNC_MGT_FORBID_SYSTABLE_FUNC,
    .translateFunc = translateCsum,
    .getEnvFunc   = getCsumFuncEnv,
    .initFunc     = functionSetup,
@ -2876,7 +2891,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
    .name = "mavg",
    .type = FUNCTION_TYPE_MAVG,
    .classification = FUNC_MGT_INDEFINITE_ROWS_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_TIMELINE_FUNC | FUNC_MGT_IMPLICIT_TS_FUNC |
-                      FUNC_MGT_FORBID_STREAM_FUNC,
+                      FUNC_MGT_FORBID_STREAM_FUNC | FUNC_MGT_FORBID_SYSTABLE_FUNC,
    .translateFunc = translateMavg,
    .getEnvFunc   = getMavgFuncEnv,
    .initFunc     = mavgFunctionSetup,
@ -2887,7 +2902,8 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
  {
    .name = "sample",
    .type = FUNCTION_TYPE_SAMPLE,
-    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_MULTI_ROWS_FUNC | FUNC_MGT_KEEP_ORDER_FUNC | FUNC_MGT_FORBID_STREAM_FUNC | FUNC_MGT_FORBID_FILL_FUNC,
+    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC | FUNC_MGT_MULTI_ROWS_FUNC | FUNC_MGT_KEEP_ORDER_FUNC | FUNC_MGT_FORBID_STREAM_FUNC |
+                      FUNC_MGT_FORBID_FILL_FUNC,
    .translateFunc = translateSample,
    .getEnvFunc   = getSampleFuncEnv,
    .initFunc     = sampleFunctionSetup,
--- a/source/libs/function/src/functionMgt.c
+++ b/source/libs/function/src/functionMgt.c
@ -219,6 +219,8 @@ bool fmIsKeepOrderFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, F

 bool fmIsCumulativeFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_CUMULATIVE_FUNC); }

+bool fmIsForbidSysTableFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_FORBID_SYSTABLE_FUNC); }
+
 bool fmIsInterpFunc(int32_t funcId) {
  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {
    return false;
--- a/source/libs/index/src/indexFstFile.c
+++ b/source/libs/index/src/indexFstFile.c
@ -29,7 +29,10 @@ typedef struct {
  char    buf[0];
 } SDataBlock;

-static void deleteDataBlockFromLRU(const void* key, size_t keyLen, void* value) { taosMemoryFree(value); }
+static void deleteDataBlockFromLRU(const void* key, size_t keyLen, void* value, void* ud) {
+  (void)ud;
+  taosMemoryFree(value);
+}

 static FORCE_INLINE void idxGenLRUKey(char* buf, const char* path, int32_t blockId) {
  char* p = buf;
@ -136,7 +139,7 @@ static int idxFileCtxDoReadFrom(IFileCtx* ctx, uint8_t* buf, int len, int32_t of
        memcpy(buf + total, blk->buf + blkOffset, nread);

        LRUStatus s = taosLRUCacheInsert(ctx->lru, key, strlen(key), blk, cacheMemSize, deleteDataBlockFromLRU, NULL,
-                                         TAOS_LRU_PRIORITY_LOW);
+                                         TAOS_LRU_PRIORITY_LOW, NULL);
        if (s != TAOS_LRU_STATUS_OK) {
          return -1;
        }
--- a/source/libs/parser/src/parCalcConst.c
+++ b/source/libs/parser/src/parCalcConst.c
@ -372,18 +372,33 @@ static bool notRefByOrderBy(SColumnNode* pCol, SNodeList* pOrderByList) {
  return !cxt.hasThisCol;
 }

+static bool isDistinctSubQuery(SNode* pNode) {
+  if (NULL == pNode) {
+    return false;
+  }
+  switch (nodeType(pNode)) {
+    case QUERY_NODE_SELECT_STMT:
+      return ((SSelectStmt*)pNode)->isDistinct;
+    case QUERY_NODE_SET_OPERATOR:
+      return isDistinctSubQuery((((SSetOperator*)pNode)->pLeft)) || isDistinctSubQuery((((SSetOperator*)pNode)->pLeft));
+    default:
+      break;
+  }
+  return false;
+}
+
 static bool isSetUselessCol(SSetOperator* pSetOp, int32_t index, SExprNode* pProj) {
  if (!isUselessCol(pProj)) {
    return false;
  }

  SNodeList* pLeftProjs = getChildProjection(pSetOp->pLeft);
-  if (!isUselessCol((SExprNode*)nodesListGetNode(pLeftProjs, index))) {
+  if (!isUselessCol((SExprNode*)nodesListGetNode(pLeftProjs, index)) || isDistinctSubQuery(pSetOp->pLeft)) {
    return false;
  }

  SNodeList* pRightProjs = getChildProjection(pSetOp->pRight);
-  if (!isUselessCol((SExprNode*)nodesListGetNode(pRightProjs, index))) {
+  if (!isUselessCol((SExprNode*)nodesListGetNode(pRightProjs, index)) || isDistinctSubQuery(pSetOp->pLeft)) {
    return false;
  }

--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@ -884,6 +884,10 @@ static int32_t findAndSetColumn(STranslateContext* pCxt, SColumnNode** pColRef,
  if (QUERY_NODE_REAL_TABLE == nodeType(pTable)) {
    const STableMeta* pMeta = ((SRealTableNode*)pTable)->pMeta;
    if (isInternalPrimaryKey(pCol)) {
+      if (TSDB_SYSTEM_TABLE == pMeta->tableType) {
+        return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_COLUMN, pCol->colName);
+      }
+
      setColumnInfoBySchema((SRealTableNode*)pTable, pMeta->schema, -1, pCol);
      *pFound = true;
      return TSDB_CODE_SUCCESS;
@ -1660,6 +1664,20 @@ static int32_t translateForbidStreamFunc(STranslateContext* pCxt, SFunctionNode*
  return TSDB_CODE_SUCCESS;
 }

+static int32_t translateForbidSysTableFunc(STranslateContext* pCxt, SFunctionNode* pFunc) {
+  if (!fmIsForbidSysTableFunc(pFunc->funcId)) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  SSelectStmt*   pSelect = (SSelectStmt*)pCxt->pCurrStmt;
+  SNode*          pTable = pSelect->pFromTable;
+  if (NULL != pTable && QUERY_NODE_REAL_TABLE == nodeType(pTable) &&
+      TSDB_SYSTEM_TABLE == ((SRealTableNode*)pTable)->pMeta->tableType) {
+    return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_SYSTABLE_NOT_ALLOWED_FUNC, pFunc->functionName);
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
 static int32_t translateRepeatScanFunc(STranslateContext* pCxt, SFunctionNode* pFunc) {
  if (!fmIsRepeatScanFunc(pFunc->funcId)) {
    return TSDB_CODE_SUCCESS;
@ -1891,6 +1909,9 @@ static int32_t translateNormalFunction(STranslateContext* pCxt, SFunctionNode* p
  if (TSDB_CODE_SUCCESS == code) {
    code = translateForbidStreamFunc(pCxt, pFunc);
  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = translateForbidSysTableFunc(pCxt, pFunc);
+  }
  if (TSDB_CODE_SUCCESS == code) {
    code = translateRepeatScanFunc(pCxt, pFunc);
  }
@ -2238,7 +2259,7 @@ static EDealRes doCheckExprForGroupBy(SNode** pNode, void* pContext) {
    }
  }
  if (isScanPseudoColumnFunc(*pNode) || QUERY_NODE_COLUMN == nodeType(*pNode)) {
-    if (pSelect->selectFuncNum > 1 || pSelect->hasOtherVectorFunc || !pSelect->hasSelectFunc) {
+    if (pSelect->selectFuncNum > 1 || pSelect->hasOtherVectorFunc || !pSelect->hasSelectFunc || (isDistinctOrderBy(pCxt) && pCxt->currClause == SQL_CLAUSE_ORDER_BY)) {
      return generateDealNodeErrMsg(pCxt, getGroupByErrorCode(pCxt), ((SExprNode*)(*pNode))->userAlias);
    } else {
      return rewriteColToSelectValFunc(pCxt, pNode);
@ -2648,7 +2669,7 @@ static int32_t replaceTbName(STranslateContext* pCxt, SSelectStmt* pSelect) {
  SNode** pNode = NULL;
  SRewriteTbNameContext pRewriteCxt = {0};
  pRewriteCxt.pTbName = pTable->table.tableName;
-  
+
  nodesRewriteExprPostOrder(&pSelect->pWhere, doTranslateTbName, &pRewriteCxt);

  return pRewriteCxt.errCode;
--- a/source/libs/parser/src/parUtil.c
+++ b/source/libs/parser/src/parUtil.c
@ -170,6 +170,8 @@ static char* getSyntaxErrFormat(int32_t errCode) {
      return "%s function is not supported in stream query";
    case TSDB_CODE_PAR_GROUP_BY_NOT_ALLOWED_FUNC:
      return "%s function is not supported in group query";
+    case TSDB_CODE_PAR_SYSTABLE_NOT_ALLOWED_FUNC:
+      return "%s function is not supported in system table query";
    case TSDB_CODE_PAR_INVALID_INTERP_CLAUSE:
      return "Invalid usage of RANGE clause, EVERY clause or FILL clause";
    case TSDB_CODE_PAR_NO_VALID_FUNC_IN_WIN:
--- a/source/libs/planner/src/planUtil.c
+++ b/source/libs/planner/src/planUtil.c
@ -51,6 +51,7 @@ static EDealRes doCreateColumn(SNode* pNode, void* pContext) {
      }
      return (TSDB_CODE_SUCCESS == nodesListAppend(pCxt->pList, pCol) ? DEAL_RES_IGNORE_CHILD : DEAL_RES_ERROR);
    }
+    case QUERY_NODE_VALUE:
    case QUERY_NODE_OPERATOR:
    case QUERY_NODE_LOGIC_CONDITION:
    case QUERY_NODE_FUNCTION:
@ -247,8 +248,7 @@ static int32_t adjustPartitionDataRequirement(SPartitionLogicNode* pPart, EDataO
    return TSDB_CODE_PLAN_INTERNAL_ERROR;
  }
  pPart->node.resultDataOrder = requirement;
-  pPart->node.requireDataOrder =
-      (requirement >= DATA_ORDER_LEVEL_IN_BLOCK ? DATA_ORDER_LEVEL_GLOBAL : DATA_ORDER_LEVEL_NONE);
+  pPart->node.requireDataOrder = requirement;
  return TSDB_CODE_SUCCESS;
 }

--- a/source/libs/stream/CMakeLists.txt
+++ b/source/libs/stream/CMakeLists.txt
@ -8,26 +8,43 @@ target_include_directories(


 if(${BUILD_WITH_ROCKSDB})
-  IF (TD_LINUX)
-  target_link_libraries(
-    stream
-    PUBLIC rocksdb tdb
-    PRIVATE  os util transport qcom executor wal index
-  )
-  ELSE() 
-  target_link_libraries(
-    stream
-    PUBLIC rocksdb tdb
-    PRIVATE  os util transport qcom executor wal index
-  )
-
-  ENDIF()
-
-  target_include_directories(
-    stream
-    PUBLIC "${TD_SOURCE_DIR}/contrib/rocksdb/include"
-  )
-
+  if (${BUILD_CONTRIB})
+    target_link_libraries(
+      stream
+      PUBLIC rocksdb tdb
+      PRIVATE  os util transport qcom executor wal index
+    )
+    target_include_directories(
+      stream
+      PUBLIC "${TD_SOURCE_DIR}/contrib/rocksdb/include"
+    )
+  else()
+    if (TD_LINUX)
+      target_include_directories(
+      stream
+      PUBLIC "${TD_SOURCE_DIR}/deps/${TD_DEPS_DIR}/rocksdb_static"
+    )
+    target_link_directories(
+      stream 
+      PUBLIC "${TD_SOURCE_DIR}/deps/${TD_DEPS_DIR}/rocksdb_static"
+    )
+    target_link_libraries(
+      stream
+      PUBLIC rocksdb tdb
+      PRIVATE  os util transport qcom executor wal index
+    )
+    else() 
+      target_link_libraries(
+        stream
+        PUBLIC rocksdb tdb
+        PRIVATE  os util transport qcom executor wal index
+      )
+      target_include_directories(
+        stream
+        PUBLIC "${TD_SOURCE_DIR}/contrib/rocksdb/include"
+      )
+    endif()
+  endif() 
  add_definitions(-DUSE_ROCKSDB)
 endif(${BUILD_WITH_ROCKSDB})

--- a/source/libs/sync/src/syncMain.c
+++ b/source/libs/sync/src/syncMain.c
@ -37,7 +37,6 @@
 #include "syncVoteMgr.h"
 #include "tglobal.h"
 #include "tref.h"
-#include "syncUtil.h"

 static void    syncNodeEqPingTimer(void* param, void* tmrId);
 static void    syncNodeEqElectTimer(void* param, void* tmrId);
@ -141,10 +140,10 @@ int32_t syncReconfig(int64_t rid, SSyncCfg* pNewCfg) {
  SSyncNode* pSyncNode = syncNodeAcquire(rid);
  if (pSyncNode == NULL) return -1;

-  if(pSyncNode->raftCfg.lastConfigIndex >= pNewCfg->lastIndex){
+  if (pSyncNode->raftCfg.lastConfigIndex >= pNewCfg->lastIndex) {
    syncNodeRelease(pSyncNode);
    sInfo("vgId:%d, no need Reconfig, current index:%" PRId64 ", new index:%" PRId64, pSyncNode->vgId,
-                                        pSyncNode->raftCfg.lastConfigIndex, pNewCfg->lastIndex);
+          pSyncNode->raftCfg.lastConfigIndex, pNewCfg->lastIndex);
    return 0;
  }

@ -323,8 +322,8 @@ int32_t syncBeginSnapshot(int64_t rid, int64_t lastApplyIndex) {
  }

  if (pSyncNode->totalReplicaNum > 1) {
-    if (pSyncNode->state != TAOS_SYNC_STATE_LEADER && pSyncNode->state != TAOS_SYNC_STATE_FOLLOWER 
-        && pSyncNode->state != TAOS_SYNC_STATE_LEARNER) {
+    if (pSyncNode->state != TAOS_SYNC_STATE_LEADER && pSyncNode->state != TAOS_SYNC_STATE_FOLLOWER &&
+        pSyncNode->state != TAOS_SYNC_STATE_LEARNER) {
      sNTrace(pSyncNode, "new-snapshot-index:%" PRId64 " candidate or unknown state, do not delete wal",
              lastApplyIndex);
      syncNodeRelease(pSyncNode);
@ -544,7 +543,7 @@ void syncGetRetryEpSet(int64_t rid, SEpSet* pEpSet) {
  if (pSyncNode == NULL) return;

  for (int32_t i = 0; i < pSyncNode->raftCfg.cfg.totalReplicaNum; ++i) {
-    if(pSyncNode->raftCfg.cfg.nodeInfo[i].nodeRole == TAOS_SYNC_ROLE_LEARNER) continue;
+    if (pSyncNode->raftCfg.cfg.nodeInfo[i].nodeRole == TAOS_SYNC_ROLE_LEARNER) continue;
    SEp* pEp = &pEpSet->eps[i];
    tstrncpy(pEp->fqdn, pSyncNode->raftCfg.cfg.nodeInfo[i].nodeFqdn, TSDB_FQDN_LEN);
    pEp->port = (pSyncNode->raftCfg.cfg.nodeInfo)[i].nodePort;
@ -579,21 +578,19 @@ int32_t syncIsCatchUp(int64_t rid) {
  }

  int32_t isCatchUp = 0;
-  if(pSyncNode->pLogBuf->totalIndex < 0 || pSyncNode->pLogBuf->commitIndex < 0 ||
+  if (pSyncNode->pLogBuf->totalIndex < 0 || pSyncNode->pLogBuf->commitIndex < 0 ||
      pSyncNode->pLogBuf->totalIndex < pSyncNode->pLogBuf->commitIndex ||
-      pSyncNode->pLogBuf->totalIndex - pSyncNode->pLogBuf->commitIndex > SYNC_LEARNER_CATCHUP){
-    sInfo("vgId:%d, Not catch up, wait one second, totalIndex:%" PRId64 " commitIndex:%" PRId64 " matchIndex:%" PRId64, 
-                                  pSyncNode->vgId, pSyncNode->pLogBuf->totalIndex, pSyncNode->pLogBuf->commitIndex, 
-                                  pSyncNode->pLogBuf->matchIndex);
+      pSyncNode->pLogBuf->totalIndex - pSyncNode->pLogBuf->commitIndex > SYNC_LEARNER_CATCHUP) {
+    sInfo("vgId:%d, Not catch up, wait one second, totalIndex:%" PRId64 " commitIndex:%" PRId64 " matchIndex:%" PRId64,
+          pSyncNode->vgId, pSyncNode->pLogBuf->totalIndex, pSyncNode->pLogBuf->commitIndex,
+          pSyncNode->pLogBuf->matchIndex);
    isCatchUp = 0;
-  }
-  else{
-    sInfo("vgId:%d, Catch up, totalIndex:%" PRId64 " commitIndex:%" PRId64 " matchIndex:%" PRId64, 
-                                  pSyncNode->vgId, pSyncNode->pLogBuf->totalIndex, pSyncNode->pLogBuf->commitIndex,
-                                  pSyncNode->pLogBuf->matchIndex);
+  } else {
+    sInfo("vgId:%d, Catch up, totalIndex:%" PRId64 " commitIndex:%" PRId64 " matchIndex:%" PRId64, pSyncNode->vgId,
+          pSyncNode->pLogBuf->totalIndex, pSyncNode->pLogBuf->commitIndex, pSyncNode->pLogBuf->matchIndex);
    isCatchUp = 1;
  }
-  
+
  syncNodeRelease(pSyncNode);
  return isCatchUp;
 }
@ -606,7 +603,7 @@ ESyncRole syncGetRole(int64_t rid) {
  }

  ESyncRole role = pSyncNode->raftCfg.cfg.nodeInfo[pSyncNode->raftCfg.cfg.myIndex].nodeRole;
-  
+
  syncNodeRelease(pSyncNode);
  return role;
 }
@ -802,8 +799,8 @@ SSyncNode* syncNodeOpen(SSyncInfo* pSyncInfo) {
  pSyncNode->vgId = pSyncInfo->vgId;
  SSyncCfg* pCfg = &pSyncNode->raftCfg.cfg;
  bool      updated = false;
-  sInfo("vgId:%d, start to open sync node, totalReplicaNum:%d replicaNum:%d selfIndex:%d", 
-                          pSyncNode->vgId, pCfg->totalReplicaNum, pCfg->replicaNum, pCfg->myIndex);
+  sInfo("vgId:%d, start to open sync node, totalReplicaNum:%d replicaNum:%d selfIndex:%d", pSyncNode->vgId,
+        pCfg->totalReplicaNum, pCfg->replicaNum, pCfg->myIndex);
  for (int32_t i = 0; i < pCfg->totalReplicaNum; ++i) {
    SNodeInfo* pNode = &pCfg->nodeInfo[i];
    if (tmsgUpdateDnodeInfo(&pNode->nodeId, &pNode->clusterId, pNode->nodeFqdn, &pNode->nodePort)) {
@ -1110,10 +1107,9 @@ int32_t syncNodeRestore(SSyncNode* pSyncNode) {

 int32_t syncNodeStart(SSyncNode* pSyncNode) {
  // start raft
-  if(pSyncNode->raftCfg.cfg.nodeInfo[pSyncNode->raftCfg.cfg.myIndex].nodeRole == TAOS_SYNC_ROLE_LEARNER){
+  if (pSyncNode->raftCfg.cfg.nodeInfo[pSyncNode->raftCfg.cfg.myIndex].nodeRole == TAOS_SYNC_ROLE_LEARNER) {
    syncNodeBecomeLearner(pSyncNode, "first start");
-  }
-  else{
+  } else {
    if (pSyncNode->replicaNum == 1) {
      raftStoreNextTerm(pSyncNode);
      syncNodeBecomeLeader(pSyncNode, "one replica start");
@ -1122,7 +1118,7 @@ int32_t syncNodeStart(SSyncNode* pSyncNode) {
      syncNodeAppendNoop(pSyncNode);
    } else {
      syncNodeBecomeFollower(pSyncNode, "first start");
-    }    
+    }
  }

  int32_t ret = 0;
@ -1438,7 +1434,7 @@ static bool syncIsConfigChanged(const SSyncCfg* pOldCfg, const SSyncCfg* pNewCfg
    const SNodeInfo* pNewInfo = &pNewCfg->nodeInfo[i];
    if (strcmp(pOldInfo->nodeFqdn, pNewInfo->nodeFqdn) != 0) return true;
    if (pOldInfo->nodePort != pNewInfo->nodePort) return true;
-    if(pOldInfo->nodeRole != pNewInfo->nodeRole) return true;
+    if (pOldInfo->nodeRole != pNewInfo->nodeRole) return true;
  }

  return false;
@ -1475,10 +1471,9 @@ void syncNodeDoConfigChange(SSyncNode* pSyncNode, SSyncCfg* pNewConfig, SyncInde
  }

  // log begin config change
-  sNInfo(pSyncNode, "begin do config change, from %d to %d, from %" PRId64 " to %" PRId64 ", replicas:%d", 
-                                          pSyncNode->vgId, 
-                                          oldConfig.totalReplicaNum, pNewConfig->totalReplicaNum, 
-                                          oldConfig.lastIndex, pNewConfig->lastIndex);
+  sNInfo(pSyncNode, "begin do config change, from %d to %d, from %" PRId64 " to %" PRId64 ", replicas:%d",
+         pSyncNode->vgId, oldConfig.totalReplicaNum, pNewConfig->totalReplicaNum, oldConfig.lastIndex,
+         pNewConfig->lastIndex);

  if (IamInNew) {
    pSyncNode->raftCfg.isStandBy = 0;  // change isStandBy to normal
@ -2234,7 +2229,10 @@ static void syncNodeEqPeerHeartbeatTimer(void* param, void* tmrId) {
  syncNodeRelease(pSyncNode);
 }

-static void deleteCacheEntry(const void* key, size_t keyLen, void* value) { taosMemoryFree(value); }
+static void deleteCacheEntry(const void* key, size_t keyLen, void* value, void* ud) {
+  (void)ud;
+  taosMemoryFree(value);
+}

 int32_t syncCacheEntry(SSyncLogStore* pLogStore, SSyncRaftEntry* pEntry, LRUHandle** h) {
  SSyncLogStoreData* pData = pLogStore->data;
@ -2243,7 +2241,7 @@ int32_t syncCacheEntry(SSyncLogStore* pLogStore, SSyncRaftEntry* pEntry, LRUHand
  int32_t   code = 0;
  int32_t   entryLen = sizeof(*pEntry) + pEntry->dataLen;
  LRUStatus status = taosLRUCacheInsert(pLogStore->pCache, &pEntry->index, sizeof(pEntry->index), pEntry, entryLen,
-                                        deleteCacheEntry, h, TAOS_LRU_PRIORITY_LOW);
+                                        deleteCacheEntry, h, TAOS_LRU_PRIORITY_LOW, NULL);
  if (status != TAOS_LRU_STATUS_OK) {
    code = -1;
  }
@ -2409,11 +2407,10 @@ int32_t syncNodeOnHeartbeat(SSyncNode* ths, const SRpcMsg* pRpcMsg) {
  pMsgReply->startTime = ths->startTime;
  pMsgReply->timeStamp = tsMs;

-  sTrace(
-        "vgId:%d, heartbeat msg from dnode:%d, cluster:%d, Msgterm:%" PRId64 " currentTerm:%" PRId64,
-        ths->vgId, DID(&(pMsg->srcId)), CID(&(pMsg->srcId)), pMsg->term, currentTerm);
+  sTrace("vgId:%d, heartbeat msg from dnode:%d, cluster:%d, Msgterm:%" PRId64 " currentTerm:%" PRId64, ths->vgId,
+         DID(&(pMsg->srcId)), CID(&(pMsg->srcId)), pMsg->term, currentTerm);

-  if(pMsg->term > currentTerm && ths->state == TAOS_SYNC_STATE_LEARNER){
+  if (pMsg->term > currentTerm && ths->state == TAOS_SYNC_STATE_LEARNER) {
    raftStoreSetTerm(ths, pMsg->term);
    currentTerm = pMsg->term;
  }
--- a/source/libs/wal/src/walRef.c
+++ b/source/libs/wal/src/walRef.c
@ -80,27 +80,3 @@ void walRefLastVer(SWal *pWal, SWalRef *pRef) {
  taosThreadMutexUnlock(&pWal->mutex);
  wDebug("vgId:%d, wal ref version %" PRId64 " for last", pWal->cfg.vgId, ver);
 }
-
-SWalRef *walRefCommittedVer(SWal *pWal) {
-  SWalRef *pRef = walOpenRef(pWal);
-  if (pRef == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
-  }
-  taosThreadMutexLock(&pWal->mutex);
-
-  int64_t ver = walGetCommittedVer(pWal);
-
-  wDebug("vgId:%d, wal ref version %" PRId64 " for committed", pWal->cfg.vgId, ver);
-
-  pRef->refVer = ver;
-  // bsearch in fileSet
-  SWalFileInfo tmpInfo;
-  tmpInfo.firstVer = ver;
-  SWalFileInfo *pRet = taosArraySearch(pWal->fileInfoSet, &tmpInfo, compareWalFileInfo, TD_LE);
-  ASSERT(pRet != NULL);
-  //  pRef->refFile = pRet->firstVer;
-
-  taosThreadMutexUnlock(&pWal->mutex);
-  return pRef;
-}
--- a/source/util/src/tarray.c
+++ b/source/util/src/tarray.c
@ -476,13 +476,13 @@ int32_t taosEncodeArray(void** buf, const SArray* pArray, FEncode encode) {
  return tlen;
 }

-void* taosDecodeArray(const void* buf, SArray** pArray, FDecode decode, int32_t dataSz) {
+void* taosDecodeArray(const void* buf, SArray** pArray, FDecode decode, int32_t dataSz, int8_t sver) {
  int32_t sz;
  buf = taosDecodeFixedI32(buf, &sz);
  *pArray = taosArrayInit(sz, sizeof(void*));
  for (int32_t i = 0; i < sz; i++) {
    void* data = taosMemoryCalloc(1, dataSz);
-    buf = decode(buf, data);
+    buf = decode(buf, data, sver);
    taosArrayPush(*pArray, &data);
  }
  return (void*)buf;
--- a/source/util/src/terror.c
+++ b/source/util/src/terror.c
@ -554,7 +554,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_COL_JSON,           "Only tag can be jso
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_VALUE_TOO_LONG,             "Value too long for column/tag")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_DELETE_WHERE,       "The DELETE statement must have a definite time window range")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_REDISTRIBUTE_VG,    "The REDISTRIBUTE VGROUP statement only support 1 to 3 dnodes")
-TAOS_DEFINE_ERROR(TSDB_CODE_PAR_FILL_NOT_ALLOWED_FUNC,      "Fill now allowed")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_FILL_NOT_ALLOWED_FUNC,      "Fill not allowed")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_WINDOW_PC,          "Invalid windows pc")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_WINDOW_NOT_ALLOWED_FUNC,    "Window not allowed")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_STREAM_NOT_ALLOWED_FUNC,    "Stream not allowed")
@ -566,6 +566,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_SMA_INDEX,          "Invalid sma index")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_SELECTED_EXPR,      "Invalid SELECTed expression")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_GET_META_ERROR,             "Fail to get table info")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_NOT_UNIQUE_TABLE_ALIAS,     "Not unique table/alias")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_SYSTABLE_NOT_ALLOWED_FUNC,  "System table not allowed")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INTERNAL_ERROR,             "Parser internal error")

 //planner
--- a/source/util/src/tlrucache.c
+++ b/source/util/src/tlrucache.c
@ -39,6 +39,7 @@ enum {
 struct SLRUEntry {
  void               *value;
  _taos_lru_deleter_t deleter;
+  void               *ud;
  SLRUEntry          *nextHash;
  SLRUEntry          *next;
  SLRUEntry          *prev;
@ -94,7 +95,7 @@ static void taosLRUEntryFree(SLRUEntry *entry) {
  ASSERT(entry->refs == 0);

  if (entry->deleter) {
-    (*entry->deleter)(entry->keyData, entry->keyLength, entry->value);
+    (*entry->deleter)(entry->keyData, entry->keyLength, entry->value, entry->ud);
  }

  taosMemoryFree(entry);
@ -146,6 +147,25 @@ static void taosLRUEntryTableCleanup(SLRUEntryTable *table) {
  taosMemoryFree(table->list);
 }

+static int taosLRUEntryTableApplyF(SLRUEntryTable *table, _taos_lru_functor_t functor, void *ud) {
+  int      ret = 0;
+  uint32_t end = 1 << table->lengthBits;
+  for (uint32_t i = 0; i < end; ++i) {
+    SLRUEntry *h = table->list[i];
+    while (h) {
+      SLRUEntry *n = h->nextHash;
+      ASSERT(TAOS_LRU_ENTRY_IN_CACHE(h));
+      ret = functor(h->keyData, h->keyLength, h->value, ud);
+      if (ret) {
+        return ret;
+      }
+      h = n;
+    }
+  }
+
+  return ret;
+}
+
 static SLRUEntry **taosLRUEntryTableFindPtr(SLRUEntryTable *table, const void *key, size_t keyLen, uint32_t hash) {
  SLRUEntry **entry = &table->list[hash >> (32 - table->lengthBits)];
  while (*entry && ((*entry)->hash != hash || memcmp(key, (*entry)->keyData, keyLen) != 0)) {
@ -424,7 +444,7 @@ static LRUStatus taosLRUCacheShardInsertEntry(SLRUCacheShard *shard, SLRUEntry *

 static LRUStatus taosLRUCacheShardInsert(SLRUCacheShard *shard, const void *key, size_t keyLen, uint32_t hash,
                                         void *value, size_t charge, _taos_lru_deleter_t deleter, LRUHandle **handle,
-                                         LRUPriority priority) {
+                                         LRUPriority priority, void *ud) {
  SLRUEntry *e = taosMemoryCalloc(1, sizeof(SLRUEntry) - 1 + keyLen);
  if (!e) {
    return TAOS_LRU_STATUS_FAIL;
@ -433,6 +453,7 @@ static LRUStatus taosLRUCacheShardInsert(SLRUCacheShard *shard, const void *key,
  e->value = value;
  e->flags = 0;
  e->deleter = deleter;
+  e->ud = ud;
  e->keyLength = keyLen;
  e->hash = hash;
  e->refs = 0;
@ -490,6 +511,18 @@ static void taosLRUCacheShardErase(SLRUCacheShard *shard, const void *key, size_
  }
 }

+static int taosLRUCacheShardApply(SLRUCacheShard *shard, _taos_lru_functor_t functor, void *ud) {
+  int ret;
+
+  taosThreadMutexLock(&shard->mutex);
+
+  ret = taosLRUEntryTableApplyF(&shard->table, functor, ud);
+
+  taosThreadMutexUnlock(&shard->mutex);
+
+  return ret;
+}
+
 static void taosLRUCacheShardEraseUnrefEntries(SLRUCacheShard *shard) {
  SArray *lastReferenceList = taosArrayInit(16, POINTER_BYTES);

@ -700,12 +733,12 @@ void taosLRUCacheCleanup(SLRUCache *cache) {
 }

 LRUStatus taosLRUCacheInsert(SLRUCache *cache, const void *key, size_t keyLen, void *value, size_t charge,
-                             _taos_lru_deleter_t deleter, LRUHandle **handle, LRUPriority priority) {
+                             _taos_lru_deleter_t deleter, LRUHandle **handle, LRUPriority priority, void *ud) {
  uint32_t hash = TAOS_LRU_CACHE_SHARD_HASH32(key, keyLen);
  uint32_t shardIndex = hash & cache->shardedCache.shardMask;

  return taosLRUCacheShardInsert(&cache->shards[shardIndex], key, keyLen, hash, value, charge, deleter, handle,
-                                 priority);
+                                 priority, ud);
 }

 LRUHandle *taosLRUCacheLookup(SLRUCache *cache, const void *key, size_t keyLen) {
@ -722,6 +755,15 @@ void taosLRUCacheErase(SLRUCache *cache, const void *key, size_t keyLen) {
  return taosLRUCacheShardErase(&cache->shards[shardIndex], key, keyLen, hash);
 }

+void taosLRUCacheApply(SLRUCache *cache, _taos_lru_functor_t functor, void *ud) {
+  int numShards = cache->numShards;
+  for (int i = 0; i < numShards; ++i) {
+    if (taosLRUCacheShardApply(&cache->shards[i], functor, ud)) {
+      break;
+    }
+  }
+}
+
 void taosLRUCacheEraseUnrefEntries(SLRUCache *cache) {
  int numShards = cache->numShards;
  for (int i = 0; i < numShards; ++i) {
--- a/tests/develop-test/win-test-file
+++ b/tests/develop-test/win-test-file
@ -9,5 +9,6 @@ python3 ./test.py -f 5-taos-tools/taosbenchmark/invalid_commandline.py
 python3 ./test.py -f 5-taos-tools/taosbenchmark/json_tag.py
 python3 ./test.py -f 5-taos-tools/taosbenchmark/query_json.py
 python3 ./test.py -f 5-taos-tools/taosbenchmark/sample_csv_json.py
+python3 ./test.py -f 5-taos-tools/taosbenchmark/sml_json_alltypes.py
 python3 ./test.py -f 5-taos-tools/taosbenchmark/taosdemoTestQueryWithJson.py -R
 python3 ./test.py -f 5-taos-tools/taosbenchmark/telnet_tcp.py -R
--- a/tests/parallel_test/cases.task
+++ b/tests/parallel_test/cases.task
@ -5,423 +5,6 @@
 #unit-test
 ,,y,unit-test,bash test.sh

-#tsim test
-,,y,script,./test.sh -f tsim/user/basic.sim
-,,y,script,./test.sh -f tsim/user/password.sim
-,,y,script,./test.sh -f tsim/user/privilege_db.sim
-,,y,script,./test.sh -f tsim/user/privilege_sysinfo.sim
-,,y,script,./test.sh -f tsim/user/privilege_topic.sim
-,,y,script,./test.sh -f tsim/db/alter_option.sim
-,,y,script,./test.sh -f tsim/db/alter_replica_13.sim
-,,y,script,./test.sh -f tsim/db/alter_replica_31.sim
-,,y,script,./test.sh -f tsim/db/basic1.sim
-,,y,script,./test.sh -f tsim/db/basic2.sim
-,,y,script,./test.sh -f tsim/db/basic3.sim
-,,y,script,./test.sh -f tsim/db/basic4.sim
-,,y,script,./test.sh -f tsim/db/basic5.sim
-,,y,script,./test.sh -f tsim/db/basic6.sim
-,,y,script,./test.sh -f tsim/db/commit.sim
-,,y,script,./test.sh -f tsim/db/create_all_options.sim
-,,y,script,./test.sh -f tsim/db/delete_reuse1.sim
-,,y,script,./test.sh -f tsim/db/delete_reuse2.sim
-,,y,script,./test.sh -f tsim/db/delete_reusevnode.sim
-,,y,script,./test.sh -f tsim/db/delete_reusevnode2.sim
-,,y,script,./test.sh -f tsim/db/delete_writing1.sim
-,,y,script,./test.sh -f tsim/db/delete_writing2.sim
-,,y,script,./test.sh -f tsim/db/error1.sim
-,,y,script,./test.sh -f tsim/db/keep.sim
-,,y,script,./test.sh -f tsim/db/len.sim
-,,y,script,./test.sh -f tsim/db/repeat.sim
-,,y,script,./test.sh -f tsim/db/show_create_db.sim
-,,y,script,./test.sh -f tsim/db/show_create_table.sim
-,,y,script,./test.sh -f tsim/db/tables.sim
-,,y,script,./test.sh -f tsim/db/taosdlog.sim
-,,y,script,./test.sh -f tsim/dnode/balance_replica1.sim
-,,y,script,./test.sh -f tsim/dnode/balance_replica3.sim
-,,y,script,./test.sh -f tsim/dnode/balance1.sim
-,,y,script,./test.sh -f tsim/dnode/balance2.sim
-,,y,script,./test.sh -f tsim/dnode/balance3.sim
-,,y,script,./test.sh -f tsim/dnode/balancex.sim
-,,y,script,./test.sh -f tsim/dnode/create_dnode.sim
-,,y,script,./test.sh -f tsim/dnode/drop_dnode_has_mnode.sim
-,,y,script,./test.sh -f tsim/dnode/drop_dnode_has_qnode_snode.sim
-,,y,script,./test.sh -f tsim/dnode/drop_dnode_has_vnode_replica1.sim
-,,y,script,./test.sh -f tsim/dnode/drop_dnode_has_vnode_replica3.sim
-,,y,script,./test.sh -f tsim/dnode/drop_dnode_has_multi_vnode_replica1.sim
-,,y,script,./test.sh -f tsim/dnode/drop_dnode_has_multi_vnode_replica3.sim
-,,y,script,./test.sh -f tsim/dnode/drop_dnode_force.sim
-,,y,script,./test.sh -f tsim/dnode/offline_reason.sim
-,,y,script,./test.sh -f tsim/dnode/redistribute_vgroup_replica1.sim
-,,y,script,./test.sh -f tsim/dnode/redistribute_vgroup_replica3_v1_leader.sim
-,,y,script,./test.sh -f tsim/dnode/redistribute_vgroup_replica3_v1_follower.sim
-,,y,script,./test.sh -f tsim/dnode/redistribute_vgroup_replica3_v2.sim
-,,y,script,./test.sh -f tsim/dnode/redistribute_vgroup_replica3_v3.sim
-,,y,script,./test.sh -f tsim/dnode/vnode_clean.sim
-,,y,script,./test.sh -f tsim/dnode/use_dropped_dnode.sim
-,,y,script,./test.sh -f tsim/dnode/split_vgroup_replica1.sim
-,,y,script,./test.sh -f tsim/dnode/split_vgroup_replica3.sim
-,,y,script,./test.sh -f tsim/import/basic.sim
-,,y,script,./test.sh -f tsim/import/commit.sim
-,,y,script,./test.sh -f tsim/import/large.sim
-,,y,script,./test.sh -f tsim/import/replica1.sim
-,,y,script,./test.sh -f tsim/insert/backquote.sim
-,,y,script,./test.sh -f tsim/insert/basic.sim
-,,y,script,./test.sh -f tsim/insert/basic0.sim
-,,y,script,./test.sh -f tsim/insert/basic1.sim
-,,y,script,./test.sh -f tsim/insert/basic2.sim
-,,y,script,./test.sh -f tsim/insert/commit-merge0.sim
-,,y,script,./test.sh -f tsim/insert/insert_drop.sim
-,,y,script,./test.sh -f tsim/insert/insert_select.sim
-,,y,script,./test.sh -f tsim/insert/null.sim
-,,y,script,./test.sh -f tsim/insert/query_block1_file.sim
-,,y,script,./test.sh -f tsim/insert/query_block1_memory.sim
-,,y,script,./test.sh -f tsim/insert/query_block2_file.sim
-,,y,script,./test.sh -f tsim/insert/query_block2_memory.sim
-,,y,script,./test.sh -f tsim/insert/query_file_memory.sim
-,,y,script,./test.sh -f tsim/insert/query_multi_file.sim
-,,y,script,./test.sh -f tsim/insert/tcp.sim
-,,y,script,./test.sh -f tsim/insert/update0.sim
-,,y,script,./test.sh -f tsim/insert/update1_sort_merge.sim
-,,y,script,./test.sh -f tsim/insert/update2.sim
-,,y,script,./test.sh -f tsim/parser/alter__for_community_version.sim
-,,y,script,./test.sh -f tsim/parser/alter_column.sim
-,,y,script,./test.sh -f tsim/parser/alter_stable.sim
-,,y,script,./test.sh -f tsim/parser/alter.sim
-,,y,script,./test.sh -f tsim/parser/alter1.sim
-,,y,script,./test.sh -f tsim/parser/auto_create_tb_drop_tb.sim
-,,y,script,./test.sh -f tsim/parser/auto_create_tb.sim
-,,y,script,./test.sh -f tsim/parser/between_and.sim
-,,y,script,./test.sh -f tsim/parser/binary_escapeCharacter.sim
-,,y,script,./test.sh -f tsim/parser/col_arithmetic_operation.sim
-,,y,script,./test.sh -f tsim/parser/columnValue_bigint.sim
-,,y,script,./test.sh -f tsim/parser/columnValue_bool.sim
-,,y,script,./test.sh -f tsim/parser/columnValue_double.sim
-,,y,script,./test.sh -f tsim/parser/columnValue_float.sim
-,,y,script,./test.sh -f tsim/parser/columnValue_int.sim
-,,y,script,./test.sh -f tsim/parser/columnValue_smallint.sim
-,,y,script,./test.sh -f tsim/parser/columnValue_tinyint.sim
-,,y,script,./test.sh -f tsim/parser/columnValue_unsign.sim
-,,y,script,./test.sh -f tsim/parser/commit.sim
-,,y,script,./test.sh -f tsim/parser/condition.sim
-,,y,script,./test.sh -f tsim/parser/constCol.sim
-,,y,script,./test.sh -f tsim/parser/create_db.sim
-,,y,script,./test.sh -f tsim/parser/create_mt.sim
-,,y,script,./test.sh -f tsim/parser/create_tb_with_tag_name.sim
-,,y,script,./test.sh -f tsim/parser/create_tb.sim
-,,y,script,./test.sh -f tsim/parser/dbtbnameValidate.sim
-,,y,script,./test.sh -f tsim/parser/distinct.sim
-,,y,script,./test.sh -f tsim/parser/fill_us.sim
-,,y,script,./test.sh -f tsim/parser/fill.sim
-,,y,script,./test.sh -f tsim/parser/first_last.sim
-,,y,script,./test.sh -f tsim/parser/fill_stb.sim
-,,y,script,./test.sh -f tsim/parser/interp.sim
-,,y,script,./test.sh -f tsim/parser/fourArithmetic-basic.sim
-,,y,script,./test.sh -f tsim/parser/function.sim
-,,y,script,./test.sh -f tsim/parser/groupby-basic.sim
-,,y,script,./test.sh -f tsim/parser/groupby.sim
-,,y,script,./test.sh -f tsim/parser/having_child.sim
-,,y,script,./test.sh -f tsim/parser/having.sim
-,,y,script,./test.sh -f tsim/parser/import_commit1.sim
-,,y,script,./test.sh -f tsim/parser/import_commit2.sim
-,,y,script,./test.sh -f tsim/parser/import_commit3.sim
-,,y,script,./test.sh -f tsim/parser/import_file.sim
-,,y,script,./test.sh -f tsim/parser/import.sim
-,,y,script,./test.sh -f tsim/parser/insert_multiTbl.sim
-,,y,script,./test.sh -f tsim/parser/insert_tb.sim
-,,y,script,./test.sh -f tsim/parser/join_manyblocks.sim
-,,y,script,./test.sh -f tsim/parser/join_multitables.sim
-,,y,script,./test.sh -f tsim/parser/join_multivnode.sim
-,,y,script,./test.sh -f tsim/parser/join.sim
-,,y,script,./test.sh -f tsim/parser/last_cache.sim
-,,y,script,./test.sh -f tsim/parser/last_groupby.sim
-,,y,script,./test.sh -f tsim/parser/lastrow.sim
-,,y,script,./test.sh -f tsim/parser/lastrow2.sim
-,,y,script,./test.sh -f tsim/parser/like.sim
-,,y,script,./test.sh -f tsim/parser/limit.sim
-,,y,script,./test.sh -f tsim/parser/limit1.sim
-,,y,script,./test.sh -f tsim/parser/mixed_blocks.sim
-,,y,script,./test.sh -f tsim/parser/nchar.sim
-,,y,script,./test.sh -f tsim/parser/nestquery.sim
-,,y,script,./test.sh -f tsim/parser/null_char.sim
-,,y,script,./test.sh -f tsim/parser/precision_ns.sim
-,,y,script,./test.sh -f tsim/parser/projection_limit_offset.sim
-,,y,script,./test.sh -f tsim/parser/regex.sim
-,,y,script,./test.sh -f tsim/parser/regressiontest.sim
-,,y,script,./test.sh -f tsim/parser/select_across_vnodes.sim
-,,y,script,./test.sh -f tsim/parser/select_distinct_tag.sim
-,,y,script,./test.sh -f tsim/parser/select_from_cache_disk.sim
-,,y,script,./test.sh -f tsim/parser/select_with_tags.sim
-,,y,script,./test.sh -f tsim/parser/selectResNum.sim
-,,y,script,./test.sh -f tsim/parser/set_tag_vals.sim
-,,y,script,./test.sh -f tsim/parser/single_row_in_tb.sim
-,,y,script,./test.sh -f tsim/parser/sliding.sim
-,,y,script,./test.sh -f tsim/parser/slimit_alter_tags.sim
-,,y,script,./test.sh -f tsim/parser/slimit.sim
-,,y,script,./test.sh -f tsim/parser/slimit1.sim
-,,y,script,./test.sh -f tsim/parser/stableOp.sim
-,,y,script,./test.sh -f tsim/parser/tags_dynamically_specifiy.sim
-,,y,script,./test.sh -f tsim/parser/tags_filter.sim
-,,y,script,./test.sh -f tsim/parser/tbnameIn.sim
-,,y,script,./test.sh -f tsim/parser/timestamp.sim
-,,y,script,./test.sh -f tsim/parser/top_groupby.sim
-,,y,script,./test.sh -f tsim/parser/topbot.sim
-,,y,script,./test.sh -f tsim/parser/union.sim
-,,y,script,./test.sh -f tsim/parser/union_sysinfo.sim
-,,y,script,./test.sh -f tsim/parser/where.sim
-,,y,script,./test.sh -f tsim/query/tagLikeFilter.sim
-,,y,script,./test.sh -f tsim/query/charScalarFunction.sim
-,,y,script,./test.sh -f tsim/query/explain.sim
-,,y,script,./test.sh -f tsim/query/interval-offset.sim
-,,y,script,./test.sh -f tsim/query/interval.sim
-,,y,script,./test.sh -f tsim/query/scalarFunction.sim
-,,y,script,./test.sh -f tsim/query/scalarNull.sim
-,,y,script,./test.sh -f tsim/query/session.sim
-,,y,script,./test.sh -f tsim/query/udf.sim
-,,y,script,./test.sh -f tsim/query/udf_with_const.sim
-,,y,script,./test.sh -f tsim/query/sys_tbname.sim
-,,y,script,./test.sh -f tsim/query/groupby.sim
-,,y,script,./test.sh -f tsim/query/event.sim
-,,y,script,./test.sh -f tsim/query/forceFill.sim
-,,y,script,./test.sh -f tsim/query/emptyTsRange.sim
-,,y,script,./test.sh -f tsim/query/partitionby.sim
-,,y,script,./test.sh -f tsim/qnode/basic1.sim
-,,y,script,./test.sh -f tsim/snode/basic1.sim
-,,y,script,./test.sh -f tsim/mnode/basic1.sim
-,,y,script,./test.sh -f tsim/mnode/basic2.sim
-,,y,script,./test.sh -f tsim/mnode/basic3.sim
-,,y,script,./test.sh -f tsim/mnode/basic4.sim
-,,y,script,./test.sh -f tsim/mnode/basic5.sim
-,,y,script,./test.sh -f tsim/show/basic.sim
-,,y,script,./test.sh -f tsim/table/autocreate.sim
-,,y,script,./test.sh -f tsim/table/basic1.sim
-,,y,script,./test.sh -f tsim/table/basic2.sim
-,,y,script,./test.sh -f tsim/table/basic3.sim
-,,y,script,./test.sh -f tsim/table/bigint.sim
-,,y,script,./test.sh -f tsim/table/binary.sim
-,,y,script,./test.sh -f tsim/table/bool.sim
-,,y,script,./test.sh -f tsim/table/column_name.sim
-,,y,script,./test.sh -f tsim/table/column_num.sim
-,,y,script,./test.sh -f tsim/table/column_value.sim
-,,y,script,./test.sh -f tsim/table/column2.sim
-,,y,script,./test.sh -f tsim/table/createmulti.sim
-,,y,script,./test.sh -f tsim/table/date.sim
-,,y,script,./test.sh -f tsim/table/db.table.sim
-,,y,script,./test.sh -f tsim/table/delete_reuse1.sim
-,,y,script,./test.sh -f tsim/table/delete_reuse2.sim
-,,y,script,./test.sh -f tsim/table/delete_writing.sim
-,,y,script,./test.sh -f tsim/table/describe.sim
-,,y,script,./test.sh -f tsim/table/double.sim
-,,y,script,./test.sh -f tsim/table/float.sim
-,,y,script,./test.sh -f tsim/table/hash.sim
-,,y,script,./test.sh -f tsim/table/int.sim
-,,y,script,./test.sh -f tsim/table/limit.sim
-,,y,script,./test.sh -f tsim/table/smallint.sim
-,,y,script,./test.sh -f tsim/table/table_len.sim
-,,y,script,./test.sh -f tsim/table/table.sim
-,,y,script,./test.sh -f tsim/table/tinyint.sim
-,,y,script,./test.sh -f tsim/table/vgroup.sim
-,,n,script,./test.sh -f tsim/stream/basic0.sim -g
-,,y,script,./test.sh -f tsim/stream/basic1.sim
-,,y,script,./test.sh -f tsim/stream/basic2.sim
-,,y,script,./test.sh -f tsim/stream/basic3.sim
-,,y,script,./test.sh -f tsim/stream/basic4.sim
-,,y,script,./test.sh -f tsim/stream/checkStreamSTable1.sim
-,,y,script,./test.sh -f tsim/stream/checkStreamSTable.sim
-,,y,script,./test.sh -f tsim/stream/deleteInterval.sim
-,,y,script,./test.sh -f tsim/stream/deleteSession.sim
-,,y,script,./test.sh -f tsim/stream/deleteState.sim
-,,y,script,./test.sh -f tsim/stream/distributeInterval0.sim
-,,y,script,./test.sh -f tsim/stream/distributeIntervalRetrive0.sim
-,,y,script,./test.sh -f tsim/stream/distributeSession0.sim
-,,y,script,./test.sh -f tsim/stream/drop_stream.sim
-,,y,script,./test.sh -f tsim/stream/fillHistoryBasic1.sim
-,,y,script,./test.sh -f tsim/stream/fillHistoryBasic2.sim
-,,y,script,./test.sh -f tsim/stream/fillHistoryBasic3.sim
-,,y,script,./test.sh -f tsim/stream/fillIntervalDelete0.sim
-,,y,script,./test.sh -f tsim/stream/fillIntervalDelete1.sim
-,,y,script,./test.sh -f tsim/stream/fillIntervalLinear.sim
-,,y,script,./test.sh -f tsim/stream/fillIntervalPartitionBy.sim
-,,y,script,./test.sh -f tsim/stream/fillIntervalPrevNext1.sim
-,,y,script,./test.sh -f tsim/stream/fillIntervalPrevNext.sim
-,,y,script,./test.sh -f tsim/stream/fillIntervalRange.sim
-,,y,script,./test.sh -f tsim/stream/fillIntervalValue.sim
-,,y,script,./test.sh -f tsim/stream/ignoreCheckUpdate.sim
-,,y,script,./test.sh -f tsim/stream/ignoreExpiredData.sim
-,,y,script,./test.sh -f tsim/stream/partitionby1.sim
-,,y,script,./test.sh -f tsim/stream/partitionbyColumnInterval.sim
-,,y,script,./test.sh -f tsim/stream/partitionbyColumnSession.sim
-,,y,script,./test.sh -f tsim/stream/partitionbyColumnState.sim
-,,y,script,./test.sh -f tsim/stream/partitionby.sim
-,,y,script,./test.sh -f tsim/stream/pauseAndResume.sim
-,,y,script,./test.sh -f tsim/stream/schedSnode.sim
-,,y,script,./test.sh -f tsim/stream/session0.sim
-,,y,script,./test.sh -f tsim/stream/session1.sim
-,,y,script,./test.sh -f tsim/stream/sliding.sim
-,,y,script,./test.sh -f tsim/stream/state0.sim
-,,y,script,./test.sh -f tsim/stream/state1.sim
-,,y,script,./test.sh -f tsim/stream/triggerInterval0.sim
-,,y,script,./test.sh -f tsim/stream/triggerSession0.sim
-,,y,script,./test.sh -f tsim/stream/udTableAndTag0.sim
-,,y,script,./test.sh -f tsim/stream/udTableAndTag1.sim
-,,y,script,./test.sh -f tsim/stream/udTableAndTag2.sim
-,,y,script,./test.sh -f tsim/stream/windowClose.sim
-,,y,script,./test.sh -f tsim/trans/lossdata1.sim
-,,y,script,./test.sh -f tsim/trans/create_db.sim
-,,y,script,./test.sh -f tsim/tmq/basic1.sim
-,,y,script,./test.sh -f tsim/tmq/basic2.sim
-,,y,script,./test.sh -f tsim/tmq/basic3.sim
-,,y,script,./test.sh -f tsim/tmq/basic4.sim
-,,y,script,./test.sh -f tsim/tmq/basic1Of2Cons.sim
-,,y,script,./test.sh -f tsim/tmq/basic2Of2Cons.sim
-,,y,script,./test.sh -f tsim/tmq/basic3Of2Cons.sim
-,,y,script,./test.sh -f tsim/tmq/basic4Of2Cons.sim
-,,y,script,./test.sh -f tsim/tmq/basic2Of2ConsOverlap.sim
-,,y,script,./test.sh -f tsim/tmq/topic.sim
-,,y,script,./test.sh -f tsim/tmq/snapshot.sim
-,,y,script,./test.sh -f tsim/tmq/snapshot1.sim
-,,y,script,./test.sh -f tsim/stable/alter_comment.sim
-,,y,script,./test.sh -f tsim/stable/alter_count.sim
-,,y,script,./test.sh -f tsim/stable/alter_import.sim
-,,y,script,./test.sh -f tsim/stable/alter_insert1.sim
-,,y,script,./test.sh -f tsim/stable/alter_insert2.sim
-,,y,script,./test.sh -f tsim/stable/alter_metrics.sim
-,,y,script,./test.sh -f tsim/stable/column_add.sim
-,,y,script,./test.sh -f tsim/stable/column_drop.sim
-,,y,script,./test.sh -f tsim/stable/column_modify.sim
-,,y,script,./test.sh -f tsim/stable/disk.sim
-,,y,script,./test.sh -f tsim/stable/dnode3.sim
-,,y,script,./test.sh -f tsim/stable/metrics.sim
-,,y,script,./test.sh -f tsim/stable/refcount.sim
-,,y,script,./test.sh -f tsim/stable/tag_add.sim
-,,y,script,./test.sh -f tsim/stable/tag_drop.sim
-,,y,script,./test.sh -f tsim/stable/tag_filter.sim
-,,y,script,./test.sh -f tsim/stable/tag_modify.sim
-,,y,script,./test.sh -f tsim/stable/tag_rename.sim
-,,y,script,./test.sh -f tsim/stable/values.sim
-,,y,script,./test.sh -f tsim/stable/vnode3.sim
-,,y,script,./test.sh -f tsim/stable/metrics_idx.sim
-,,n,script,./test.sh -f tsim/sma/drop_sma.sim
-,,y,script,./test.sh -f tsim/sma/sma_leak.sim
-,,y,script,./test.sh -f tsim/sma/tsmaCreateInsertQuery.sim
-,,y,script,./test.sh -f tsim/sma/rsmaCreateInsertQuery.sim
-,,y,script,./test.sh -f tsim/sma/rsmaPersistenceRecovery.sim
-,,n,script,./test.sh -f tsim/valgrind/checkError1.sim
-,,n,script,./test.sh -f tsim/valgrind/checkError2.sim
-,,n,script,./test.sh -f tsim/valgrind/checkError3.sim
-,,n,script,./test.sh -f tsim/valgrind/checkError4.sim
-,,n,script,./test.sh -f tsim/valgrind/checkError5.sim
-,,n,script,./test.sh -f tsim/valgrind/checkError6.sim
-,,n,script,./test.sh -f tsim/valgrind/checkError7.sim
-,,n,script,./test.sh -f tsim/valgrind/checkError8.sim
-,,n,script,./test.sh -f tsim/valgrind/checkUdf.sim
-,,y,script,./test.sh -f tsim/vnode/replica3_basic.sim
-,,y,script,./test.sh -f tsim/vnode/replica3_repeat.sim
-,,y,script,./test.sh -f tsim/vnode/replica3_vgroup.sim
-,,y,script,./test.sh -f tsim/vnode/replica3_many.sim
-,,y,script,./test.sh -f tsim/vnode/replica3_import.sim
-,,y,script,./test.sh -f tsim/vnode/stable_balance_replica1.sim
-,,y,script,./test.sh -f tsim/vnode/stable_dnode2_stop.sim
-,,y,script,./test.sh -f tsim/vnode/stable_dnode2.sim
-,,y,script,./test.sh -f tsim/vnode/stable_dnode3.sim
-,,y,script,./test.sh -f tsim/vnode/stable_replica3_dnode6.sim
-,,y,script,./test.sh -f tsim/vnode/stable_replica3_vnode3.sim
-,,y,script,./test.sh -f tsim/sync/3Replica1VgElect.sim
-,,y,script,./test.sh -f tsim/sync/3Replica5VgElect.sim
-,,y,script,./test.sh -f tsim/sync/oneReplica1VgElect.sim
-,,y,script,./test.sh -f tsim/sync/oneReplica5VgElect.sim
-,,y,script,./test.sh -f tsim/catalog/alterInCurrent.sim
-,,y,script,./test.sh -f tsim/scalar/in.sim
-,,y,script,./test.sh -f tsim/scalar/scalar.sim
-,,y,script,./test.sh -f tsim/scalar/filter.sim
-,,y,script,./test.sh -f tsim/scalar/caseWhen.sim
-,,y,script,./test.sh -f tsim/scalar/tsConvert.sim
-,,y,script,./test.sh -f tsim/alter/cached_schema_after_alter.sim
-,,y,script,./test.sh -f tsim/alter/dnode.sim
-,,y,script,./test.sh -f tsim/alter/table.sim
-,,y,script,./test.sh -f tsim/cache/new_metrics.sim
-,,y,script,./test.sh -f tsim/cache/restart_table.sim
-,,y,script,./test.sh -f tsim/cache/restart_metrics.sim
-,,y,script,./test.sh -f tsim/column/commit.sim
-,,y,script,./test.sh -f tsim/column/metrics.sim
-,,y,script,./test.sh -f tsim/column/table.sim
-,,y,script,./test.sh -f tsim/compress/commitlog.sim
-,,y,script,./test.sh -f tsim/compress/compress2.sim
-,,y,script,./test.sh -f tsim/compress/compress.sim
-,,y,script,./test.sh -f tsim/compress/uncompress.sim
-,,y,script,./test.sh -f tsim/compute/avg.sim
-,,y,script,./test.sh -f tsim/compute/block_dist.sim
-,,y,script,./test.sh -f tsim/compute/bottom.sim
-,,y,script,./test.sh -f tsim/compute/count.sim
-,,y,script,./test.sh -f tsim/compute/diff.sim
-,,y,script,./test.sh -f tsim/compute/diff2.sim
-,,y,script,./test.sh -f tsim/compute/first.sim
-,,y,script,./test.sh -f tsim/compute/interval.sim
-,,y,script,./test.sh -f tsim/compute/last_row.sim
-,,y,script,./test.sh -f tsim/compute/last.sim
-,,y,script,./test.sh -f tsim/compute/leastsquare.sim
-,,y,script,./test.sh -f tsim/compute/max.sim
-,,y,script,./test.sh -f tsim/compute/min.sim
-,,y,script,./test.sh -f tsim/compute/null.sim
-,,y,script,./test.sh -f tsim/compute/percentile.sim
-,,y,script,./test.sh -f tsim/compute/stddev.sim
-,,y,script,./test.sh -f tsim/compute/sum.sim
-,,y,script,./test.sh -f tsim/compute/top.sim
-,,y,script,./test.sh -f tsim/field/2.sim
-,,y,script,./test.sh -f tsim/field/3.sim
-,,y,script,./test.sh -f tsim/field/4.sim
-,,y,script,./test.sh -f tsim/field/5.sim
-,,y,script,./test.sh -f tsim/field/6.sim
-,,y,script,./test.sh -f tsim/field/binary.sim
-,,y,script,./test.sh -f tsim/field/bigint.sim
-,,y,script,./test.sh -f tsim/field/bool.sim
-,,y,script,./test.sh -f tsim/field/double.sim
-,,y,script,./test.sh -f tsim/field/float.sim
-,,y,script,./test.sh -f tsim/field/int.sim
-,,y,script,./test.sh -f tsim/field/single.sim
-,,y,script,./test.sh -f tsim/field/smallint.sim
-,,y,script,./test.sh -f tsim/field/tinyint.sim
-,,y,script,./test.sh -f tsim/field/unsigined_bigint.sim
-,,y,script,./test.sh -f tsim/vector/metrics_field.sim
-,,y,script,./test.sh -f tsim/vector/metrics_mix.sim
-,,y,script,./test.sh -f tsim/vector/metrics_query.sim
-,,y,script,./test.sh -f tsim/vector/metrics_tag.sim
-,,y,script,./test.sh -f tsim/vector/metrics_time.sim
-,,y,script,./test.sh -f tsim/vector/multi.sim
-,,y,script,./test.sh -f tsim/vector/single.sim
-,,y,script,./test.sh -f tsim/vector/table_field.sim
-,,y,script,./test.sh -f tsim/vector/table_mix.sim
-,,y,script,./test.sh -f tsim/vector/table_query.sim
-,,y,script,./test.sh -f tsim/vector/table_time.sim
-,,y,script,./test.sh -f tsim/wal/kill.sim
-,,y,script,./test.sh -f tsim/tag/3.sim
-,,y,script,./test.sh -f tsim/tag/4.sim
-,,y,script,./test.sh -f tsim/tag/5.sim
-,,y,script,./test.sh -f tsim/tag/6.sim
-,,y,script,./test.sh -f tsim/tag/add.sim
-,,y,script,./test.sh -f tsim/tag/bigint.sim
-,,y,script,./test.sh -f tsim/tag/binary_binary.sim
-,,y,script,./test.sh -f tsim/tag/binary.sim
-,,y,script,./test.sh -f tsim/tag/bool_binary.sim
-,,y,script,./test.sh -f tsim/tag/bool_int.sim
-,,y,script,./test.sh -f tsim/tag/bool.sim
-,,y,script,./test.sh -f tsim/tag/change.sim
-,,y,script,./test.sh -f tsim/tag/column.sim
-,,y,script,./test.sh -f tsim/tag/commit.sim
-,,y,script,./test.sh -f tsim/tag/create.sim
-,,y,script,./test.sh -f tsim/tag/delete.sim
-,,y,script,./test.sh -f tsim/tag/double.sim
-,,y,script,./test.sh -f tsim/tag/filter.sim
-,,y,script,./test.sh -f tsim/tag/float.sim
-,,y,script,./test.sh -f tsim/tag/int_binary.sim
-,,y,script,./test.sh -f tsim/tag/int_float.sim
-,,y,script,./test.sh -f tsim/tag/int.sim
-,,y,script,./test.sh -f tsim/tag/set.sim
-,,y,script,./test.sh -f tsim/tag/smallint.sim
-,,y,script,./test.sh -f tsim/tag/tinyint.sim
-,,y,script,./test.sh -f tsim/tag/drop_tag.sim
-,,y,script,./test.sh -f tsim/tag/tbNameIn.sim
-,,y,script,./test.sh -f tmp/monitor.sim
-
 #system test
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/nestedQuery.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/nestedQuery_str.py
@ -449,6 +32,7 @@
 ,,y,system-test,./pytest.sh python3 ./test.py -f 7-tmq/subscribeStb2.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 7-tmq/subscribeStb3.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 7-tmq/subscribeDb0.py -N 3 -n 3
+,,y,system-test,./pytest.sh python3 ./test.py -f 7-tmq/ins_topics_test.py


 ,,y,system-test,./pytest.sh python3 ./test.py -f 1-insert/delete_stable.py
@ -812,17 +396,16 @@
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/concat2.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/json_tag.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/nestedQueryInterval.py
+,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/systable_func.py

 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/stablity.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/stablity_1.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/elapsed.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/csum.py
-#,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/function_diff.py
+,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/function_diff.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/tagFilter.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/projectionDesc.py
-,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/ts_3398.py -N 3 -n 3
-,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/ts_3405.py -N 3 -n 3
-,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/ts_3423.py -N 3 -n 3
+,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/ts_3405_3398_3423.py -N 3 -n 3

 ,,n,system-test,python3 ./test.py -f 2-query/queryQnode.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 6-cluster/5dnode1mnode.py
@ -856,7 +439,7 @@
 ,,y,system-test,./pytest.sh python3 ./test.py -f 6-cluster/5dnode3mnodeAdd1Ddnoe.py -N 7 -M 3 -C 6
 ,,y,system-test,./pytest.sh python3 ./test.py -f 6-cluster/5dnode3mnodeAdd1Ddnoe.py -N 7 -M 3 -C 6 -n 3
 #,,y,system-test,./pytest.sh python3 ./test.py -f 6-cluster/5dnode3mnodeDrop.py -N 5
-,,y,system-test,./pytest.sh python3 ./test.py -f 6-cluster/5dnode3mnodeRecreateMnode.py -N 5 -M 3
+,,y,system-test,./pytest.sh python3 ./test.py -f 6-cluster/5dnode3mnodeRecreateMnode.py -N 6 -M 3
 ,,y,system-test,./pytest.sh python3 ./test.py -f 6-cluster/5dnode3mnodeStopFollowerLeader.py -N 5 -M 3
 ,,y,system-test,./pytest.sh python3 ./test.py -f 6-cluster/5dnode3mnodeStop2Follower.py -N 5 -M 3
 ,,y,system-test,./pytest.sh python3 ./test.py -f 6-cluster/vnode/4dnode1mnode_basic_createDb_replica1.py -N 4 -M 1
@ -932,7 +515,7 @@
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/csum.py -Q 2
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/mavg.py -Q 2
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/sample.py -Q 2
-#,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/function_diff.py -Q 2
+,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/function_diff.py -Q 2
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/unique.py -Q 2
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/stateduration.py -Q 2
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/function_stateduration.py -Q 2
@ -1027,7 +610,7 @@
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/csum.py -Q 3
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/mavg.py -Q 3
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/sample.py -Q 3
-#,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/function_diff.py -Q 3
+,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/function_diff.py -Q 3
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/unique.py -Q 3
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/stateduration.py -Q 3
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/function_stateduration.py -Q 3
@ -1123,7 +706,7 @@
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/mavg.py -Q 4
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/sample.py -Q 4
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/cast.py -Q 4
-#,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/function_diff.py -Q 4
+,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/function_diff.py -Q 4
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/unique.py -Q 4
 #,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/stateduration.py -Q 4
 #,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/function_stateduration.py -Q 4
@ -1595,6 +1178,7 @@
 ,,y,script,./test.sh -f tsim/tag/drop_tag.sim
 ,,y,script,./test.sh -f tsim/tag/tbNameIn.sim
 ,,y,script,./test.sh -f tmp/monitor.sim
+
 #develop test
 ,,n,develop-test,python3 ./test.py -f 2-query/table_count_scan.py
 ,,n,develop-test,python3 ./test.py -f 2-query/show_create_db.py
--- a/tests/parallel_test/split_case.sh
+++ b/tests/parallel_test/split_case.sh
@ -5,6 +5,8 @@ parm_path=$(pwd ${parm_path})
 echo "execute path:${parm_path}"
 cd ${parm_path}
 cp cases.task  ${case_file}
+sed -i '/udf/d' ${case_file}
+sed -i '/Udf/d' ${case_file}
 sed -i '/^$/d' ${case_file} 
 sed -i '$a\%%FINISHED%%' ${case_file} 

--- a/tests/script/tsim/query/sys_tbname.sim
+++ b/tests/script/tsim/query/sys_tbname.sim
@ -131,4 +131,8 @@ print $rows
 if $rows != 9 then
  return -1
 endi
+
+print =========================== td-24781
+sql select DISTINCT (`precision`) from `information_schema`.`ins_databases` PARTITION BY `precision`
+
 #system sh/exec.sh -n dnode1 -s stop -x SIGINT
--- a/tests/script/win-test-file
+++ b/tests/script/win-test-file
@ -1,3 +1,28 @@
+./test.sh -f tsim/tmq/basic2Of2ConsOverlap.sim
+./test.sh -f tsim/parser/where.sim
+./test.sh -f tsim/parser/join_manyblocks.sim
+./test.sh -f tsim/dnode/redistribute_vgroup_replica3_v1_leader.sim
+./test.sh -f tsim/dnode/redistribute_vgroup_replica3_v1_follower.sim
+./test.sh -f tsim/dnode/redistribute_vgroup_replica3_v2.sim
+./test.sh -f tsim/dnode/redistribute_vgroup_replica3_v3.sim
+./test.sh -f tsim/parser/limit1.sim
+./test.sh -f tsim/parser/union.sim
+./test.sh -f tsim/parser/commit.sim
+./test.sh -f tsim/parser/nestquery.sim
+./test.sh -f tsim/valgrind/checkError7.sim
+./test.sh -f tsim/parser/groupby.sim
+./test.sh -f tsim/parser/sliding.sim
+./test.sh -f tsim/dnode/balance2.sim
+./test.sh -f tsim/vnode/replica3_repeat.sim
+./test.sh -f tsim/parser/col_arithmetic_operation.sim
+./test.sh -f tsim/trans/create_db.sim
+./test.sh -f tsim/dnode/balance3.sim
+./test.sh -f tsim/vnode/replica3_many.sim
+./test.sh -f tsim/stable/metrics_idx.sim
+./test.sh -f tsim/db/alter_replica_13.sim
+./test.sh -f tsim/sync/3Replica1VgElect.sim
+./test.sh -f tsim/sync/3Replica5VgElect.sim
+./test.sh -f tsim/valgrind/checkError6.sim
 ./test.sh -f tsim/user/basic.sim
 ./test.sh -f tsim/user/password.sim
 ./test.sh -f tsim/user/privilege_db.sim
@ -5,7 +30,6 @@
 ./test.sh -f tsim/user/privilege_topic.sim
 ./test.sh -f tsim/user/privilege_table.sim
 ./test.sh -f tsim/db/alter_option.sim
-rem ./test.sh -f tsim/db/alter_replica_13.sim
 ./test.sh -f tsim/db/alter_replica_31.sim
 ./test.sh -f tsim/db/basic1.sim
 ./test.sh -f tsim/db/basic2.sim
@ -29,11 +53,10 @@ rem ./test.sh -f tsim/db/alter_replica_13.sim
 ./test.sh -f tsim/db/show_create_table.sim
 ./test.sh -f tsim/db/tables.sim
 ./test.sh -f tsim/db/taosdlog.sim
+./test.sh -f tsim/db/table_prefix_suffix.sim
 ./test.sh -f tsim/dnode/balance_replica1.sim
 ./test.sh -f tsim/dnode/balance_replica3.sim
 ./test.sh -f tsim/dnode/balance1.sim
-./test.sh -f tsim/dnode/balance2.sim
-./test.sh -f tsim/dnode/balance3.sim
 ./test.sh -f tsim/dnode/balancex.sim
 ./test.sh -f tsim/dnode/create_dnode.sim
 ./test.sh -f tsim/dnode/drop_dnode_has_mnode.sim
@ -45,10 +68,6 @@ rem ./test.sh -f tsim/db/alter_replica_13.sim
 ./test.sh -f tsim/dnode/drop_dnode_force.sim
 ./test.sh -f tsim/dnode/offline_reason.sim
 ./test.sh -f tsim/dnode/redistribute_vgroup_replica1.sim
-./test.sh -f tsim/dnode/redistribute_vgroup_replica3_v1_leader.sim
-./test.sh -f tsim/dnode/redistribute_vgroup_replica3_v1_follower.sim
-./test.sh -f tsim/dnode/redistribute_vgroup_replica3_v2.sim
-./test.sh -f tsim/dnode/redistribute_vgroup_replica3_v3.sim
 ./test.sh -f tsim/dnode/vnode_clean.sim
 ./test.sh -f tsim/dnode/use_dropped_dnode.sim
 ./test.sh -f tsim/dnode/split_vgroup_replica1.sim
@ -74,6 +93,7 @@ rem ./test.sh -f tsim/db/alter_replica_13.sim
 ./test.sh -f tsim/insert/query_multi_file.sim
 ./test.sh -f tsim/insert/tcp.sim
 ./test.sh -f tsim/insert/update0.sim
+./test.sh -f tsim/insert/delete0.sim
 ./test.sh -f tsim/insert/update1_sort_merge.sim
 ./test.sh -f tsim/insert/update2.sim
 ./test.sh -f tsim/parser/alter__for_community_version.sim
@ -85,7 +105,6 @@ rem ./test.sh -f tsim/db/alter_replica_13.sim
 ./test.sh -f tsim/parser/auto_create_tb.sim
 ./test.sh -f tsim/parser/between_and.sim
 ./test.sh -f tsim/parser/binary_escapeCharacter.sim
-./test.sh -f tsim/parser/col_arithmetic_operation.sim
 ./test.sh -f tsim/parser/columnValue_bigint.sim
 ./test.sh -f tsim/parser/columnValue_bool.sim
 ./test.sh -f tsim/parser/columnValue_double.sim
@ -94,8 +113,8 @@ rem ./test.sh -f tsim/db/alter_replica_13.sim
 ./test.sh -f tsim/parser/columnValue_smallint.sim
 ./test.sh -f tsim/parser/columnValue_tinyint.sim
 ./test.sh -f tsim/parser/columnValue_unsign.sim
-./test.sh -f tsim/parser/commit.sim
 ./test.sh -f tsim/parser/condition.sim
+./test.sh -f tsim/parser/condition_scl.sim
 ./test.sh -f tsim/parser/constCol.sim
 ./test.sh -f tsim/parser/create_db.sim
 ./test.sh -f tsim/parser/create_mt.sim
@ -111,7 +130,6 @@ rem ./test.sh -f tsim/db/alter_replica_13.sim
 ./test.sh -f tsim/parser/fourArithmetic-basic.sim
 ./test.sh -f tsim/parser/function.sim
 ./test.sh -f tsim/parser/groupby-basic.sim
-./test.sh -f tsim/parser/groupby.sim
 ./test.sh -f tsim/parser/having_child.sim
 ./test.sh -f tsim/parser/having.sim
 ./test.sh -f tsim/parser/import_commit1.sim
@ -121,7 +139,6 @@ rem ./test.sh -f tsim/db/alter_replica_13.sim
 ./test.sh -f tsim/parser/import.sim
 ./test.sh -f tsim/parser/insert_multiTbl.sim
 ./test.sh -f tsim/parser/insert_tb.sim
-./test.sh -f tsim/parser/join_manyblocks.sim
 ./test.sh -f tsim/parser/join_multitables.sim
 ./test.sh -f tsim/parser/join_multivnode.sim
 ./test.sh -f tsim/parser/join.sim
@ -131,10 +148,8 @@ rem ./test.sh -f tsim/db/alter_replica_13.sim
 ./test.sh -f tsim/parser/lastrow2.sim
 ./test.sh -f tsim/parser/like.sim
 ./test.sh -f tsim/parser/limit.sim
-./test.sh -f tsim/parser/limit1.sim
 ./test.sh -f tsim/parser/mixed_blocks.sim
 ./test.sh -f tsim/parser/nchar.sim
-./test.sh -f tsim/parser/nestquery.sim
 ./test.sh -f tsim/parser/null_char.sim
 ./test.sh -f tsim/parser/precision_ns.sim
 ./test.sh -f tsim/parser/projection_limit_offset.sim
@ -147,7 +162,6 @@ rem ./test.sh -f tsim/db/alter_replica_13.sim
 ./test.sh -f tsim/parser/selectResNum.sim
 ./test.sh -f tsim/parser/set_tag_vals.sim
 ./test.sh -f tsim/parser/single_row_in_tb.sim
-./test.sh -f tsim/parser/sliding.sim
 ./test.sh -f tsim/parser/slimit_alter_tags.sim
 ./test.sh -f tsim/parser/slimit.sim
 ./test.sh -f tsim/parser/slimit1.sim
@ -158,9 +172,9 @@ rem ./test.sh -f tsim/db/alter_replica_13.sim
 ./test.sh -f tsim/parser/timestamp.sim
 ./test.sh -f tsim/parser/top_groupby.sim
 ./test.sh -f tsim/parser/topbot.sim
-./test.sh -f tsim/parser/union.sim
 ./test.sh -f tsim/parser/union_sysinfo.sim
-./test.sh -f tsim/parser/where.sim
+./test.sh -f tsim/parser/slimit_limit.sim
+./test.sh -f tsim/parser/table_merge_limit.sim
 ./test.sh -f tsim/query/tagLikeFilter.sim
 ./test.sh -f tsim/query/charScalarFunction.sim
 ./test.sh -f tsim/query/explain.sim
@ -169,12 +183,21 @@ rem ./test.sh -f tsim/db/alter_replica_13.sim
 ./test.sh -f tsim/query/scalarFunction.sim
 ./test.sh -f tsim/query/scalarNull.sim
 ./test.sh -f tsim/query/session.sim
+./test.sh -f tsim/query/join_interval.sim
+./test.sh -f tsim/query/unionall_as_table.sim
+./test.sh -f tsim/query/multi_order_by.sim
 ./test.sh -f tsim/query/sys_tbname.sim
 ./test.sh -f tsim/query/groupby.sim
+./test.sh -f tsim/query/groupby_distinct.sim
 ./test.sh -f tsim/query/event.sim
 ./test.sh -f tsim/query/forceFill.sim
 ./test.sh -f tsim/query/emptyTsRange.sim
+./test.sh -f tsim/query/emptyTsRange_scl.sim
 ./test.sh -f tsim/query/partitionby.sim
+./test.sh -f tsim/query/tableCount.sim
+./test.sh -f tsim/query/tag_scan.sim
+./test.sh -f tsim/query/nullColSma.sim
+./test.sh -f tsim/query/bug3398.sim
 ./test.sh -f tsim/qnode/basic1.sim
 ./test.sh -f tsim/snode/basic1.sim
 ./test.sh -f tsim/mnode/basic1.sim
@ -257,7 +280,6 @@ rem ./test.sh -f tsim/db/alter_replica_13.sim
 ./test.sh -f tsim/stream/udTableAndTag2.sim
 ./test.sh -f tsim/stream/windowClose.sim
 ./test.sh -f tsim/trans/lossdata1.sim
-./test.sh -f tsim/trans/create_db.sim
 ./test.sh -f tsim/tmq/basic1.sim
 ./test.sh -f tsim/tmq/basic2.sim
 ./test.sh -f tsim/tmq/basic3.sim
@ -266,7 +288,6 @@ rem ./test.sh -f tsim/db/alter_replica_13.sim
 ./test.sh -f tsim/tmq/basic2Of2Cons.sim
 ./test.sh -f tsim/tmq/basic3Of2Cons.sim
 ./test.sh -f tsim/tmq/basic4Of2Cons.sim
-./test.sh -f tsim/tmq/basic2Of2ConsOverlap.sim
 ./test.sh -f tsim/tmq/topic.sim
 ./test.sh -f tsim/tmq/snapshot.sim
 ./test.sh -f tsim/tmq/snapshot1.sim
@ -290,7 +311,6 @@ rem ./test.sh -f tsim/db/alter_replica_13.sim
 ./test.sh -f tsim/stable/tag_rename.sim
 ./test.sh -f tsim/stable/values.sim
 ./test.sh -f tsim/stable/vnode3.sim
-./test.sh -f tsim/stable/metrics_idx.sim
 ./test.sh -f tsim/sma/drop_sma.sim
 ./test.sh -f tsim/sma/sma_leak.sim
 ./test.sh -f tsim/sma/tsmaCreateInsertQuery.sim
@ -301,13 +321,9 @@ rem ./test.sh -f tsim/db/alter_replica_13.sim
 ./test.sh -f tsim/valgrind/checkError3.sim
 ./test.sh -f tsim/valgrind/checkError4.sim
 ./test.sh -f tsim/valgrind/checkError5.sim
-./test.sh -f tsim/valgrind/checkError6.sim
-./test.sh -f tsim/valgrind/checkError7.sim
 ./test.sh -f tsim/valgrind/checkError8.sim
 ./test.sh -f tsim/vnode/replica3_basic.sim
-./test.sh -f tsim/vnode/replica3_repeat.sim
 ./test.sh -f tsim/vnode/replica3_vgroup.sim
-./test.sh -f tsim/vnode/replica3_many.sim
 ./test.sh -f tsim/vnode/replica3_import.sim
 ./test.sh -f tsim/vnode/stable_balance_replica1.sim
 ./test.sh -f tsim/vnode/stable_dnode2_stop.sim
@ -315,8 +331,6 @@ rem ./test.sh -f tsim/db/alter_replica_13.sim
 ./test.sh -f tsim/vnode/stable_dnode3.sim
 ./test.sh -f tsim/vnode/stable_replica3_dnode6.sim
 ./test.sh -f tsim/vnode/stable_replica3_vnode3.sim
-./test.sh -f tsim/sync/3Replica1VgElect.sim
-./test.sh -f tsim/sync/3Replica5VgElect.sim
 ./test.sh -f tsim/sync/oneReplica1VgElect.sim
 ./test.sh -f tsim/sync/oneReplica5VgElect.sim
 ./test.sh -f tsim/catalog/alterInCurrent.sim
--- a/Show More
+++ b/Show More