Merge remote-tracking branch 'origin/3.0' into feature/qnode

Jenkinsfile2

@@ -121,7 +121,7 @@ def pre_test_win(){
         set
         date /t
         time /t
-        rd /s /Q C:\\workspace\\%EXECUTOR_NUMBER%\\TDinternal\\debug
+        rd /s /Q C:\\workspace\\%EXECUTOR_NUMBER%\\TDinternal\\debug || exit 0
     '''
     bat '''
         cd C:\\workspace\\%EXECUTOR_NUMBER%\\TDinternal

include/libs/nodes/querynodes.h

@@ -236,6 +236,7 @@ typedef struct SSelectStmt {
   bool        isTimeOrderQuery;
   bool        hasAggFuncs;
   bool        hasRepeatScanFuncs;
+  bool        hasNonstdSQLFunc;
 } SSelectStmt;
 
 typedef enum ESetOperatorType { SET_OP_TYPE_UNION_ALL = 1, SET_OP_TYPE_UNION } ESetOperatorType;

include/libs/stream/tstream.h

@@ -107,6 +107,7 @@ static FORCE_INLINE void streamDataSubmitRefDec(SStreamDataSubmit* pDataSubmit)
   if (ref == 0) {
     taosMemoryFree(pDataSubmit->data);
     taosMemoryFree(pDataSubmit->dataRef);
+    taosFreeQitem(pDataSubmit);
   }
 }
 
@@ -279,6 +280,12 @@ typedef struct {
   SArray* res;  // SArray<SSDataBlock>
 } SStreamSinkReq;
 
+typedef struct {
+  SMsgHead head;
+  int64_t  streamId;
+  int32_t  taskId;
+} SStreamTaskRunReq;
+
 int32_t streamEnqueueDataSubmit(SStreamTask* pTask, SStreamDataSubmit* input);
 int32_t streamEnqueueDataBlk(SStreamTask* pTask, SStreamDataBlock* input);
 int32_t streamDequeueOutput(SStreamTask* pTask, void** output);

include/libs/sync/sync.h

@@ -20,14 +20,11 @@
 extern "C" {
 #endif
 
-#include <stdbool.h>
-#include <stdint.h>
-//#include <tdatablock.h>
+#include "os.h"
+
 #include "cJSON.h"
 #include "tdef.h"
-//#include "taosdef.h"
-//#include "trpc.h"
-//#include "wal.h"
+#include "tmsgcb.h"
 
 typedef uint64_t SyncNodeId;
 typedef int32_t  SyncGroupId;
@@ -132,11 +129,10 @@ typedef struct SSyncInfo {
   char        path[TSDB_FILENAME_LEN];
   SWal*       pWal;
   SSyncFSM*   pFsm;
+  SMsgCb*     msgcb;
 
-  void* rpcClient;
-  int32_t (*FpSendMsg)(void* rpcClient, const SEpSet* pEpSet, SRpcMsg* pMsg);
-  void* queue;
-  int32_t (*FpEqMsg)(void* queue, SRpcMsg* pMsg);
+  int32_t (*FpSendMsg)(const SEpSet* pEpSet, SRpcMsg* pMsg);
+  int32_t (*FpEqMsg)(const SMsgCb* msgcb, SRpcMsg* pMsg);
 
 } SSyncInfo;
 

include/libs/sync/syncTools.h

@@ -20,13 +20,10 @@
 extern "C" {
 #endif
 
-#include <stdbool.h>
-#include <stdint.h>
-//#include <tdatablock.h>
+#include "os.h"
+
 #include "cJSON.h"
-//#include "taosdef.h"
 #include "trpc.h"
-//#include "wal.h"
 
 // ------------------ ds -------------------
 typedef struct SRaftId {
@@ -43,8 +40,7 @@ void       syncNodeRelease(SSyncNode* pNode);
 
 int32_t syncGetRespRpc(int64_t rid, uint64_t index, SRpcMsg* msg);
 int32_t syncGetAndDelRespRpc(int64_t rid, uint64_t index, SRpcMsg* msg);
-void    syncSetQ(int64_t rid, void* queueHandle);
-void    syncSetRpc(int64_t rid, void* rpcHandle);
+void    syncSetMsgCb(int64_t rid, const SMsgCb* msgcb);
 char*   sync2SimpleStr(int64_t rid);
 
 // set timer ms

include/libs/transport/trpc.h

@@ -38,7 +38,7 @@ typedef struct {
 
 typedef struct SRpcHandleInfo {
   // rpc info
-  void   *handle;         // rpc handle returned to app
+  void *  handle;         // rpc handle returned to app
   int64_t refId;          // refid, used by server
   int32_t noResp;         // has response or not(default 0, 0: resp, 1: no resp);
   int32_t persistHandle;  // persist handle or not
@@ -49,13 +49,13 @@ typedef struct SRpcHandleInfo {
   void *node;     // node mgmt handle
 
   // resp info
-  void   *rsp;
+  void *  rsp;
   int32_t rspLen;
 } SRpcHandleInfo;
 
 typedef struct SRpcMsg {
   tmsg_t         msgType;
-  void          *pCont;
+  void *         pCont;
   int32_t        contLen;
   int32_t        code;
   SRpcHandleInfo info;
@@ -63,11 +63,6 @@ typedef struct SRpcMsg {
 } SRpcMsg;
 
 typedef void (*RpcCfp)(void *parent, SRpcMsg *, SEpSet *rf);
-typedef int (*RpcAfp)(void *parent, char *tableId, char *spi, char *encrypt, char *secret, char *ckey);
-///
-// // SRpcMsg code
-// REDIERE,
-// NOT READY, EpSet
 typedef bool (*RpcRfp)(int32_t code);
 
 typedef struct SRpcInit {
@@ -81,17 +76,10 @@ typedef struct SRpcInit {
 
   // the following is for client app ecurity only
   char *user;  // user name
-  char  spi;      // security parameter index
-  char  encrypt;  // encrypt algorithm
-  char *secret;   // key for authentication
-  char *ckey;     // ciphering key
 
   // call back to process incoming msg, code shall be ignored by server app
   RpcCfp cfp;
 
-  // call back to retrieve the client auth info, for server app only
-  RpcAfp afp;
-
   // user defined retry func
   RpcRfp rfp;
 

include/util/taoserror.h

@@ -649,6 +649,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_INVALID_TBNAME            TAOS_DEF_ERROR_CODE(0, 0x264C)
 #define TSDB_CODE_PAR_INVALID_FUNCTION_NAME     TAOS_DEF_ERROR_CODE(0, 0x264D)
 #define TSDB_CODE_PAR_COMMENT_TOO_LONG          TAOS_DEF_ERROR_CODE(0, 0x264E)
+#define TSDB_CODE_PAR_NOT_ALLOWED_FUNC          TAOS_DEF_ERROR_CODE(0, 0x264F)
 
 //planner
 #define TSDB_CODE_PLAN_INTERNAL_ERROR           TAOS_DEF_ERROR_CODE(0, 0x2700)

packaging/deb/makedeb.sh

@@ -67,9 +67,9 @@ fi
 
 cp ${compile_dir}/build/bin/taos                    ${pkg_dir}${install_home_path}/bin
 cp ${compile_dir}/build/lib/${libfile}              ${pkg_dir}${install_home_path}/driver
-cp ${compile_dir}/../src/inc/taos.h                 ${pkg_dir}${install_home_path}/include
-cp ${compile_dir}/../src/inc/taosdef.h              ${pkg_dir}${install_home_path}/include
-cp ${compile_dir}/../src/inc/taoserror.h            ${pkg_dir}${install_home_path}/include
+cp ${compile_dir}/../include/client/taos.h          ${pkg_dir}${install_home_path}/include
+cp ${compile_dir}/../include/common/taosdef.h       ${pkg_dir}${install_home_path}/include
+cp ${compile_dir}/../include/util/taoserror.h       ${pkg_dir}${install_home_path}/include
 cp -r ${top_dir}/examples/*                         ${pkg_dir}${install_home_path}/examples
 #cp -r ${top_dir}/src/connector/python               ${pkg_dir}${install_home_path}/connector
 #cp -r ${top_dir}/src/connector/go                   ${pkg_dir}${install_home_path}/connector

packaging/release.sh

 #!/bin/bash
 #
-# Generate the tar.gz package for linux os
+# Generate the deb package for ubuntu, or rpm package for centos, or tar.gz package for other linux os
 
 set -e
 #set -x
 
+# release.sh  -v [cluster | edge]
+#             -c [aarch32 | aarch64 | x64 | x86 | mips64 ...]
+#             -o [Linux | Kylin | Alpine | Raspberrypi | Darwin | Windows | Ningsi60 | Ningsi80 |...]
+#             -V [stable | beta]
+#             -l [full | lite]
+#             -s [static | dynamic]
+#             -d [taos | ...]
+#             -n [2.0.0.3]
+#             -m [2.0.0.0]
+#             -H [ false | true]
+
 # set parameters by default value
-version="3.0.0.0"
+verMode=edge    # [cluster, edge]
+verType=stable  # [stable, beta]
+cpuType=x64     # [aarch32 | aarch64 | x64 | x86 | mips64 ...]
+osType=Linux    # [Linux | Kylin | Alpine | Raspberrypi | Darwin | Windows | Ningsi60 | Ningsi80 |...]
+pagMode=full    # [full | lite]
+soMode=dynamic  # [static | dynamic]
+dbName=taos     # [taos | ...]
+allocator=glibc # [glibc | jemalloc]
+verNumber=""
+verNumberComp="2.0.0.0"
+httpdBuild=false
+
+while getopts "hv:V:c:o:l:s:d:a:n:m:H:" arg; do
+  case $arg in
+  v)
+    #echo "verMode=$OPTARG"
+    verMode=$(echo $OPTARG)
+    ;;
+  V)
+    #echo "verType=$OPTARG"
+    verType=$(echo $OPTARG)
+    ;;
+  c)
+    #echo "cpuType=$OPTARG"
+    cpuType=$(echo $OPTARG)
+    ;;
+  l)
+    #echo "pagMode=$OPTARG"
+    pagMode=$(echo $OPTARG)
+    ;;
+  s)
+    #echo "soMode=$OPTARG"
+    soMode=$(echo $OPTARG)
+    ;;
+  d)
+    #echo "dbName=$OPTARG"
+    dbName=$(echo $OPTARG)
+    ;;
+  a)
+    #echo "allocator=$OPTARG"
+    allocator=$(echo $OPTARG)
+    ;;
+  n)
+    #echo "verNumber=$OPTARG"
+    verNumber=$(echo $OPTARG)
+    ;;
+  m)
+    #echo "verNumberComp=$OPTARG"
+    verNumberComp=$(echo $OPTARG)
+    ;;
+  o)
+    #echo "osType=$OPTARG"
+    osType=$(echo $OPTARG)
+    ;;
+  H)
+    #echo "httpdBuild=$OPTARG"
+    httpdBuild=$(echo $OPTARG)
+    ;;
+  h)
+    echo "Usage: $(basename $0) -v [cluster | edge] "
+    echo "                  -c [aarch32 | aarch64 | x64 | x86 | mips64 ...] "
+    echo "                  -o [Linux | Kylin | Alpine | Raspberrypi | Darwin | Windows | Ningsi60 | Ningsi80 |...] "
+    echo "                  -V [stable | beta] "
+    echo "                  -l [full | lite] "
+    echo "                  -a [glibc | jemalloc] "
+    echo "                  -s [static | dynamic] "
+    echo "                  -d [taos | ...] "
+    echo "                  -n [version number] "
+    echo "                  -m [compatible version number] "
+    echo "                  -H [false | true] "
+    exit 0
+    ;;
+  ?) #unknow option
+    echo "unkonw argument"
+    exit 1
+    ;;
+  esac
+done
+
+echo "verMode=${verMode} verType=${verType} cpuType=${cpuType} osType=${osType} pagMode=${pagMode} soMode=${soMode} dbName=${dbName} allocator=${allocator} verNumber=${verNumber} verNumberComp=${verNumberComp} httpdBuild=${httpdBuild}"
 
 curr_dir=$(pwd)
 
-script_dir="$(dirname $(readlink -f $0))"
-top_dir="$(readlink -f ${script_dir}/..)"
+if [ "$osType" == "Darwin" ]; then
+  script_dir=$(dirname $0)
+  cd ${script_dir}
+  script_dir="$(pwd)"
+  top_dir=${script_dir}/..
+else
+  script_dir="$(dirname $(readlink -f $0))"
+  top_dir="$(readlink -f ${script_dir}/..)"
+fi
+
+csudo=""
+if command -v sudo > /dev/null; then
+ csudo="sudo "
+fi
+
+function is_valid_version() {
+  [ -z $1 ] && return 1 || :
+
+  rx='^([0-9]+\.){3}(\*|[0-9]+)$'
+  if [[ $1 =~ $rx ]]; then
+    return 0
+  fi
+  return 1
+}
+
+function vercomp() {
+  if [[ $1 == $2 ]]; then
+    echo 0
+    exit 0
+  fi
+
+  local IFS=.
+  local i ver1=($1) ver2=($2)
+
+  # fill empty fields in ver1 with zeros
+  for ((i = ${#ver1[@]}; i < ${#ver2[@]}; i++)); do
+    ver1[i]=0
+  done
+
+  for ((i = 0; i < ${#ver1[@]}; i++)); do
+    if [[ -z ${ver2[i]} ]]; then
+      # fill empty fields in ver2 with zeros
+      ver2[i]=0
+    fi
+    if ((10#${ver1[i]} > 10#${ver2[i]})); then
+      echo 1
+      exit 0
+    fi
+    if ((10#${ver1[i]} < 10#${ver2[i]})); then
+      echo 2
+      exit 0
+    fi
+  done
+  echo 0
+}
+
+# 1. check version information
+if ( (! is_valid_version $verNumber) || (! is_valid_version $verNumberComp) || [[ "$(vercomp $verNumber $verNumberComp)" == '2' ]]); then
+  echo "please enter correct version"
+  exit 0
+fi
 
-echo "=======================new version number: ${verNumber}======================================"
+echo "=======================new version number: ${verNumber}, compatible version: ${verNumberComp}======================================"
 
 build_time=$(date +"%F %R")
 
-echo "script_dir: ${script_dir}"
-echo "top_dir: ${top_dir}"
+# get commint id from git
+gitinfo=$(git rev-parse --verify HEAD)
 
-cd ${top_dir}
-# git checkout -- .
-# git checkout 3.0
-# git pull || :
+if [[ "$verMode" == "cluster" ]]; then
+  enterprise_dir="${top_dir}/../enterprise"
+  cd ${enterprise_dir}
+  gitinfoOfInternal=$(git rev-parse --verify HEAD)
+else
+  gitinfoOfInternal=NULL
+fi
 
-echo "curr_dir: ${curr_dir}"
+cd "${curr_dir}"
 
 # 2. cmake executable file
 compile_dir="${top_dir}/debug"
-# if [ -d ${compile_dir} ]; then
-#   rm -rf ${compile_dir}
-# fi
-
-mkdir -p ${compile_dir}
+if [ -d ${compile_dir} ]; then
+  ${csudo}rm -rf ${compile_dir}
+fi
 
+if [ "$osType" != "Darwin" ]; then
+  ${csudo}mkdir -p ${compile_dir}
+else
+  mkdir -p ${compile_dir}
+fi
 cd ${compile_dir}
 
-echo "compile_dir: ${compile_dir}"
+if [[ "$allocator" == "jemalloc" ]]; then
+  allocator_macro="-DJEMALLOC_ENABLED=true"
+else
+  allocator_macro=""
+fi
 
-cmake .. -DBUILD_TOOLS=true
-make -j32
+if [[ "$dbName" != "taos" ]]; then
+  source ${enterprise_dir}/packaging/oem/sed_$dbName.sh
+  replace_community_$dbName
+fi
 
-release_dir="${top_dir}/release"
-if [ -d ${release_dir} ]; then
-  rm -rf ${release_dir}
+if [[ "$httpdBuild" == "true" ]]; then
+  BUILD_HTTP=true
+else
+  BUILD_HTTP=false
 fi
 
-mkdir -p ${release_dir}
-cd ${release_dir}
+if [[ "$verMode" == "cluster" ]]; then
+  BUILD_HTTP=internal
+fi
 
-install_dir="${release_dir}/TDengine-server-${version}"
-mkdir -p ${install_dir}
-mkdir -p ${install_dir}/bin
-mkdir -p ${install_dir}/lib
-mkdir -p ${install_dir}/inc
+if [[ "$pagMode" == "full" ]]; then
+  BUILD_TOOLS=true
+else
+  BUILD_TOOLS=false
+fi
+
+# check support cpu type
+if [[ "$cpuType" == "x64" ]] || [[ "$cpuType" == "aarch64" ]] || [[ "$cpuType" == "aarch32" ]] || [[ "$cpuType" == "mips64" ]]; then
+  if [ "$verMode" != "cluster" ]; then
+    # community-version compile
+    cmake ../ -DCPUTYPE=${cpuType} -DOSTYPE=${osType} -DSOMODE=${soMode} -DDBNAME=${dbName} -DVERTYPE=${verType} -DVERDATE="${build_time}" -DGITINFO=${gitinfo} -DGITINFOI=${gitinfoOfInternal} -DVERNUMBER=${verNumber} -DVERCOMPATIBLE=${verNumberComp} -DPAGMODE=${pagMode} -DBUILD_HTTP=${BUILD_HTTP} -DBUILD_TOOLS=${BUILD_TOOLS} ${allocator_macro}
+  else
+    if [[ "$dbName" != "taos" ]]; then
+      replace_enterprise_$dbName
+    fi
+    cmake ../../ -DCPUTYPE=${cpuType} -DOSTYPE=${osType} -DSOMODE=${soMode} -DDBNAME=${dbName} -DVERTYPE=${verType} -DVERDATE="${build_time}" -DGITINFO=${gitinfo} -DGITINFOI=${gitinfoOfInternal} -DVERNUMBER=${verNumber} -DVERCOMPATIBLE=${verNumberComp} -DBUILD_HTTP=${BUILD_HTTP} -DBUILD_TOOLS=${BUILD_TOOLS} ${allocator_macro}
+  fi
+else
+  echo "input cpuType=${cpuType} error!!!"
+  exit 1
+fi
 
-install_files="${script_dir}/tools/install.sh"
-chmod a+x ${script_dir}/tools/install.sh || :
-cp ${install_files} ${install_dir} 
+CORES=$(grep -c ^processor /proc/cpuinfo)
 
-header_files="${top_dir}/include/client/taos.h ${top_dir}/include/util/taoserror.h"
-cp ${header_files} ${install_dir}/inc
+if [[ "$allocator" == "jemalloc" ]]; then
+  # jemalloc need compile first, so disable parallel build
+  make -j ${CORES} && ${csudo}make install
+else
+  make -j ${CORES} && ${csudo}make install
+fi
+
+cd ${curr_dir}
 
-bin_files="${compile_dir}/build/bin/taosd ${compile_dir}/build/bin/taos  ${compile_dir}/build/bin/create_table ${compile_dir}/build/bin/tmq_sim ${script_dir}/tools/remove.sh ${compile_dir}/build/bin/taosBenchmark   ${compile_dir}/build/bin/taosdump"
-cp -rf ${bin_files} ${install_dir}/bin && chmod a+x ${install_dir}/bin/* || :
+# 3. Call the corresponding script for packaging
+if [ "$osType" != "Darwin" ]; then
+  if [[ "$verMode" != "cluster" ]] && [[ "$pagMode" == "full" ]] && [[ "$cpuType" == "x64" ]] && [[ "$dbName" == "taos" ]]; then
+    ret='0'
+    command -v dpkg >/dev/null 2>&1 || { ret='1'; }
+    if [ "$ret" -eq 0 ]; then
+      echo "====do deb package for the ubuntu system===="
+      output_dir="${top_dir}/debs"
+      if [ -d ${output_dir} ]; then
+        ${csudo}rm -rf ${output_dir}
+      fi
+      ${csudo}mkdir -p ${output_dir}
+      cd ${script_dir}/deb
+      ${csudo}./makedeb.sh ${compile_dir} ${output_dir} ${verNumber} ${cpuType} ${osType} ${verMode} ${verType}
 
-cp ${compile_dir}/build/lib/libtaos.so  ${install_dir}/lib/
-cp ${compile_dir}/build/lib/libavro* ${install_dir}/lib/ > /dev/null || echo -e "failed to copy avro libraries"
-cp -rf ${compile_dir}/build/lib/pkgconfig  ${install_dir}/lib/ > /dev/null || echo -e "failed to copy pkgconfig directory"
+      if [[ "$pagMode" == "full" ]]; then
+        if [ -d ${top_dir}/tools/taos-tools/packaging/deb ]; then
+          cd ${top_dir}/tools/taos-tools/packaging/deb
+          [ -z "$taos_tools_ver" ] && taos_tools_ver="0.1.0"
 
+          taos_tools_ver=$(git describe --tags | sed -e 's/ver-//g' | awk -F '-' '{print $1}')
+          ${csudo}./make-taos-tools-deb.sh ${top_dir} \
+            ${compile_dir} ${output_dir} ${taos_tools_ver} ${cpuType} ${osType} ${verMode} ${verType}
+        fi
+      fi
+    else
+      echo "==========dpkg command not exist, so not release deb package!!!"
+    fi
+    ret='0'
+    command -v rpmbuild >/dev/null 2>&1 || { ret='1'; }
+    if [ "$ret" -eq 0 ]; then
+      echo "====do rpm package for the centos system===="
+      output_dir="${top_dir}/rpms"
+      if [ -d ${output_dir} ]; then
+        ${csudo}rm -rf ${output_dir}
+      fi
+      ${csudo}mkdir -p ${output_dir}
+      cd ${script_dir}/rpm
+      ${csudo}./makerpm.sh ${compile_dir} ${output_dir} ${verNumber} ${cpuType} ${osType} ${verMode} ${verType}
 
-#cp ${compile_dir}/source/dnode/mnode/impl/libmnode.so ${install_dir}/lib/
-#cp ${compile_dir}/source/dnode/qnode/libqnode.so ${install_dir}/lib/
-#cp ${compile_dir}/source/dnode/snode/libsnode.so ${install_dir}/lib/
-#cp ${compile_dir}/source/dnode/bnode/libbnode.so ${install_dir}/lib/
-#cp ${compile_dir}/source/libs/wal/libwal.so ${install_dir}/lib/
-#cp ${compile_dir}/source/libs/scheduler/libscheduler.so ${install_dir}/lib/
-#cp ${compile_dir}/source/libs/planner/libplanner.so ${install_dir}/lib/
-#cp ${compile_dir}/source/libs/parser/libparser.so ${install_dir}/lib/
-#cp ${compile_dir}/source/libs/qcom/libqcom.so ${install_dir}/lib/
-#cp ${compile_dir}/source/libs/transport/libtransport.so ${install_dir}/lib/
-#cp ${compile_dir}/source/libs/function/libfunction.so ${install_dir}/lib/
-#cp ${compile_dir}/source/common/libcommon.so ${install_dir}/lib/
-#cp ${compile_dir}/source/os/libos.so ${install_dir}/lib/
-#cp ${compile_dir}/source/dnode/mnode/sdb/libsdb.so ${install_dir}/lib/
-#cp ${compile_dir}/source/libs/catalog/libcatalog.so ${install_dir}/lib/
+      if [[ "$pagMode" == "full" ]]; then
+        if [ -d ${top_dir}/tools/taos-tools/packaging/rpm ]; then
+          cd ${top_dir}/tools/taos-tools/packaging/rpm
+          [ -z "$taos_tools_ver" ] && taos_tools_ver="0.1.0"
 
-pkg_name=${install_dir}-Linux-x64
+          taos_tools_ver=$(git describe --tags | sed -e 's/ver-//g' | awk -F '-' '{print $1}' | sed -e 's/-/_/g')
+          ${csudo}./make-taos-tools-rpm.sh ${top_dir} \
+            ${compile_dir} ${output_dir} ${taos_tools_ver} ${cpuType} ${osType} ${verMode} ${verType}
+        fi
+      fi
+    else
+      echo "==========rpmbuild command not exist, so not release rpm package!!!"
+    fi
+  fi
 
-tar -zcv -f "$(basename ${pkg_name}).tar.gz" $(basename ${install_dir}) --remove-files || :
+  echo "====do tar.gz package for all systems===="
+  cd ${script_dir}/tools
 
+  ${csudo}./makepkg.sh ${compile_dir} ${verNumber} "${build_time}" ${cpuType} ${osType} ${verMode} ${verType} ${pagMode} ${verNumberComp} ${dbName}
+  ${csudo}./makeclient.sh ${compile_dir} ${verNumber} "${build_time}" ${cpuType} ${osType} ${verMode} ${verType} ${pagMode} ${dbName}
+  # ${csudo}./makearbi.sh ${compile_dir} ${verNumber} "${build_time}" ${cpuType} ${osType} ${verMode} ${verType} ${pagMode}
 
+else
+  # only make client for Darwin
+  cd ${script_dir}/tools
+  ./makeclient.sh ${compile_dir} ${verNumber} "${build_time}" ${cpuType} ${osType} ${verMode} ${verType} ${pagMode} ${dbName}
+fi

packaging/rpm/tdengine.spec

@@ -74,9 +74,9 @@ if [ -f %{_compiledir}/build/bin/taosadapter ]; then
     cp %{_compiledir}/build/bin/taosadapter                    %{buildroot}%{homepath}/bin ||:
 fi
 cp %{_compiledir}/build/lib/${libfile}              %{buildroot}%{homepath}/driver
-cp %{_compiledir}/../src/inc/taos.h                 %{buildroot}%{homepath}/include
-cp %{_compiledir}/../src/inc/taosdef.h              %{buildroot}%{homepath}/include
-cp %{_compiledir}/../src/inc/taoserror.h            %{buildroot}%{homepath}/include
+cp %{_compiledir}/../include/client/taos.h          %{buildroot}%{homepath}/include
+cp %{_compiledir}/../include/common/taosdef.h       %{buildroot}%{homepath}/include
+cp %{_compiledir}/../include/util/taoserror.h       %{buildroot}%{homepath}/include
 #cp -r %{_compiledir}/../src/connector/python        %{buildroot}%{homepath}/connector
 #cp -r %{_compiledir}/../src/connector/go            %{buildroot}%{homepath}/connector
 #cp -r %{_compiledir}/../src/connector/nodejs        %{buildroot}%{homepath}/connector

packaging/tools/install.sh

@@ -485,6 +485,17 @@ function install_service() {
     # fi
 }
 
+function install_config() {
+    if [ ! -f ${cfg_install_dir}/${configFile} ]; then
+        ${csudo}mkdir -p ${cfg_install_dir}
+        [ -f ${script_dir}/cfg/${configFile} ] && ${csudo}cp ${script_dir}/cfg/${configFile} ${cfg_install_dir}
+        ${csudo}chmod 644 ${cfg_install_dir}/*
+    fi
+
+    ${csudo}cp -f ${script_dir}/cfg/${configFile} ${install_main_dir}/cfg/${configFile}.org
+    ${csudo}ln -s ${cfg_install_dir}/${configFile} ${install_main_dir}/cfg
+}
+
 function install_TDengine() {
     # Start to install
     echo -e "${GREEN}Start to install TDengine...${NC}"
@@ -500,7 +511,7 @@ function install_TDengine() {
         # For installing new
         install_bin
         install_service
-        #install_config
+        install_config
 
         # Ask if to start the service
         #echo
@@ -539,7 +550,7 @@ function install_TDengine() {
         echo
     else # Only install client
         install_bin
-        #install_config
+        install_config
         echo
         echo -e "\033[44;32;1mTDengine client is installed successfully!${NC}"
     fi

packaging/tools/install_client.sh

@@ -17,7 +17,6 @@ serverName="taosd"
 clientName="taos"
 uninstallScript="rmtaos"
 configFile="taos.cfg"
-tarName="taos.tar.gz"
 
 osType=Linux
 pagMode=full
@@ -243,12 +242,6 @@ function install_examples() {
 
 function update_TDengine() {
     # Start to update
-    if [ ! -e ${tarName} ]; then
-        echo "File ${tarName} does not exist"
-        exit 1
-    fi
-    tar -zxf ${tarName}
-
     echo -e "${GREEN}Start to update ${productName} client...${NC}"
     # Stop the client shell if running
     if pidof ${clientName} &> /dev/null; then
@@ -271,18 +264,10 @@ function update_TDengine() {
 
     echo
     echo -e "\033[44;32;1m${productName} client is updated successfully!${NC}"
-
-    rm -rf $(tar -tf ${tarName})
 }
 
 function install_TDengine() {
   # Start to install
-  if [ ! -e ${tarName} ]; then
-    echo "File ${tarName} does not exist"
-    exit 1
-  fi
-  tar -zxf ${tarName}
-
   echo -e "${GREEN}Start to install ${productName} client...${NC}"
 
   install_main_path

packaging/tools/makearbi.sh

@@ -22,7 +22,7 @@ productName="TDengine"
 
 # create compressed install file.
 build_dir="${compile_dir}/build"
-code_dir="${top_dir}/src"
+code_dir="${top_dir}"
 release_dir="${top_dir}/release"
 
 #package_name='linux'
@@ -36,7 +36,7 @@ fi
 bin_files="${build_dir}/bin/tarbitrator ${script_dir}/remove_arbi.sh"
 install_files="${script_dir}/install_arbi.sh"
 
-#header_files="${code_dir}/inc/taos.h ${code_dir}/inc/taosdef.h ${code_dir}/inc/taoserror.h"
+#header_files="${code_dir}/include/client/taos.h ${code_dir}/include/common/taosdef.h ${code_dir}/include/util/taoserror.h"
 init_file_tarbitrator_deb=${script_dir}/../deb/tarbitratord
 init_file_tarbitrator_rpm=${script_dir}/../rpm/tarbitratord
 

packaging/tools/makeclient.sh

@@ -32,7 +32,7 @@ fi
 
 # create compressed install file.
 build_dir="${compile_dir}/build"
-code_dir="${top_dir}/src"
+code_dir="${top_dir}"
 release_dir="${top_dir}/release"
 
 #package_name='linux'
@@ -62,7 +62,7 @@ else
   lib_files="${build_dir}/lib/libtaos.${version}.dylib"
 fi
 
-header_files="${code_dir}/inc/taos.h ${code_dir}/inc/taosdef.h ${code_dir}/inc/taoserror.h"
+header_files="${code_dir}/include/client/taos.h ${code_dir}/include/common/taosdef.h ${code_dir}/include/util/taoserror.h"
 if [ "$dbName" != "taos" ]; then
   cfg_dir="${top_dir}/../enterprise/packaging/cfg"
 else
@@ -152,7 +152,7 @@ if [[ $productName == "TDengine" ]]; then
     cp -r ${examples_dir}/go ${install_dir}/examples
     cp -r ${examples_dir}/nodejs ${install_dir}/examples
     cp -r ${examples_dir}/C# ${install_dir}/examples
-    mkdir -p ${install_dir}/examples/taosbenchmark-json && cp ${examples_dir}/../src/kit/taos-tools/example/* ${install_dir}/examples/taosbenchmark-json
+    mkdir -p ${install_dir}/examples/taosbenchmark-json && cp ${examples_dir}/../tools/taos-tools/example/* ${install_dir}/examples/taosbenchmark-json
   fi
 
   if [ "$verMode" == "cluster" ]; then
@@ -199,8 +199,8 @@ if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
   else
     echo "WARNING: go connector not found, please check if want to use it!"
   fi
-  cp -r ${connector_dir}/python ${install_dir}/connector
-  cp -r ${connector_dir}/nodejs ${install_dir}/connector
+  cp -r ${connector_dir}/python ${install_dir}/connector || :
+  cp -r ${connector_dir}/nodejs ${install_dir}/connector || :
 fi
 # Copy release note
 # cp ${script_dir}/release_note ${install_dir}

packaging/tools/makepkg.sh

@@ -33,7 +33,7 @@ defaultPasswd="taosdata"
 
 # create compressed install file.
 build_dir="${compile_dir}/build"
-code_dir="${top_dir}/src"
+code_dir="${top_dir}"
 release_dir="${top_dir}/release"
 
 #package_name='linux'
@@ -43,8 +43,8 @@ else
   install_dir="${release_dir}/${productName}-server-${version}"
 fi
 
-if [ -d ${top_dir}/src/kit/taos-tools/packaging/deb ]; then
-  cd ${top_dir}/src/kit/taos-tools/packaging/deb
+if [ -d ${top_dir}/tools/taos-tools/packaging/deb ]; then
+  cd ${top_dir}/tools/taos-tools/packaging/deb
   [ -z "$taos_tools_ver" ] && taos_tools_ver="0.1.0"
 
   taostools_ver=$(git describe --tags | sed -e 's/ver-//g' | awk -F '-' '{print $1}')
@@ -94,7 +94,7 @@ else
 fi
 
 lib_files="${build_dir}/lib/libtaos.so.${version}"
-header_files="${code_dir}/inc/taos.h ${code_dir}/inc/taosdef.h ${code_dir}/inc/taoserror.h"
+header_files="${code_dir}/include/client/taos.h ${code_dir}/include/common/taosdef.h ${code_dir}/include/util/taoserror.h"
 
 if [ "$dbName" != "taos" ]; then
   cfg_dir="${top_dir}/../enterprise/packaging/cfg"
@@ -103,7 +103,7 @@ else
 fi
 
 install_files="${script_dir}/install.sh"
-nginx_dir="${code_dir}/../../enterprise/src/plugins/web"
+nginx_dir="${top_dir}/../enterprise/src/plugins/web"
 
 init_file_deb=${script_dir}/../deb/taosd
 init_file_rpm=${script_dir}/../rpm/taosd
@@ -162,8 +162,8 @@ if [ -n "${taostools_bin_files}" ]; then
         && cp ${taostools_bin_files} ${taostools_install_dir}/bin \
         && chmod a+x ${taostools_install_dir}/bin/* || :
 
-    if [ -f ${top_dir}/src/kit/taos-tools/packaging/tools/install-taostools.sh ]; then
-        cp ${top_dir}/src/kit/taos-tools/packaging/tools/install-taostools.sh \
+    if [ -f ${top_dir}/tools/taos-tools/packaging/tools/install-taostools.sh ]; then
+        cp ${top_dir}/tools/taos-tools/packaging/tools/install-taostools.sh \
             ${taostools_install_dir}/ > /dev/null \
             && chmod a+x ${taostools_install_dir}/install-taostools.sh \
             || echo -e "failed to copy install-taostools.sh"
@@ -171,8 +171,8 @@ if [ -n "${taostools_bin_files}" ]; then
         echo -e "install-taostools.sh not found"
     fi
 
-    if [ -f ${top_dir}/src/kit/taos-tools/packaging/tools/uninstall-taostools.sh ]; then
-        cp ${top_dir}/src/kit/taos-tools/packaging/tools/uninstall-taostools.sh \
+    if [ -f ${top_dir}/tools/taos-tools/packaging/tools/uninstall-taostools.sh ]; then
+        cp ${top_dir}/tools/taos-tools/packaging/tools/uninstall-taostools.sh \
             ${taostools_install_dir}/ > /dev/null \
             && chmod a+x ${taostools_install_dir}/uninstall-taostools.sh \
             || echo -e "failed to copy uninstall-taostools.sh"
@@ -288,7 +288,7 @@ if [[ $dbName == "taos" ]]; then
     cp -r ${examples_dir}/go ${install_dir}/examples
     cp -r ${examples_dir}/nodejs ${install_dir}/examples
     cp -r ${examples_dir}/C# ${install_dir}/examples
-    mkdir -p ${install_dir}/examples/taosbenchmark-json && cp ${examples_dir}/../src/kit/taos-tools/example/* ${install_dir}/examples/taosbenchmark-json
+    mkdir -p ${install_dir}/examples/taosbenchmark-json && cp ${examples_dir}/../tools/taos-tools/example/* ${install_dir}/examples/taosbenchmark-json
   fi
 fi
 

source/client/src/clientEnv.c

@@ -60,7 +60,7 @@ static void registerRequest(SRequestObj *pRequest) {
 static void deregisterRequest(SRequestObj *pRequest) {
   assert(pRequest != NULL);
 
-  STscObj          *pTscObj = pRequest->pTscObj;
+  STscObj *         pTscObj = pRequest->pTscObj;
   SInstanceSummary *pActivity = &pTscObj->pAppInfo->summary;
 
   int32_t currentInst = atomic_sub_fetch_64((int64_t *)&pActivity->currentRequests, 1);
@@ -91,7 +91,6 @@ static bool clientRpcRfp(int32_t code) {
   }
 }
 
-
 // TODO refactor
 void *openTransporter(const char *user, const char *auth, int32_t numOfThread) {
   SRpcInit rpcInit;
@@ -105,10 +104,6 @@ void *openTransporter(const char *user, const char *auth, int32_t numOfThread) {
   rpcInit.connType = TAOS_CONN_CLIENT;
   rpcInit.user = (char *)user;
   rpcInit.idleTime = tsShellActivityTimer * 1000;
-  rpcInit.ckey = "key";
-  rpcInit.spi = 1;
-  rpcInit.secret = (char *)auth;
-
   void *pDnodeConn = rpcOpen(&rpcInit);
   if (pDnodeConn == NULL) {
     tscError("failed to init connection to server");
@@ -318,7 +313,7 @@ int taos_options_imp(TSDB_OPTION option, const char *str) {
     return 0;
   }
 
-  SConfig     *pCfg = taosGetCfg();
+  SConfig *    pCfg = taosGetCfg();
   SConfigItem *pItem = NULL;
 
   switch (option) {

source/client/src/clientImpl.c

@@ -339,7 +339,7 @@ int32_t validateSversion(SRequestObj* pRequest, void* res) {
     }
 
     for (int32_t i = 0; i < pRsp->nBlocks; ++i) {
-      SSubmitBlkRsp *blk = pRsp->pBlocks + i;
+      SSubmitBlkRsp* blk = pRsp->pBlocks + i;
       STbSVersion    tbSver = {.tbFName = blk->tblFName, .sver = blk->sver};
       taosArrayPush(pArray, &tbSver);
     }
@@ -1038,7 +1038,6 @@ TSDB_SERVER_STATUS taos_check_server_status(const char* fqdn, int port, char* de
   SRpcInit           rpcInit = {0};
   char               pass[TSDB_PASSWORD_LEN + 1] = {0};
 
-  taosEncryptPass_c((uint8_t*)("_pwd"), strlen("_pwd"), pass);
   rpcInit.label = "CHK";
   rpcInit.numOfThreads = 1;
   rpcInit.cfp = NULL;
@@ -1046,9 +1045,6 @@ TSDB_SERVER_STATUS taos_check_server_status(const char* fqdn, int port, char* de
   rpcInit.connType = TAOS_CONN_CLIENT;
   rpcInit.idleTime = tsShellActivityTimer * 1000;
   rpcInit.user = "_dnd";
-  rpcInit.ckey = "_key";
-  rpcInit.spi = 1;
-  rpcInit.secret = pass;
 
   clientRpc = rpcOpen(&rpcInit);
   if (clientRpc == NULL) {

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

@@ -126,7 +126,6 @@ static void vmProcessWriteQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numO
       syncGetEpSet(vnodeGetSyncHandle(pVnode->pImpl), &newEpSet);
       newEpSet.inUse = (newEpSet.inUse + 1) % newEpSet.numOfEps;
       tmsgSendRedirectRsp(&rsp, &newEpSet);
-
     } else if (ret == TAOS_SYNC_PROPOSE_OTHER_ERROR) {
       rsp.code = TSDB_CODE_SYN_INTERNAL_ERROR;
       tmsgSendRsp(&rsp);

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

@@ -103,7 +103,7 @@ static inline int32_t dmPushToProcQueue(SProc *proc, SProcQueue *queue, SRpcMsg
     return -1;
   }
 
-  if (ftype == DND_FUNC_REQ && IsReq(pMsg) && pMsg->code == 0 && handle != 0) {
+  if (ftype == DND_FUNC_REQ && IsReq(pMsg) && pMsg->code == 0 && handle != 0 && pMsg->info.noResp == 0) {
     if (taosHashPut(proc->hash, &handle, sizeof(int64_t), &pMsg->info, sizeof(SRpcConnInfo)) != 0) {
       taosThreadMutexUnlock(&queue->mutex);
       return -1;

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

@@ -49,9 +49,9 @@ int32_t dmProcessNodeMsg(SMgmtWrapper *pWrapper, SRpcMsg *pMsg) {
 }
 
 static void dmProcessRpcMsg(SDnode *pDnode, SRpcMsg *pRpc, SEpSet *pEpSet) {
-  SDnodeTrans  *pTrans = &pDnode->trans;
+  SDnodeTrans * pTrans = &pDnode->trans;
   int32_t       code = -1;
-  SRpcMsg      *pMsg = NULL;
+  SRpcMsg *     pMsg = NULL;
   bool          needRelease = false;
   SDnodeHandle *pHandle = &pTrans->msgHandles[TMSG_INDEX(pRpc->msgType)];
   SMgmtWrapper *pWrapper = NULL;
@@ -179,11 +179,11 @@ int32_t dmInitMsgHandle(SDnode *pDnode) {
 
   for (EDndNodeType ntype = DNODE; ntype < NODE_END; ++ntype) {
     SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype];
-    SArray       *pArray = (*pWrapper->func.getHandlesFp)();
+    SArray *      pArray = (*pWrapper->func.getHandlesFp)();
     if (pArray == NULL) return -1;
 
     for (int32_t i = 0; i < taosArrayGetSize(pArray); ++i) {
-      SMgmtHandle  *pMgmt = taosArrayGet(pArray, i);
+      SMgmtHandle * pMgmt = taosArrayGet(pArray, i);
       SDnodeHandle *pHandle = &pTrans->msgHandles[TMSG_INDEX(pMgmt->msgType)];
       if (pMgmt->needCheckVgId) {
         pHandle->needCheckVgId = pMgmt->needCheckVgId;
@@ -200,47 +200,6 @@ int32_t dmInitMsgHandle(SDnode *pDnode) {
   return 0;
 }
 
-static void dmSendRpcRedirectRsp(const SRpcMsg *pMsg) {
-  SDnode *pDnode = dmInstance();
-  SEpSet  epSet = {0};
-  dmGetMnodeEpSet(&pDnode->data, &epSet);
-
-  dDebug("RPC %p, req is redirected, num:%d use:%d", pMsg->info.handle, epSet.numOfEps, epSet.inUse);
-  for (int32_t i = 0; i < epSet.numOfEps; ++i) {
-    dDebug("mnode index:%d %s:%u", i, epSet.eps[i].fqdn, epSet.eps[i].port);
-    if (strcmp(epSet.eps[i].fqdn, tsLocalFqdn) == 0 && epSet.eps[i].port == tsServerPort) {
-      epSet.inUse = (i + 1) % epSet.numOfEps;
-    }
-
-    epSet.eps[i].port = htons(epSet.eps[i].port);
-  }
-
-  SMEpSet msg = {.epSet = epSet};
-  int32_t len = tSerializeSMEpSet(NULL, 0, &msg);
-
-  SRpcMsg rsp = {
-      .code = TSDB_CODE_RPC_REDIRECT,
-      .info = pMsg->info,
-      .contLen = len,
-  };
-  rsp.pCont = rpcMallocCont(len);
-  tSerializeSMEpSet(rsp.pCont, len, &msg);
-  rpcSendResponse(&rsp);
-
-  rpcFreeCont(pMsg->pCont);
-}
-
-static inline void dmSendRecv(SEpSet *pEpSet, SRpcMsg *pReq, SRpcMsg *pRsp) {
-  SDnode *pDnode = dmInstance();
-  if (pDnode->status != DND_STAT_RUNNING) {
-    pRsp->code = TSDB_CODE_NODE_OFFLINE;
-    rpcFreeCont(pReq->pCont);
-    pReq->pCont = NULL;
-  } else {
-    rpcSendRecv(pDnode->trans.clientRpc, pEpSet, pReq, pRsp);
-  }
-}
-
 static inline int32_t dmSendReq(const SEpSet *pEpSet, SRpcMsg *pMsg) {
   SDnode *pDnode = dmInstance();
   if (pDnode->status != DND_STAT_RUNNING) {
@@ -257,39 +216,38 @@ static inline int32_t dmSendReq(const SEpSet *pEpSet, SRpcMsg *pMsg) {
 
 static inline void dmSendRsp(SRpcMsg *pMsg) {
   SMgmtWrapper *pWrapper = pMsg->info.wrapper;
-  if (pMsg->code == TSDB_CODE_NODE_REDIRECT) {
-    dmSendRpcRedirectRsp(pMsg);
-  } else {
   if (InChildProc(pWrapper)) {
     dmPutToProcPQueue(&pWrapper->proc, pMsg, DND_FUNC_RSP);
+    rpcFreeCont(pMsg->pCont);
+    pMsg->pCont = NULL;
   } else {
     rpcSendResponse(pMsg);
   }
-  }
 }
 
 static inline void dmSendRedirectRsp(SRpcMsg *pMsg, const SEpSet *pNewEpSet) {
-  SMgmtWrapper *pWrapper = pMsg->info.wrapper;
-  if (InChildProc(pWrapper)) {
-    dmPutToProcPQueue(&pWrapper->proc, pMsg, DND_FUNC_RSP);
-  } else {
-    SRpcMsg rsp = {0};
+  SRpcMsg rsp = {.code = TSDB_CODE_RPC_REDIRECT, .info = pMsg->info};
   SMEpSet msg = {.epSet = *pNewEpSet};
-    int32_t len = tSerializeSMEpSet(NULL, 0, &msg);
-    rsp.pCont = rpcMallocCont(len);
-    rsp.contLen = len;
-    tSerializeSMEpSet(rsp.pCont, len, &msg);
+  int32_t contLen = tSerializeSMEpSet(NULL, 0, &msg);
 
-    rsp.code = TSDB_CODE_RPC_REDIRECT;
-    rsp.info = pMsg->info;
-    rpcSendResponse(&rsp);
+  rsp.pCont = rpcMallocCont(contLen);
+  if (rsp.pCont == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+  } else {
+    tSerializeSMEpSet(rsp.pCont, contLen, &msg);
+    rsp.contLen = contLen;
   }
+  dmSendRsp(&rsp);
+  rpcFreeCont(pMsg->pCont);
+  pMsg->pCont = NULL;
 }
 
 static inline void dmRegisterBrokenLinkArg(SRpcMsg *pMsg) {
   SMgmtWrapper *pWrapper = pMsg->info.wrapper;
   if (InChildProc(pWrapper)) {
     dmPutToProcPQueue(&pWrapper->proc, pMsg, DND_FUNC_REGIST);
+    rpcFreeCont(pMsg->pCont);
+    pMsg->pCont = NULL;
   } else {
     rpcRegisterBrokenLinkArg(pMsg);
   }
@@ -318,15 +276,9 @@ int32_t dmInitClient(SDnode *pDnode) {
   rpcInit.connType = TAOS_CONN_CLIENT;
   rpcInit.idleTime = tsShellActivityTimer * 1000;
   rpcInit.user = INTERNAL_USER;
-  rpcInit.ckey = INTERNAL_CKEY;
-  rpcInit.spi = 1;
   rpcInit.parent = pDnode;
   rpcInit.rfp = rpcRfp;
 
-  char pass[TSDB_PASSWORD_LEN + 1] = {0};
-  taosEncryptPass_c((uint8_t *)(INTERNAL_SECRET), strlen(INTERNAL_SECRET), pass);
-  rpcInit.secret = pass;
-
   pTrans->clientRpc = rpcOpen(&rpcInit);
   if (pTrans->clientRpc == NULL) {
     dError("failed to init dnode rpc client");
@@ -391,3 +343,34 @@ SMsgCb dmGetMsgcb(SDnode *pDnode) {
   };
   return msgCb;
 }
+
+static void dmSendMnodeRedirectRsp(SRpcMsg *pMsg) {
+  SDnode *pDnode = dmInstance();
+  SEpSet  epSet = {0};
+  dmGetMnodeEpSet(&pDnode->data, &epSet);
+
+  dDebug("msg:%p, is redirected, num:%d use:%d", pMsg, epSet.numOfEps, epSet.inUse);
+  for (int32_t i = 0; i < epSet.numOfEps; ++i) {
+    dDebug("mnode index:%d %s:%u", i, epSet.eps[i].fqdn, epSet.eps[i].port);
+    if (strcmp(epSet.eps[i].fqdn, tsLocalFqdn) == 0 && epSet.eps[i].port == tsServerPort) {
+      epSet.inUse = (i + 1) % epSet.numOfEps;
+    }
+
+    epSet.eps[i].port = htons(epSet.eps[i].port);
+  }
+
+  SRpcMsg rsp = {.code = TSDB_CODE_RPC_REDIRECT, .info = pMsg->info};
+  SMEpSet msg = {.epSet = epSet};
+  int32_t contLen = tSerializeSMEpSet(NULL, 0, &msg);
+  rsp.pCont = rpcMallocCont(contLen);
+  if (rsp.pCont == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+  } else {
+    tSerializeSMEpSet(rsp.pCont, contLen, &msg);
+    rsp.contLen = contLen;
+  }
+
+  dmSendRsp(&rsp);
+  rpcFreeCont(pMsg->pCont);
+  pMsg->pCont = NULL;
+}

source/dnode/mgmt/test/sut/src/client.cpp

@@ -48,10 +48,10 @@ void TestClient::DoInit() {
   rpcInit.connType = TAOS_CONN_CLIENT;
   rpcInit.idleTime = 30 * 1000;
   rpcInit.user = (char*)this->user;
-  rpcInit.ckey = (char*)"key";
+  // rpcInit.ckey = (char*)"key";
   rpcInit.parent = this;
-  rpcInit.secret = (char*)secretEncrypt;
-  rpcInit.spi = 1;
+  // rpcInit.secret = (char*)secretEncrypt;
+  // rpcInit.spi = 1;
 
   clientRpc = rpcOpen(&rpcInit);
   ASSERT(clientRpc);

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

@@ -85,10 +85,9 @@ int vnodeAsyncCommit(SVnode* pVnode);
 int32_t   vnodeSyncOpen(SVnode* pVnode, char* path);
 int32_t   vnodeSyncStart(SVnode* pVnode);
 void      vnodeSyncClose(SVnode* pVnode);
-void      vnodeSyncSetQ(SVnode* pVnode, void* qHandle);
-void      vnodeSyncSetRpc(SVnode* pVnode, void* rpcHandle);
-int32_t   vnodeSyncEqMsg(void* qHandle, SRpcMsg* pMsg);
-int32_t   vnodeSendMsg(void* rpcHandle, const SEpSet* pEpSet, SRpcMsg* pMsg);
+void      vnodeSyncSetMsgCb(SVnode* pVnode);
+int32_t   vnodeSyncEqMsg(const SMsgCb* msgcb, SRpcMsg* pMsg);
+int32_t   vnodeSyncSendMsg(const SEpSet* pEpSet, SRpcMsg* pMsg);
 void      vnodeSyncCommitCb(struct SSyncFSM* pFsm, const SRpcMsg* pMsg, SFsmCbMeta cbMeta);
 void      vnodeSyncPreCommitCb(struct SSyncFSM* pFsm, const SRpcMsg* pMsg, SFsmCbMeta cbMeta);
 void      vnodeSyncRollBackCb(struct SSyncFSM* pFsm, const SRpcMsg* pMsg, SFsmCbMeta cbMeta);

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

@@ -112,21 +112,20 @@ int32_t tqUpdateTbUidList(STQ* pTq, const SArray* tbUidList, bool isAdd) {
     if (pIter == NULL) break;
     pExec = (STqExec*)pIter;
     if (pExec->subType == TOPIC_SUB_TYPE__DB) {
-      if (isAdd) {
-        continue;
-      } else {
+      if (!isAdd) {
         int32_t sz = taosArrayGetSize(tbUidList);
         for (int32_t i = 0; i < sz; i++) {
           int64_t tbUid = *(int64_t*)taosArrayGet(tbUidList, i);
           taosHashPut(pExec->pDropTbUid, &tbUid, sizeof(int64_t), NULL, 0);
         }
       }
-    }
+    } else {
       for (int32_t i = 0; i < 5; i++) {
         int32_t code = qUpdateQualifiedTableId(pExec->task[i], tbUidList, isAdd);
         ASSERT(code == 0);
       }
     }
+  }
   return 0;
 }
 
@@ -1059,6 +1058,57 @@ int32_t tqProcessStreamTrigger(STQ* pTq, void* data, int32_t dataLen, int32_t wo
   return 0;
 }
 
+int32_t tqProcessStreamTriggerNew(STQ* pTq, SSubmitReq* data) {
+  SStreamDataSubmit* pSubmit = NULL;
+
+  // build data
+  pSubmit = taosAllocateQitem(sizeof(SStreamDataSubmit), DEF_QITEM);
+  if (pSubmit == NULL) return -1;
+  pSubmit->dataRef = taosMemoryMalloc(sizeof(int32_t));
+  if (pSubmit->dataRef == NULL) goto FAIL;
+  *pSubmit->dataRef = 1;
+  pSubmit->data = data;
+  pSubmit->type = STREAM_INPUT__DATA_BLOCK;
+
+  void* pIter = NULL;
+  while (1) {
+    pIter = taosHashIterate(pTq->pStreamTasks, pIter);
+    if (pIter == NULL) break;
+    SStreamTask* pTask = (SStreamTask*)pIter;
+    if (pTask->inputType == TASK_INPUT_TYPE__SUMBIT_BLOCK) {
+      streamEnqueueDataSubmit(pTask, pSubmit);
+      // TODO cal back pressure
+    }
+    // check run
+    int8_t execStatus = atomic_load_8(&pTask->status);
+    if (execStatus == TASK_STATUS__IDLE || execStatus == TASK_STATUS__CLOSING) {
+      SStreamTaskRunReq* pReq = taosMemoryMalloc(sizeof(SStreamTaskRunReq));
+      if (pReq == NULL) continue;
+      // TODO: do we need htonl?
+      pReq->head.vgId = pTq->pVnode->config.vgId;
+      pReq->streamId = pTask->streamId;
+      pReq->taskId = pTask->taskId;
+      SRpcMsg msg = {
+          .msgType = 0,
+          .pCont = pReq,
+          .contLen = sizeof(SStreamTaskRunReq),
+      };
+      tmsgPutToQueue(&pTq->pVnode->msgCb, FETCH_QUEUE, &msg);
+    }
+  }
+  streamDataSubmitRefDec(pSubmit);
+
+  return 0;
+FAIL:
+  if (pSubmit) {
+    if (pSubmit->dataRef) {
+      taosMemoryFree(pSubmit->dataRef);
+    }
+    taosFreeQitem(pSubmit);
+  }
+  return -1;
+}
+
 int32_t tqProcessTaskExec(STQ* pTq, char* msg, int32_t msgLen, int32_t workerId) {
   SStreamTaskExecReq req;
   tDecodeSStreamTaskExecReq(msg, &req);

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

@@ -34,21 +34,11 @@ STqReadHandle* tqInitSubmitMsgScanner(SMeta* pMeta) {
 
 int32_t tqReadHandleSetMsg(STqReadHandle* pReadHandle, SSubmitReq* pMsg, int64_t ver) {
   pReadHandle->pMsg = pMsg;
-  // pMsg->length = htonl(pMsg->length);
-  // pMsg->numOfBlocks = htonl(pMsg->numOfBlocks);
 
-  // iterate and convert
   if (tInitSubmitMsgIter(pMsg, &pReadHandle->msgIter) < 0) return -1;
   while (true) {
     if (tGetSubmitMsgNext(&pReadHandle->msgIter, &pReadHandle->pBlock) < 0) return -1;
     if (pReadHandle->pBlock == NULL) break;
-
-    // pReadHandle->pBlock->uid = htobe64(pReadHandle->pBlock->uid);
-    // pReadHandle->pBlock->suid = htobe64(pReadHandle->pBlock->suid);
-    // pReadHandle->pBlock->sversion = htonl(pReadHandle->pBlock->sversion);
-    // pReadHandle->pBlock->dataLen = htonl(pReadHandle->pBlock->dataLen);
-    // pReadHandle->pBlock->schemaLen = htonl(pReadHandle->pBlock->schemaLen);
-    // pReadHandle->pBlock->numOfRows = htons(pReadHandle->pBlock->numOfRows);
   }
 
   if (tInitSubmitMsgIter(pMsg, &pReadHandle->msgIter) < 0) return -1;

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

@@ -180,8 +180,7 @@ void vnodeClose(SVnode *pVnode) {
 
 // start the sync timer after the queue is ready
 int32_t vnodeStart(SVnode *pVnode) {
-  vnodeSyncSetQ(pVnode, NULL);
-  vnodeSyncSetRpc(pVnode, NULL);
+  vnodeSyncSetMsgCb(pVnode);
   vnodeSyncStart(pVnode);
   return 0;
 }

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

@@ -27,9 +27,8 @@ int32_t vnodeSyncOpen(SVnode *pVnode, char *path) {
   syncInfo.pWal = pVnode->pWal;
 
   syncInfo.pFsm = syncVnodeMakeFsm(pVnode);
-  syncInfo.rpcClient = NULL;
-  syncInfo.FpSendMsg = vnodeSendMsg;
-  syncInfo.queue = NULL;
+  syncInfo.msgcb = NULL;
+  syncInfo.FpSendMsg = vnodeSyncSendMsg;
   syncInfo.FpEqMsg = vnodeSyncEqMsg;
 
   pVnode->sync = syncOpen(&syncInfo);
@@ -53,31 +52,13 @@ void vnodeSyncClose(SVnode *pVnode) {
   syncStop(pVnode->sync);
 }
 
-void vnodeSyncSetQ(SVnode *pVnode, void *qHandle) { syncSetQ(pVnode->sync, (void *)(&(pVnode->msgCb))); }
+void vnodeSyncSetMsgCb(SVnode *pVnode) { syncSetMsgCb(pVnode->sync, &pVnode->msgCb); }
 
-void vnodeSyncSetRpc(SVnode *pVnode, void *rpcHandle) { syncSetRpc(pVnode->sync, (void *)(&(pVnode->msgCb))); }
+int32_t vnodeSyncEqMsg(const SMsgCb *msgcb, SRpcMsg *pMsg) { return tmsgPutToQueue(msgcb, SYNC_QUEUE, pMsg); }
 
-int32_t vnodeSyncEqMsg(void *qHandle, SRpcMsg *pMsg) {
-  int32_t ret = 0;
-  SMsgCb *pMsgCb = qHandle;
-  if (pMsgCb->queueFps[SYNC_QUEUE] != NULL) {
-    tmsgPutToQueue(qHandle, SYNC_QUEUE, pMsg);
-  } else {
-    vError("vnodeSyncEqMsg queue is NULL, SYNC_QUEUE:%d", SYNC_QUEUE);
-  }
-  return ret;
-}
-
-int32_t vnodeSendMsg(void *rpcHandle, const SEpSet *pEpSet, SRpcMsg *pMsg) {
-  int32_t ret = 0;
-  SMsgCb *pMsgCb = rpcHandle;
-  if (pMsgCb->queueFps[SYNC_QUEUE] != NULL) {
+int32_t vnodeSyncSendMsg(const SEpSet *pEpSet, SRpcMsg *pMsg) {
   pMsg->info.noResp = 1;
-    tmsgSendReq(pEpSet, pMsg);
-  } else {
-    vError("vnodeSendMsg queue is NULL, SYNC_QUEUE:%d", SYNC_QUEUE);
-  }
-  return ret;
+  return tmsgSendReq(pEpSet, pMsg);
 }
 
 int32_t vnodeSyncGetSnapshotCb(struct SSyncFSM *pFsm, SSnapshot *pSnapshot) {

source/libs/function/src/udfd.c

@@ -27,16 +27,16 @@
 #include "trpc.h"
 
 typedef struct SUdfdContext {
-  uv_loop_t  *loop;
+  uv_loop_t * loop;
   uv_pipe_t   ctrlPipe;
   uv_signal_t intrSignal;
   char        listenPipeName[PATH_MAX + UDF_LISTEN_PIPE_NAME_LEN + 2];
   uv_pipe_t   listeningPipe;
 
-  void       *clientRpc;
+  void *     clientRpc;
   SCorEpSet  mgmtEp;
   uv_mutex_t udfsMutex;
-  SHashObj  *udfsHash;
+  SHashObj * udfsHash;
 
   bool printVersion;
 } SUdfdContext;
@@ -45,7 +45,7 @@ SUdfdContext global;
 
 typedef struct SUdfdUvConn {
   uv_stream_t *client;
-  char        *inputBuf;
+  char *       inputBuf;
   int32_t      inputLen;
   int32_t      inputCap;
   int32_t      inputTotal;
@@ -99,7 +99,7 @@ typedef enum EUdfdRpcReqRspType {
 typedef struct SUdfdRpcSendRecvInfo {
   EUdfdRpcReqRspType rpcType;
   int32_t            code;
-  void* param;
+  void *             param;
   uv_sem_t           resultSem;
 } SUdfdRpcSendRecvInfo;
 
@@ -136,7 +136,7 @@ void udfdProcessRpcRsp(void *parent, SRpcMsg *pMsg, SEpSet *pEpSet) {
     tDeserializeSRetrieveFuncRsp(pMsg->pCont, pMsg->contLen, &retrieveRsp);
 
     SFuncInfo *pFuncInfo = (SFuncInfo *)taosArrayGet(retrieveRsp.pFuncInfos, 0);
-    SUdf* udf = msgInfo->param;
+    SUdf *     udf = msgInfo->param;
     udf->funcType = pFuncInfo->funcType;
     udf->scriptType = pFuncInfo->scriptType;
     udf->outputType = pFuncInfo->outputType;
@@ -145,7 +145,8 @@ void udfdProcessRpcRsp(void *parent, SRpcMsg *pMsg, SEpSet *pEpSet) {
 
     char path[PATH_MAX] = {0};
     snprintf(path, sizeof(path), "%s/lib%s.so", "/tmp", pFuncInfo->name);
-    TdFilePtr file = taosOpenFile(path, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_READ | TD_FILE_TRUNC | TD_FILE_AUTO_DEL);
+    TdFilePtr file =
+        taosOpenFile(path, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_READ | TD_FILE_TRUNC | TD_FILE_AUTO_DEL);
     // TODO check for failure of flush to disk
     taosWriteFile(file, pFuncInfo->pCode, pFuncInfo->codeSize);
     taosCloseFile(&file);
@@ -168,11 +169,11 @@ int32_t udfdFillUdfInfoFromMNode(void *clientRpc, char *udfName, SUdf *udf) {
   taosArrayPush(retrieveReq.pFuncNames, udfName);
 
   int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq);
-  void   *pReq = rpcMallocCont(contLen);
+  void *  pReq = rpcMallocCont(contLen);
   tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq);
   taosArrayDestroy(retrieveReq.pFuncNames);
 
-  SUdfdRpcSendRecvInfo* msgInfo = taosMemoryCalloc(1, sizeof(SUdfdRpcSendRecvInfo));
+  SUdfdRpcSendRecvInfo *msgInfo = taosMemoryCalloc(1, sizeof(SUdfdRpcSendRecvInfo));
   msgInfo->rpcType = UDFD_RPC_RETRIVE_FUNC;
   msgInfo->param = udf;
   uv_sem_init(&msgInfo->resultSem, 0);
@@ -194,7 +195,7 @@ int32_t udfdFillUdfInfoFromMNode(void *clientRpc, char *udfName, SUdf *udf) {
 int32_t udfdConnectToMnode() {
   SConnectReq connReq = {0};
   connReq.connType = CONN_TYPE__UDFD;
-  tstrncpy(connReq.app, "udfd",sizeof(connReq.app));
+  tstrncpy(connReq.app, "udfd", sizeof(connReq.app));
   tstrncpy(connReq.user, TSDB_DEFAULT_USER, sizeof(connReq.user));
   char pass[TSDB_PASSWORD_LEN + 1] = {0};
   taosEncryptPass_c((uint8_t *)(TSDB_DEFAULT_PASS), strlen(TSDB_DEFAULT_PASS), pass);
@@ -203,7 +204,7 @@ int32_t udfdConnectToMnode() {
   connReq.startTime = htobe64(taosGetTimestampMs());
 
   int32_t contLen = tSerializeSConnectReq(NULL, 0, &connReq);
-  void*   pReq = rpcMallocCont(contLen);
+  void *  pReq = rpcMallocCont(contLen);
   tSerializeSConnectReq(pReq, contLen, &connReq);
 
   SUdfdRpcSendRecvInfo *msgInfo = taosMemoryCalloc(1, sizeof(SUdfdRpcSendRecvInfo));
@@ -240,17 +241,17 @@ int32_t udfdLoadUdf(char *udfName, SUdf *udf) {
     return TSDB_CODE_UDF_LOAD_UDF_FAILURE;
   }
 
-  char initFuncName[TSDB_FUNC_NAME_LEN+5] = {0};
+  char  initFuncName[TSDB_FUNC_NAME_LEN + 5] = {0};
   char *initSuffix = "_init";
   strcpy(initFuncName, udfName);
   strncat(initFuncName, initSuffix, strlen(initSuffix));
-  uv_dlsym(&udf->lib, initFuncName, (void**)(&udf->initFunc));
+  uv_dlsym(&udf->lib, initFuncName, (void **)(&udf->initFunc));
 
-  char destroyFuncName[TSDB_FUNC_NAME_LEN+5] = {0};
+  char  destroyFuncName[TSDB_FUNC_NAME_LEN + 5] = {0};
   char *destroySuffix = "_destroy";
   strcpy(destroyFuncName, udfName);
   strncat(destroyFuncName, destroySuffix, strlen(destroySuffix));
-  uv_dlsym(&udf->lib, destroyFuncName, (void**)(&udf->destroyFunc));
+  uv_dlsym(&udf->lib, destroyFuncName, (void **)(&udf->destroyFunc));
 
   if (udf->funcType == TSDB_FUNC_TYPE_SCALAR) {
     char processFuncName[TSDB_FUNC_NAME_LEN] = {0};
@@ -270,17 +271,17 @@ int32_t udfdLoadUdf(char *udfName, SUdf *udf) {
     strncpy(finishFuncName, processFuncName, strlen(processFuncName));
     strncat(finishFuncName, finishSuffix, strlen(finishSuffix));
     uv_dlsym(&udf->lib, finishFuncName, (void **)(&udf->aggFinishFunc));
-    //TODO: merge
+    // TODO: merge
   }
   return 0;
 }
 
-void udfdProcessSetupRequest(SUvUdfWork* uvUdf, SUdfRequest* request) {
+void udfdProcessSetupRequest(SUvUdfWork *uvUdf, SUdfRequest *request) {
   // TODO: tracable id from client. connect, setup, call, teardown
-    fnInfo( "setup request. seq num: %" PRId64 ", udf name: %s", request->seqNum, request->setup.udfName);
+  fnInfo("setup request. seq num: %" PRId64 ", udf name: %s", request->seqNum, request->setup.udfName);
   SUdfSetupRequest *setup = &request->setup;
   int32_t           code = TSDB_CODE_SUCCESS;
-    SUdf *udf = NULL;
+  SUdf *            udf = NULL;
   uv_mutex_lock(&global.udfsMutex);
   SUdf **udfInHash = taosHashGet(global.udfsHash, request->setup.udfName, strlen(request->setup.udfName));
   if (udfInHash) {
@@ -341,16 +342,15 @@ void udfdProcessSetupRequest(SUvUdfWork* uvUdf, SUdfRequest* request) {
 
 void udfdProcessCallRequest(SUvUdfWork *uvUdf, SUdfRequest *request) {
   SUdfCallRequest *call = &request->call;
-  fnDebug("%" PRId64 "call request. call type %d, handle: %" PRIx64, request->seqNum, call->callType,
-          call->udfHandle);
-  SUdfcFuncHandle *handle = (SUdfcFuncHandle *)(call->udfHandle);
-  SUdf            *udf = handle->udf;
+  fnDebug("%" PRId64 "call request. call type %d, handle: %" PRIx64, request->seqNum, call->callType, call->udfHandle);
+  SUdfcFuncHandle * handle = (SUdfcFuncHandle *)(call->udfHandle);
+  SUdf *            udf = handle->udf;
   SUdfResponse      response = {0};
-  SUdfResponse *rsp = &response;
+  SUdfResponse *    rsp = &response;
   SUdfCallResponse *subRsp = &rsp->callRsp;
 
   int32_t code = TSDB_CODE_SUCCESS;
-  switch(call->callType) {
+  switch (call->callType) {
     case TSDB_UDF_CALL_SCALA_PROC: {
       SUdfColumn output = {0};
 
@@ -363,9 +363,7 @@ void udfdProcessCallRequest(SUvUdfWork *uvUdf, SUdfRequest *request) {
       break;
     }
     case TSDB_UDF_CALL_AGG_INIT: {
-      SUdfInterBuf outBuf = {.buf = taosMemoryMalloc(udf->bufSize),
-                             .bufLen= udf->bufSize,
-                             .numOfResult = 0};
+      SUdfInterBuf outBuf = {.buf = taosMemoryMalloc(udf->bufSize), .bufLen = udf->bufSize, .numOfResult = 0};
       udf->aggStartFunc(&outBuf);
       subRsp->resultBuf = outBuf;
       break;
@@ -373,9 +371,7 @@ void udfdProcessCallRequest(SUvUdfWork *uvUdf, SUdfRequest *request) {
     case TSDB_UDF_CALL_AGG_PROC: {
       SUdfDataBlock input = {0};
       convertDataBlockToUdfDataBlock(&call->block, &input);
-      SUdfInterBuf outBuf = {.buf = taosMemoryMalloc(udf->bufSize),
-                             .bufLen= udf->bufSize,
-                             .numOfResult = 0};
+      SUdfInterBuf outBuf = {.buf = taosMemoryMalloc(udf->bufSize), .bufLen = udf->bufSize, .numOfResult = 0};
       code = udf->aggProcFunc(&input, &call->interBuf, &outBuf);
       freeUdfInterBuf(&call->interBuf);
       freeUdfDataDataBlock(&input);
@@ -384,9 +380,7 @@ void udfdProcessCallRequest(SUvUdfWork *uvUdf, SUdfRequest *request) {
       break;
     }
     case TSDB_UDF_CALL_AGG_FIN: {
-      SUdfInterBuf outBuf = {.buf = taosMemoryMalloc(udf->bufSize),
-                             .bufLen= udf->bufSize,
-                             .numOfResult = 0};
+      SUdfInterBuf outBuf = {.buf = taosMemoryMalloc(udf->bufSize), .bufLen = udf->bufSize, .numOfResult = 0};
       code = udf->aggFinishFunc(&call->interBuf, &outBuf);
       freeUdfInterBuf(&call->interBuf);
       subRsp->resultBuf = outBuf;
@@ -429,18 +423,17 @@ void udfdProcessCallRequest(SUvUdfWork *uvUdf, SUdfRequest *request) {
     }
     default:
       break;
-
   }
 
   taosMemoryFree(uvUdf->input.base);
   return;
 }
 
-void udfdProcessTeardownRequest(SUvUdfWork* uvUdf, SUdfRequest* request) {
+void udfdProcessTeardownRequest(SUvUdfWork *uvUdf, SUdfRequest *request) {
   SUdfTeardownRequest *teardown = &request->teardown;
   fnInfo("teardown. seq number: %" PRId64 ", handle:%" PRIx64, request->seqNum, teardown->udfHandle);
   SUdfcFuncHandle *handle = (SUdfcFuncHandle *)(teardown->udfHandle);
-  SUdf *udf = handle->udf;
+  SUdf *           udf = handle->udf;
   bool             unloadUdf = false;
   int32_t          code = TSDB_CODE_SUCCESS;
 
@@ -568,7 +561,7 @@ bool isUdfdUvMsgComplete(SUdfdUvConn *pipe) {
 }
 
 void udfdHandleRequest(SUdfdUvConn *conn) {
-  uv_work_t  *work = taosMemoryMalloc(sizeof(uv_work_t));
+  uv_work_t * work = taosMemoryMalloc(sizeof(uv_work_t));
   SUvUdfWork *udfWork = taosMemoryMalloc(sizeof(SUvUdfWork));
   udfWork->client = conn->client;
   udfWork->input = uv_buf_init(conn->inputBuf, conn->inputLen);
@@ -653,11 +646,11 @@ static bool udfdRpcRfp(int32_t code) {
   }
 }
 
-int initEpSetFromCfg(const char* firstEp, const char* secondEp, SCorEpSet* pEpSet) {
+int initEpSetFromCfg(const char *firstEp, const char *secondEp, SCorEpSet *pEpSet) {
   pEpSet->version = 0;
 
   // init mnode ip set
-  SEpSet* mgmtEpSet = &(pEpSet->epSet);
+  SEpSet *mgmtEpSet = &(pEpSet->epSet);
   mgmtEpSet->numOfEps = 0;
   mgmtEpSet->inUse = 0;
 
@@ -694,7 +687,6 @@ int initEpSetFromCfg(const char* firstEp, const char* secondEp, SCorEpSet* pEpSe
   return 0;
 }
 
-
 int32_t udfdOpenClientRpc() {
   SRpcInit rpcInit = {0};
   rpcInit.label = "UDFD";
@@ -704,15 +696,9 @@ int32_t udfdOpenClientRpc() {
   rpcInit.connType = TAOS_CONN_CLIENT;
   rpcInit.idleTime = tsShellActivityTimer * 1000;
   rpcInit.user = TSDB_DEFAULT_USER;
-  rpcInit.ckey = "key";
-  rpcInit.spi = 1;
   rpcInit.parent = &global;
   rpcInit.rfp = udfdRpcRfp;
 
-  char pass[TSDB_PASSWORD_LEN + 1] = {0};
-  taosEncryptPass_c((uint8_t *)(TSDB_DEFAULT_PASS), strlen(TSDB_DEFAULT_PASS), pass);
-  rpcInit.secret = pass;
-
   global.clientRpc = rpcOpen(&rpcInit);
   if (global.clientRpc == NULL) {
     fnError("failed to init dnode rpc client");
@@ -823,7 +809,7 @@ static int32_t udfdUvInit() {
   return 0;
 }
 
-static void udfdCloseWalkCb(uv_handle_t* handle, void* arg) {
+static void udfdCloseWalkCb(uv_handle_t *handle, void *arg) {
   if (!uv_is_closing(handle)) {
     uv_close(handle, NULL);
   }
@@ -883,7 +869,7 @@ int main(int argc, char *argv[]) {
   int32_t retryMnodeTimes = 0;
   int32_t code = 0;
   while (retryMnodeTimes++ < TSDB_MAX_REPLICA) {
-    uv_sleep(500 * ( 1 << retryMnodeTimes));
+    uv_sleep(500 * (1 << retryMnodeTimes));
     code = udfdConnectToMnode();
     if (code == 0) {
       break;

source/libs/function/test/udf2.c

@@ -26,7 +26,7 @@ int32_t udf2_start(SUdfInterBuf *buf) {
 
 int32_t udf2(SUdfDataBlock* block, SUdfInterBuf *interBuf, SUdfInterBuf *newInterBuf) {
   double sumSquares = *(double*)interBuf->buf;
-  int8_t numOutput = 0;
+  int8_t numNotNull = 0;
   for (int32_t i = 0; i < block->numOfCols; ++i) {
     SUdfColumn* col = block->udfCols[i];
     if (!(col->colMeta.type == TSDB_DATA_TYPE_INT || 
@@ -56,15 +56,14 @@ int32_t udf2(SUdfDataBlock* block, SUdfInterBuf *interBuf, SUdfInterBuf *newInte
         default: 
           break;
       }
-      numOutput = 1;
+      ++numNotNull;
     }
   }
 
-  if (numOutput == 1) {
   *(double*)(newInterBuf->buf) = sumSquares;
   newInterBuf->bufLen = sizeof(double);
-  }
-  if (interBuf->numOfResult == 0 && numOutput == 0) {
+
+  if (interBuf->numOfResult == 0 && numNotNull == 0) {
     newInterBuf->numOfResult = 0;
   } else {
     newInterBuf->numOfResult = 1;

source/libs/index/src/indexCache.c

@@ -22,7 +22,7 @@
 #define MAX_INDEX_KEY_LEN 256  // test only, change later
 
 #define MEM_TERM_LIMIT     10 * 10000
-#define MEM_THRESHOLD      1024 * 1024
+#define MEM_THRESHOLD      64 * 1024
 #define MEM_ESTIMATE_RADIO 1.5
 
 static void indexMemRef(MemTable* tbl);

source/libs/index/src/indexFst.c

@@ -99,7 +99,7 @@ void fstUnFinishedNodesAddSuffix(FstUnFinishedNodes* nodes, FstSlice bs, Output
   if (fstSliceIsEmpty(s)) {
     return;
   }
-  size_t                    sz = taosArrayGetSize(nodes->stack) - 1;
+  int32_t                   sz = taosArrayGetSize(nodes->stack) - 1;
   FstBuilderNodeUnfinished* un = taosArrayGet(nodes->stack, sz);
   assert(un->last == NULL);
 
@@ -130,11 +130,11 @@ void fstUnFinishedNodesAddSuffix(FstUnFinishedNodes* nodes, FstSlice bs, Output
 uint64_t fstUnFinishedNodesFindCommPrefix(FstUnFinishedNodes* node, FstSlice bs) {
   FstSlice* s = &bs;
 
-  size_t   ssz = taosArrayGetSize(node->stack);  // stack size
+  int32_t  ssz = taosArrayGetSize(node->stack);  // stack size
   uint64_t count = 0;
   int32_t  lsz;  // data len
   uint8_t* data = fstSliceData(s, &lsz);
-  for (size_t i = 0; i < ssz && i < lsz; i++) {
+  for (int32_t i = 0; i < ssz && i < lsz; i++) {
     FstBuilderNodeUnfinished* un = taosArrayGet(node->stack, i);
     if (un->last->inp == data[i]) {
       count++;
@@ -147,8 +147,8 @@ uint64_t fstUnFinishedNodesFindCommPrefix(FstUnFinishedNodes* node, FstSlice bs)
 uint64_t fstUnFinishedNodesFindCommPrefixAndSetOutput(FstUnFinishedNodes* node, FstSlice bs, Output in, Output* out) {
   FstSlice* s = &bs;
 
-  size_t lsz = (size_t)(s->end - s->start + 1);  // data len
-  size_t ssz = taosArrayGetSize(node->stack);    // stack size
+  int32_t lsz = (size_t)(s->end - s->start + 1);  // data len
+  int32_t ssz = taosArrayGetSize(node->stack);    // stack size
   *out = in;
   uint64_t i = 0;
   for (i = 0; i < lsz && i < ssz; i++) {
@@ -245,7 +245,7 @@ void fstStateCompileForOneTrans(FstCountingWriter* w, CompiledAddr addr, FstTran
   return;
 }
 void fstStateCompileForAnyTrans(FstCountingWriter* w, CompiledAddr addr, FstBuilderNode* node) {
-  size_t sz = taosArrayGetSize(node->trans);
+  int32_t sz = taosArrayGetSize(node->trans);
   assert(sz <= 256);
 
   uint8_t tSize = 0;
@@ -253,7 +253,7 @@ void fstStateCompileForAnyTrans(FstCountingWriter* w, CompiledAddr addr, FstBuil
 
   // finalOutput.is_zero()
   bool anyOuts = (node->finalOutput != 0);
-  for (size_t i = 0; i < sz; i++) {
+  for (int32_t i = 0; i < sz; i++) {
     FstTransition* t = taosArrayGet(node->trans, i);
     tSize = TMAX(tSize, packDeltaSize(addr, t->addr));
     oSize = TMAX(oSize, packSize(t->out));
@@ -301,7 +301,7 @@ void fstStateCompileForAnyTrans(FstCountingWriter* w, CompiledAddr addr, FstBuil
     /// for (uint8_t i = 0; i < 256; i++) {
     //  index[i] = 255;
     ///}
-    for (size_t i = 0; i < sz; i++) {
+    for (int32_t i = 0; i < sz; i++) {
       FstTransition* t = taosArrayGet(node->trans, i);
       index[t->inp] = i;
       // fstPackDeltaIn(w, addr, t->addr, tSize);
@@ -731,7 +731,7 @@ bool fstNodeFindInput(FstNode* node, uint8_t b, uint64_t* res) {
 }
 
 bool fstNodeCompile(FstNode* node, void* w, CompiledAddr lastAddr, CompiledAddr addr, FstBuilderNode* builderNode) {
-  size_t sz = taosArrayGetSize(builderNode->trans);
+  int32_t sz = taosArrayGetSize(builderNode->trans);
   assert(sz < 256);
   if (sz == 0 && builderNode->isFinal && builderNode->finalOutput == 0) {
     return true;
@@ -959,8 +959,8 @@ void fstBuilderNodeUnfinishedAddOutputPrefix(FstBuilderNodeUnfinished* unNode, O
   if (FST_BUILDER_NODE_IS_FINAL(unNode->node)) {
     unNode->node->finalOutput += out;
   }
-  size_t sz = taosArrayGetSize(unNode->node->trans);
-  for (size_t i = 0; i < sz; i++) {
+  int32_t sz = taosArrayGetSize(unNode->node->trans);
+  for (int32_t i = 0; i < sz; i++) {
     FstTransition* trn = taosArrayGet(unNode->node->trans, i);
     trn->out += out;
   }
@@ -1077,7 +1077,7 @@ bool fstGet(Fst* fst, FstSlice* b, Output* out) {
     tOut = tOut + FST_NODE_FINAL_OUTPUT(root);
   }
 
-  for (size_t i = 0; i < taosArrayGetSize(nodes); i++) {
+  for (int32_t i = 0; i < taosArrayGetSize(nodes); i++) {
     FstNode** node = (FstNode**)taosArrayGet(nodes, i);
     fstNodeDestroy(*node);
   }
@@ -1352,7 +1352,7 @@ StreamWithStateResult* streamWithStateNextWith(StreamWithState* sws, StreamCallb
     StreamState s2 = {.node = nextNode, .trans = 0, .out = {.null = false, .out = out}, .autState = nextState};
     taosArrayPush(sws->stack, &s2);
 
-    size_t   isz = taosArrayGetSize(sws->inp);
+    int32_t  isz = taosArrayGetSize(sws->inp);
     uint8_t* buf = (uint8_t*)taosMemoryMalloc(isz * sizeof(uint8_t));
     for (uint32_t i = 0; i < isz; i++) {
       buf[i] = *(uint8_t*)taosArrayGet(sws->inp, i);

source/libs/index/src/indexTfile.c

@@ -116,7 +116,7 @@ TFileCache* tfileCacheCreate(const char* path) {
       continue;
     }
     TFileHeader* header = &reader->header;
-    ICacheKey    key = {.suid = header->suid, .colName = header->colName, .nColName = strlen(header->colName)};
+    ICacheKey    key = {.suid = header->suid, .colName = header->colName, .nColName = (int32_t)strlen(header->colName)};
 
     char    buf[128] = {0};
     int32_t sz = indexSerialCacheKey(&key, buf);
@@ -230,7 +230,7 @@ static int32_t tfSearchTerm(void* reader, SIndexTerm* tem, SIdxTempResult* tr) {
     indexInfo("index: %" PRIu64 ", col: %s, colVal: %s, found table info in tindex, time cost: %" PRIu64 "us",
               tem->suid, tem->colName, tem->colVal, cost);
 
-    ret = tfileReaderLoadTableIds((TFileReader*)reader, offset, tr->total);
+    ret = tfileReaderLoadTableIds((TFileReader*)reader, (int32_t)offset, tr->total);
     cost = taosGetTimestampUs() - et;
     indexInfo("index: %" PRIu64 ", col: %s, colVal: %s, load all table info, time cost: %" PRIu64 "us", tem->suid,
               tem->colName, tem->colVal, cost);
@@ -890,7 +890,7 @@ static int tfileWriteFooter(TFileWriter* write) {
   char  buf[sizeof(tfileMagicNumber) + 1] = {0};
   void* pBuf = (void*)buf;
   taosEncodeFixedU64((void**)(void*)&pBuf, tfileMagicNumber);
-  int nwrite = write->ctx->write(write->ctx, buf, strlen(buf));
+  int nwrite = write->ctx->write(write->ctx, buf, (int32_t)strlen(buf));
 
   indexInfo("tfile write footer size: %d", write->ctx->size(write->ctx));
   assert(nwrite == sizeof(tfileMagicNumber));

source/libs/index/src/indexUtil.c

@@ -37,14 +37,14 @@ static int iBinarySearch(SArray *arr, int s, int e, uint64_t k) {
 }
 
 void iIntersection(SArray *inters, SArray *final) {
-  int32_t sz = taosArrayGetSize(inters);
+  int32_t sz = (int32_t)taosArrayGetSize(inters);
   if (sz <= 0) {
     return;
   }
   MergeIndex *mi = taosMemoryCalloc(sz, sizeof(MergeIndex));
   for (int i = 0; i < sz; i++) {
     SArray *t = taosArrayGetP(inters, i);
-    mi[i].len = taosArrayGetSize(t);
+    mi[i].len = (int32_t)taosArrayGetSize(t);
     mi[i].idx = 0;
   }
 
@@ -70,7 +70,7 @@ void iIntersection(SArray *inters, SArray *final) {
   taosMemoryFreeClear(mi);
 }
 void iUnion(SArray *inters, SArray *final) {
-  int32_t sz = taosArrayGetSize(inters);
+  int32_t sz = (int32_t)taosArrayGetSize(inters);
   if (sz <= 0) {
     return;
   }
@@ -82,7 +82,7 @@ void iUnion(SArray *inters, SArray *final) {
   MergeIndex *mi = taosMemoryCalloc(sz, sizeof(MergeIndex));
   for (int i = 0; i < sz; i++) {
     SArray *t = taosArrayGetP(inters, i);
-    mi[i].len = taosArrayGetSize(t);
+    mi[i].len = (int32_t)taosArrayGetSize(t);
     mi[i].idx = 0;
   }
   while (1) {
@@ -117,8 +117,8 @@ void iUnion(SArray *inters, SArray *final) {
 }
 
 void iExcept(SArray *total, SArray *except) {
-  int32_t tsz = taosArrayGetSize(total);
-  int32_t esz = taosArrayGetSize(except);
+  int32_t tsz = (int32_t)taosArrayGetSize(total);
+  int32_t esz = (int32_t)taosArrayGetSize(except);
   if (esz == 0 || tsz == 0) {
     return;
   }
@@ -141,7 +141,10 @@ int uidCompare(const void *a, const void *b) {
   // add more version compare
   uint64_t u1 = *(uint64_t *)a;
   uint64_t u2 = *(uint64_t *)b;
-  return u1 - u2;
+  if (u1 == u2) {
+    return 0;
+  }
+  return u1 < u2 ? -1 : 1;
 }
 int verdataCompare(const void *a, const void *b) {
   SIdxVerdata *va = (SIdxVerdata *)a;

source/libs/index/test/CMakeLists.txt

@@ -92,7 +92,19 @@ target_link_libraries (jsonUT
   index
 )
 
-#add_test(
-#  NAME index_test
-#  COMMAND indexTest
-#)
+add_test(
+  NAME idxtest
+  COMMAND indexTest
+)
+add_test(
+  NAME idxJsonUT
+  COMMAND jsonUT 
+)
+add_test(
+  NAME idxUtilUT 
+  COMMAND UtilUT 
+)
+add_test(
+  NAME idxFstUT 
+  COMMAND fstUT 
+)

source/libs/index/test/fstTest.cc

@@ -48,7 +48,7 @@ class FstWriter {
 
 class FstReadMemory {
  public:
-  FstReadMemory(size_t size, const std::string& fileName = "/tmp/tindex.tindex") {
+  FstReadMemory(int32_t size, const std::string& fileName = "/tmp/tindex.tindex") {
     _wc = writerCtxCreate(TFile, fileName.c_str(), true, 64 * 1024);
     _w = fstCountingWriterCreate(_wc);
     _size = size;
@@ -152,7 +152,7 @@ class FstReadMemory {
   Fst*               _fst;
   FstSlice           _s;
   WriterCtx*         _wc;
-  size_t             _size;
+  int32_t            _size;
 };
 
 #define L 100

source/libs/index/test/indexTests.cc

@@ -714,7 +714,7 @@ class IndexObj {
     return numOfTable;
   }
   int ReadMultiMillonData(const std::string& colName, const std::string& colVal = "Hello world",
-                          size_t numOfTable = 100 * 10000) {
+                          size_t numOfTable = 100) {
     std::string tColVal = colVal;
 
     int colValSize = tColVal.size();
@@ -896,7 +896,7 @@ TEST_F(IndexEnv2, testIndex_TrigeFlush) {
     // r
     std::cout << "failed to init" << std::endl;
   }
-  int numOfTable = 100 * 10000;
+  int numOfTable = 100 * 100;
   index->WriteMillonData("tag1", "Hello Wolrd", numOfTable);
   int target = index->SearchOne("tag1", "Hello Wolrd");
   std::cout << "Get Index: " << target << std::endl;
@@ -910,8 +910,8 @@ static void single_write_and_search(IndexObj* idx) {
 static void multi_write_and_search(IndexObj* idx) {
   int target = idx->SearchOne("tag1", "Hello");
   target = idx->SearchOne("tag2", "Test");
-  idx->WriteMultiMillonData("tag1", "hello world test", 100 * 10000);
-  idx->WriteMultiMillonData("tag2", "world test nothing", 100 * 10000);
+  idx->WriteMultiMillonData("tag1", "hello world test", 100 * 100);
+  idx->WriteMultiMillonData("tag2", "world test nothing", 100 * 10);
 }
 TEST_F(IndexEnv2, testIndex_serarch_cache_and_tfile) {
   std::string path = "/tmp/cache_and_tfile";
@@ -920,8 +920,8 @@ TEST_F(IndexEnv2, testIndex_serarch_cache_and_tfile) {
   }
   index->PutOne("tag1", "Hello");
   index->PutOne("tag2", "Test");
-  index->WriteMultiMillonData("tag1", "Hello", 100 * 10000);
-  index->WriteMultiMillonData("tag2", "Test", 100 * 10000);
+  index->WriteMultiMillonData("tag1", "Hello", 100 * 100);
+  index->WriteMultiMillonData("tag2", "Test", 100 * 100);
   std::thread threads[NUM_OF_THREAD];
 
   for (int i = 0; i < NUM_OF_THREAD; i++) {
@@ -949,49 +949,49 @@ TEST_F(IndexEnv2, testIndex_MultiWrite_and_MultiRead) {
   }
 }
 
-TEST_F(IndexEnv2, testIndex_restart) {
-  std::string path = "/tmp/cache_and_tfile";
-  if (index->Init(path) != 0) {
-  }
-  index->SearchOneTarget("tag1", "Hello", 10);
-  index->SearchOneTarget("tag2", "Test", 10);
-}
-TEST_F(IndexEnv2, testIndex_restart1) {
-  std::string path = "/tmp/cache_and_tfile";
-  if (index->Init(path) != 0) {
-  }
-  index->ReadMultiMillonData("tag1", "coding");
-  index->SearchOneTarget("tag1", "Hello", 10);
-  index->SearchOneTarget("tag2", "Test", 10);
-}
+// TEST_F(IndexEnv2, testIndex_restart) {
+//  std::string path = "/tmp/cache_and_tfile";
+//  if (index->Init(path) != 0) {
+//  }
+//  index->SearchOneTarget("tag1", "Hello", 10);
+//  index->SearchOneTarget("tag2", "Test", 10);
+//}
+// TEST_F(IndexEnv2, testIndex_restart1) {
+//  std::string path = "/tmp/cache_and_tfile";
+//  if (index->Init(path) != 0) {
+//  }
+//  index->ReadMultiMillonData("tag1", "coding");
+//  index->SearchOneTarget("tag1", "Hello", 10);
+//  index->SearchOneTarget("tag2", "Test", 10);
+//}
 
-TEST_F(IndexEnv2, testIndex_read_performance) {
-  std::string path = "/tmp/cache_and_tfile";
-  if (index->Init(path) != 0) {
-  }
-  index->PutOneTarge("tag1", "Hello", 12);
-  index->PutOneTarge("tag1", "Hello", 15);
-  index->ReadMultiMillonData("tag1", "Hello");
-  std::cout << "reader sz: " << index->SearchOne("tag1", "Hello") << std::endl;
-  assert(3 == index->SearchOne("tag1", "Hello"));
-}
-TEST_F(IndexEnv2, testIndexMultiTag) {
-  std::string path = "/tmp/multi_tag";
-  if (index->Init(path) != 0) {
-  }
-  int64_t st = taosGetTimestampUs();
-  int32_t num = 1000 * 10000;
-  index->WriteMultiMillonData("tag1", "xxxxxxxxxxxxxxx", num);
-  std::cout << "numOfRow: " << num << "\ttime cost:" << taosGetTimestampUs() - st << std::endl;
-  // index->WriteMultiMillonData("tag2", "xxxxxxxxxxxxxxxxxxxxxxxxx", 100 * 10000);
-}
+// TEST_F(IndexEnv2, testIndex_read_performance) {
+//  std::string path = "/tmp/cache_and_tfile";
+//  if (index->Init(path) != 0) {
+//  }
+//  index->PutOneTarge("tag1", "Hello", 12);
+//  index->PutOneTarge("tag1", "Hello", 15);
+//  index->ReadMultiMillonData("tag1", "Hello");
+//  std::cout << "reader sz: " << index->SearchOne("tag1", "Hello") << std::endl;
+//  assert(3 == index->SearchOne("tag1", "Hello"));
+//}
+// TEST_F(IndexEnv2, testIndexMultiTag) {
+//  std::string path = "/tmp/multi_tag";
+//  if (index->Init(path) != 0) {
+//  }
+//  int64_t st = taosGetTimestampUs();
+//  int32_t num = 1000 * 10000;
+//  index->WriteMultiMillonData("tag1", "xxxxxxxxxxxxxxx", num);
+//  std::cout << "numOfRow: " << num << "\ttime cost:" << taosGetTimestampUs() - st << std::endl;
+//  // index->WriteMultiMillonData("tag2", "xxxxxxxxxxxxxxxxxxxxxxxxx", 100 * 10000);
+//}
 TEST_F(IndexEnv2, testLongComVal1) {
   std::string path = "/tmp/long_colVal";
   if (index->Init(path) != 0) {
   }
   // gen colVal by randstr
   std::string randstr = "xxxxxxxxxxxxxxxxx";
-  index->WriteMultiMillonData("tag1", randstr, 100 * 10000);
+  index->WriteMultiMillonData("tag1", randstr, 100 * 1000);
 }
 
 TEST_F(IndexEnv2, testLongComVal2) {
@@ -1000,7 +1000,7 @@ TEST_F(IndexEnv2, testLongComVal2) {
   }
   // gen colVal by randstr
   std::string randstr = "abcccc fdadfafdafda";
-  index->WriteMultiMillonData("tag1", randstr, 100 * 10000);
+  index->WriteMultiMillonData("tag1", randstr, 100 * 1000);
 }
 TEST_F(IndexEnv2, testLongComVal3) {
   std::string path = "/tmp/long_colVal";
@@ -1008,7 +1008,7 @@ TEST_F(IndexEnv2, testLongComVal3) {
   }
   // gen colVal by randstr
   std::string randstr = "Yes, coding and coding and coding";
-  index->WriteMultiMillonData("tag1", randstr, 100 * 10000);
+  index->WriteMultiMillonData("tag1", randstr, 100 * 1000);
 }
 TEST_F(IndexEnv2, testLongComVal4) {
   std::string path = "/tmp/long_colVal";
@@ -1016,7 +1016,7 @@ TEST_F(IndexEnv2, testLongComVal4) {
   }
   // gen colVal by randstr
   std::string randstr = "111111 bac fdadfa";
-  index->WriteMultiMillonData("tag1", randstr, 100 * 10000);
+  index->WriteMultiMillonData("tag1", randstr, 100 * 100);
 }
 TEST_F(IndexEnv2, testIndex_read_performance1) {
   std::string path = "/tmp/cache_and_tfile";
@@ -1026,7 +1026,7 @@ TEST_F(IndexEnv2, testIndex_read_performance1) {
   index->PutOneTarge("tag1", "Hello", 15);
   index->ReadMultiMillonData("tag1", "Hello", 1000);
   std::cout << "reader sz: " << index->SearchOne("tag1", "Hello") << std::endl;
-  assert(3 == index->SearchOne("tag1", "Hello"));
+  EXPECT_EQ(2, index->SearchOne("tag1", "Hello"));
 }
 TEST_F(IndexEnv2, testIndex_read_performance2) {
   std::string path = "/tmp/cache_and_tfile";
@@ -1034,9 +1034,9 @@ TEST_F(IndexEnv2, testIndex_read_performance2) {
   }
   index->PutOneTarge("tag1", "Hello", 12);
   index->PutOneTarge("tag1", "Hello", 15);
-  index->ReadMultiMillonData("tag1", "Hello", 1000 * 10);
+  index->ReadMultiMillonData("tag1", "Hello", 1000);
   std::cout << "reader sz: " << index->SearchOne("tag1", "Hello") << std::endl;
-  assert(3 == index->SearchOne("tag1", "Hello"));
+  EXPECT_EQ(2, index->SearchOne("tag1", "Hello"));
 }
 TEST_F(IndexEnv2, testIndex_read_performance3) {
   std::string path = "/tmp/cache_and_tfile";
@@ -1044,9 +1044,9 @@ TEST_F(IndexEnv2, testIndex_read_performance3) {
   }
   index->PutOneTarge("tag1", "Hello", 12);
   index->PutOneTarge("tag1", "Hello", 15);
-  index->ReadMultiMillonData("tag1", "Hello", 1000 * 100);
+  index->ReadMultiMillonData("tag1", "Hello", 1000);
   std::cout << "reader sz: " << index->SearchOne("tag1", "Hello") << std::endl;
-  assert(3 == index->SearchOne("tag1", "Hello"));
+  EXPECT_EQ(2, index->SearchOne("tag1", "Hello"));
 }
 TEST_F(IndexEnv2, testIndex_read_performance4) {
   std::string path = "/tmp/cache_and_tfile";
@@ -1054,9 +1054,9 @@ TEST_F(IndexEnv2, testIndex_read_performance4) {
   }
   index->PutOneTarge("tag10", "Hello", 12);
   index->PutOneTarge("tag12", "Hello", 15);
-  index->ReadMultiMillonData("tag10", "Hello", 1000 * 100);
+  index->ReadMultiMillonData("tag10", "Hello", 1000);
   std::cout << "reader sz: " << index->SearchOne("tag1", "Hello") << std::endl;
-  assert(3 == index->SearchOne("tag10", "Hello"));
+  EXPECT_EQ(1, index->SearchOne("tag10", "Hello"));
 }
 TEST_F(IndexEnv2, testIndex_cache_del) {
   std::string path = "/tmp/cache_and_tfile";
@@ -1108,7 +1108,7 @@ TEST_F(IndexEnv2, testIndex_del) {
   index->Del("tag10", "Hello", 11);
   EXPECT_EQ(98, index->SearchOne("tag10", "Hello"));
 
-  index->WriteMultiMillonData("tag10", "xxxxxxxxxxxxxx", 100 * 10000);
+  index->WriteMultiMillonData("tag10", "xxxxxxxxxxxxxx", 100 * 100);
   index->Del("tag10", "Hello", 17);
   EXPECT_EQ(97, index->SearchOne("tag10", "Hello"));
 }

source/libs/index/test/jsonUT.cc

@@ -154,7 +154,7 @@ TEST_F(JsonEnv, testWriteMillonData) {
 
     SIndexMultiTerm* terms = indexMultiTermCreate();
     indexMultiTermAdd(terms, term);
-    for (size_t i = 0; i < 100; i++) {
+    for (size_t i = 0; i < 10; i++) {
       tIndexJsonPut(index, terms, i);
     }
     indexMultiTermDestroy(terms);
@@ -162,14 +162,14 @@ TEST_F(JsonEnv, testWriteMillonData) {
   {
     std::string colName("voltagefdadfa");
     std::string colVal("abxxxxxxxxxxxx");
-    for (int i = 0; i < 1000; i++) {
+    for (int i = 0; i < 10; i++) {
       colVal[i % colVal.size()] = '0' + i % 128;
       SIndexTerm* term = indexTermCreate(1, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
                                          colVal.c_str(), colVal.size());
 
       SIndexMultiTerm* terms = indexMultiTermCreate();
       indexMultiTermAdd(terms, term);
-      for (size_t i = 0; i < 1000; i++) {
+      for (size_t i = 0; i < 100; i++) {
         tIndexJsonPut(index, terms, i);
       }
       indexMultiTermDestroy(terms);
@@ -199,7 +199,7 @@ TEST_F(JsonEnv, testWriteMillonData) {
     SArray* result = taosArrayInit(1, sizeof(uint64_t));
     indexMultiTermQueryAdd(mq, q, QUERY_TERM);
     tIndexJsonSearch(index, mq, result);
-    assert(100 == taosArrayGetSize(result));
+    EXPECT_EQ(10, taosArrayGetSize(result));
     indexMultiTermQueryDestroy(mq);
   }
   {
@@ -229,7 +229,7 @@ TEST_F(JsonEnv, testWriteMillonData) {
         SArray* result = taosArrayInit(1, sizeof(uint64_t));
         indexMultiTermQueryAdd(mq, q, QUERY_GREATER_EQUAL);
         tIndexJsonSearch(index, mq, result);
-        assert(100 == taosArrayGetSize(result));
+        EXPECT_EQ(10, taosArrayGetSize(result));
         indexMultiTermQueryDestroy(mq);
       }
     }
@@ -385,7 +385,7 @@ TEST_F(JsonEnv, testWriteJsonTfileAndCache_INT) {
 
     SIndexMultiTerm* terms = indexMultiTermCreate();
     indexMultiTermAdd(terms, term);
-    for (size_t i = 0; i < 100000; i++) {
+    for (size_t i = 0; i < 1000; i++) {
       tIndexJsonPut(index, terms, i);
     }
     indexMultiTermDestroy(terms);
@@ -523,7 +523,7 @@ TEST_F(JsonEnv, testWriteJsonTfileAndCache_INT2) {
   {
     int         val = 10;
     std::string colName("test1");
-    for (int i = 0; i < 10000; i++) {
+    for (int i = 0; i < 1000; i++) {
       val += 1;
       WriteData(index, colName, TSDB_DATA_TYPE_INT, &val, sizeof(val), i);
     }
@@ -532,7 +532,7 @@ TEST_F(JsonEnv, testWriteJsonTfileAndCache_INT2) {
     int         val = 10;
     std::string colName("test2xxx");
     std::string colVal("xxxxxxxxxxxxxxx");
-    for (int i = 0; i < 100000; i++) {
+    for (int i = 0; i < 1000; i++) {
       val += 1;
       WriteData(index, colName, TSDB_DATA_TYPE_BINARY, (void*)(colVal.c_str()), colVal.size(), i);
     }
@@ -542,14 +542,14 @@ TEST_F(JsonEnv, testWriteJsonTfileAndCache_INT2) {
     std::string colName("test1");
     int         val = 9;
     Search(index, colName, TSDB_DATA_TYPE_INT, &val, sizeof(val), QUERY_GREATER_EQUAL, &res);
-    EXPECT_EQ(10000, taosArrayGetSize(res));
+    EXPECT_EQ(1000, taosArrayGetSize(res));
   }
   {
     SArray*     res = NULL;
     std::string colName("test2xxx");
     std::string colVal("xxxxxxxxxxxxxxx");
     Search(index, colName, TSDB_DATA_TYPE_BINARY, (void*)(colVal.c_str()), colVal.size(), QUERY_TERM, &res);
-    EXPECT_EQ(100000, taosArrayGetSize(res));
+    EXPECT_EQ(1000, taosArrayGetSize(res));
   }
 }
 TEST_F(JsonEnv, testWriteJsonTfileAndCache_FLOAT) {

source/libs/parser/src/parTranslater.c

@@ -53,6 +53,8 @@ static bool afterGroupBy(ESqlClause clause) { return clause > SQL_CLAUSE_GROUP_B
 
 static bool beforeHaving(ESqlClause clause) { return clause < SQL_CLAUSE_HAVING; }
 
+static bool afterHaving(ESqlClause clause) { return clause > SQL_CLAUSE_HAVING; }
+
 static int32_t addNamespace(STranslateContext* pCxt, void* pTable) {
   size_t currTotalLevel = taosArrayGetSize(pCxt->pNsLevel);
   if (currTotalLevel > pCxt->currLevel) {
@@ -276,6 +278,10 @@ static bool isScanPseudoColumnFunc(const SNode* pNode) {
   return (QUERY_NODE_FUNCTION == nodeType(pNode) && fmIsScanPseudoColumnFunc(((SFunctionNode*)pNode)->funcId));
 }
 
+static bool isNonstandardSQLFunc(const SNode* pNode) {
+  return (QUERY_NODE_FUNCTION == nodeType(pNode) && fmIsNonstandardSQLFunc(((SFunctionNode*)pNode)->funcId));
+}
+
 static bool isDistinctOrderBy(STranslateContext* pCxt) {
   return (SQL_CLAUSE_ORDER_BY == pCxt->currClause && pCxt->pCurrStmt->isDistinct);
 }
@@ -433,6 +439,7 @@ static EDealRes translateColumnWithoutPrefix(STranslateContext* pCxt, SColumnNod
   SArray* pTables = taosArrayGetP(pCxt->pNsLevel, pCxt->currLevel);
   size_t  nums = taosArrayGetSize(pTables);
   bool    found = false;
+  bool    isInternalPk = isInternalPrimaryKey(pCol);
   for (size_t i = 0; i < nums; ++i) {
     STableNode* pTable = taosArrayGetP(pTables, i);
     if (findAndSetColumn(pCol, pTable)) {
@@ -440,10 +447,13 @@ static EDealRes translateColumnWithoutPrefix(STranslateContext* pCxt, SColumnNod
         return generateDealNodeErrMsg(pCxt, TSDB_CODE_PAR_AMBIGUOUS_COLUMN, pCol->colName);
       }
       found = true;
+      if (isInternalPk) {
+        break;
+      }
     }
   }
   if (!found) {
-    if (isInternalPrimaryKey(pCol)) {
+    if (isInternalPk) {
       return generateDealNodeErrMsg(pCxt, TSDB_CODE_PAR_INVALID_INTERNAL_PK);
     } else {
       return generateDealNodeErrMsg(pCxt, TSDB_CODE_PAR_INVALID_COLUMN, pCol->colName);
@@ -703,10 +713,13 @@ static EDealRes translateOperator(STranslateContext* pCxt, SOperatorNode* pOp) {
   return DEAL_RES_CONTINUE;
 }
 
-static EDealRes haveAggFunction(SNode* pNode, void* pContext) {
+static EDealRes haveAggOrNonstdFunction(SNode* pNode, void* pContext) {
   if (isAggFunc(pNode)) {
     *((bool*)pContext) = true;
     return DEAL_RES_END;
+  } else if (isNonstandardSQLFunc(pNode)) {
+    *((bool*)pContext) = true;
+    return DEAL_RES_END;
   }
   return DEAL_RES_CONTINUE;
 }
@@ -743,6 +756,12 @@ static int32_t rewriteCountStar(STranslateContext* pCxt, SFunctionNode* pCount)
   return code;
 }
 
+static bool hasInvalidFuncNesting(SNodeList* pParameterList) {
+  bool hasInvalidFunc = false;
+  nodesWalkExprs(pParameterList, haveAggOrNonstdFunction, &hasInvalidFunc);
+  return hasInvalidFunc;
+}
+
 static EDealRes translateFunction(STranslateContext* pCxt, SFunctionNode* pFunc) {
   SFmGetFuncInfoParam param = {.pCtg = pCxt->pParseCxt->pCatalog,
                                .pRpc = pCxt->pParseCxt->pTransporter,
@@ -754,11 +773,12 @@ static EDealRes translateFunction(STranslateContext* pCxt, SFunctionNode* pFunc)
     if (beforeHaving(pCxt->currClause)) {
       return generateDealNodeErrMsg(pCxt, TSDB_CODE_PAR_ILLEGAL_USE_AGG_FUNCTION);
     }
-    bool haveAggFunc = false;
-    nodesWalkExprs(pFunc->pParameterList, haveAggFunction, &haveAggFunc);
-    if (haveAggFunc) {
+    if (hasInvalidFuncNesting(pFunc->pParameterList)) {
       return generateDealNodeErrMsg(pCxt, TSDB_CODE_PAR_AGG_FUNC_NESTING);
     }
+    if (pCxt->pCurrStmt->hasNonstdSQLFunc) {
+      return generateDealNodeErrMsg(pCxt, TSDB_CODE_PAR_NOT_ALLOWED_FUNC);
+    }
 
     pCxt->pCurrStmt->hasAggFuncs = true;
     pCxt->pCurrStmt->isTimeOrderQuery = false;
@@ -784,6 +804,15 @@ static EDealRes translateFunction(STranslateContext* pCxt, SFunctionNode* pFunc)
       }
     }
   }
+  if (TSDB_CODE_SUCCESS == pCxt->errCode && fmIsNonstandardSQLFunc(pFunc->funcId)) {
+    if (SQL_CLAUSE_SELECT != pCxt->currClause || pCxt->pCurrStmt->hasNonstdSQLFunc || pCxt->pCurrStmt->hasAggFuncs) {
+      return generateDealNodeErrMsg(pCxt, TSDB_CODE_PAR_NOT_ALLOWED_FUNC);
+    }
+    if (hasInvalidFuncNesting(pFunc->pParameterList)) {
+      return generateDealNodeErrMsg(pCxt, TSDB_CODE_PAR_AGG_FUNC_NESTING);
+    }
+    pCxt->pCurrStmt->hasNonstdSQLFunc = true;
+  }
   return TSDB_CODE_SUCCESS == pCxt->errCode ? DEAL_RES_CONTINUE : DEAL_RES_ERROR;
 }
 
@@ -952,6 +981,7 @@ typedef struct CheckAggColCoexistCxt {
   STranslateContext* pTranslateCxt;
   bool               existAggFunc;
   bool               existCol;
+  bool               existNonstdFunc;
   int32_t            selectFuncNum;
 } CheckAggColCoexistCxt;
 
@@ -962,6 +992,10 @@ static EDealRes doCheckAggColCoexist(SNode* pNode, void* pContext) {
     pCxt->existAggFunc = true;
     return DEAL_RES_IGNORE_CHILD;
   }
+  if (isNonstandardSQLFunc(pNode)) {
+    pCxt->existNonstdFunc = true;
+    return DEAL_RES_IGNORE_CHILD;
+  }
   if (isScanPseudoColumnFunc(pNode) || QUERY_NODE_COLUMN == nodeType(pNode)) {
     pCxt->existCol = true;
   }
@@ -972,16 +1006,21 @@ static int32_t checkAggColCoexist(STranslateContext* pCxt, SSelectStmt* pSelect)
   if (NULL != pSelect->pGroupByList) {
     return TSDB_CODE_SUCCESS;
   }
-  CheckAggColCoexistCxt cxt = {.pTranslateCxt = pCxt, .existAggFunc = false, .existCol = false};
+  CheckAggColCoexistCxt cxt = {
+      .pTranslateCxt = pCxt, .existAggFunc = false, .existCol = false, .existNonstdFunc = false};
   nodesWalkExprs(pSelect->pProjectionList, doCheckAggColCoexist, &cxt);
   if (!pSelect->isDistinct) {
     nodesWalkExprs(pSelect->pOrderByList, doCheckAggColCoexist, &cxt);
   }
   if (1 == cxt.selectFuncNum) {
     return rewriteColsToSelectValFunc(pCxt, pSelect);
-  } else if ((cxt.selectFuncNum > 1 || cxt.existAggFunc || NULL != pSelect->pWindow) && cxt.existCol) {
+  }
+  if ((cxt.selectFuncNum > 1 || cxt.existAggFunc || NULL != pSelect->pWindow) && cxt.existCol) {
     return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_NOT_SINGLE_GROUP);
   }
+  if (cxt.existNonstdFunc && cxt.existCol) {
+    return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_NOT_ALLOWED_FUNC);
+  }
   return TSDB_CODE_SUCCESS;
 }
 

source/libs/parser/src/parUtil.c

@@ -164,6 +164,9 @@ static char* getSyntaxErrFormat(int32_t errCode) {
       return "Invalid function name";
     case TSDB_CODE_PAR_COMMENT_TOO_LONG:
       return "Comment too long";
+    case TSDB_CODE_PAR_NOT_ALLOWED_FUNC:
+      return "Some functions are allowed only in the SELECT list of a query. "
+             "And, cannot be mixed with other non scalar functions or columns.";
     case TSDB_CODE_OUT_OF_MEMORY:
       return "Out of memory";
     default:

source/libs/parser/test/parSelectTest.cpp

@@ -121,6 +121,26 @@ TEST_F(ParserSelectTest, selectFunc) {
   run("SELECT MAX(c1), c2 FROM t1 STATE_WINDOW(c3)");
 }
 
+TEST_F(ParserSelectTest, nonstdFunc) {
+  useDb("root", "test");
+
+  run("SELECT DIFF(c1) FROM t1");
+
+  // run("SELECT DIFF(c1) FROM t1 INTERVAL(10s)");
+}
+
+TEST_F(ParserSelectTest, nonstdFuncSemanticCheck) {
+  useDb("root", "test");
+
+  run("SELECT DIFF(c1), c2 FROM t1", TSDB_CODE_PAR_NOT_ALLOWED_FUNC, PARSER_STAGE_TRANSLATE);
+
+  run("SELECT DIFF(c1), tbname FROM t1", TSDB_CODE_PAR_NOT_ALLOWED_FUNC, PARSER_STAGE_TRANSLATE);
+
+  run("SELECT DIFF(c1), count(*) FROM t1", TSDB_CODE_PAR_NOT_ALLOWED_FUNC, PARSER_STAGE_TRANSLATE);
+
+  run("SELECT DIFF(c1), CSUM(c1) FROM t1", TSDB_CODE_PAR_NOT_ALLOWED_FUNC, PARSER_STAGE_TRANSLATE);
+}
+
 TEST_F(ParserSelectTest, clause) {
   useDb("root", "test");
 

source/libs/planner/src/planSpliter.c

@@ -24,7 +24,7 @@
 #define SPLIT_FLAG_TEST_MASK(val, mask) (((val) & (mask)) != 0)
 
 typedef struct SSplitContext {
-  int32_t queryId;
+  uint64_t queryId;
   int32_t  groupId;
   bool     split;
 } SSplitContext;

source/libs/qworker/src/qworkerMsg.c

@@ -292,7 +292,7 @@ int32_t qwRegisterQueryBrokenLinkArg(QW_FPARAMS_DEF, SRpcHandleInfo *pConn) {
   req->taskId = htobe64(tId);
   req->refId = htobe64(rId);
 
-  SRpcMsg pMsg = {
+  SRpcMsg brokenMsg = {
       .msgType = TDMT_VND_DROP_TASK,
       .pCont = req,
       .contLen = sizeof(STaskDropReq),
@@ -300,7 +300,7 @@ int32_t qwRegisterQueryBrokenLinkArg(QW_FPARAMS_DEF, SRpcHandleInfo *pConn) {
       .info = *pConn,
   };
 
-  tmsgRegisterBrokenLinkArg(&pMsg);
+  tmsgRegisterBrokenLinkArg(&brokenMsg);
 
   return TSDB_CODE_SUCCESS;
 }
@@ -326,7 +326,7 @@ int32_t qwRegisterHbBrokenLinkArg(SQWorker *mgmt, uint64_t sId, SRpcHandleInfo *
     QW_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
   }
 
-  SRpcMsg pMsg = {
+  SRpcMsg brokenMsg = {
       .msgType = TDMT_VND_QUERY_HEARTBEAT,
       .pCont = msg,
       .contLen = msgSize,
@@ -334,7 +334,7 @@ int32_t qwRegisterHbBrokenLinkArg(SQWorker *mgmt, uint64_t sId, SRpcHandleInfo *
       .info = *pConn,
   };
 
-  tmsgRegisterBrokenLinkArg(&pMsg);
+  tmsgRegisterBrokenLinkArg(&brokenMsg);
 
   return TSDB_CODE_SUCCESS;
 }

source/libs/stream/src/tstream.c

@@ -247,6 +247,19 @@ int32_t streamTaskExec2(SStreamTask* pTask, SMsgCb* pMsgCb) {
         void* data = NULL;
         taosGetQitem(pTask->inputQAll, &data);
         if (data == NULL) break;
+
+        streamTaskExecImpl(pTask, data, pRes);
+
+        taosFreeQitem(data);
+
+        if (taosArrayGetSize(pRes) != 0) {
+          SStreamDataBlock* resQ = taosAllocateQitem(sizeof(void**), DEF_QITEM);
+          resQ->type = STREAM_INPUT__DATA_BLOCK;
+          resQ->blocks = pRes;
+          taosWriteQitem(pTask->outputQ, resQ);
+          pRes = taosArrayInit(0, sizeof(SSDataBlock));
+          if (pRes == NULL) goto FAIL;
+        }
       }
 
       atomic_store_8(&pTask->status, TASK_STATUS__IDLE);
@@ -298,6 +311,9 @@ int32_t streamTaskSink(SStreamTask* pTask, SMsgCb* pMsgCb) {
     }
 
     // dispatch
+    // TODO dispatch guard
+    int8_t outputStatus = atomic_load_8(&pTask->outputStatus);
+    if (outputStatus == TASK_OUTPUT_STATUS__NORMAL) {
       if (pTask->dispatchType == TASK_DISPATCH__INPLACE) {
         SRpcMsg dispatchMsg = {0};
         if (streamBuildExecMsg(pTask, pRes, &dispatchMsg, NULL) < 0) {
@@ -356,6 +372,7 @@ int32_t streamTaskSink(SStreamTask* pTask, SMsgCb* pMsgCb) {
         ASSERT(pTask->dispatchType == TASK_DISPATCH__NONE);
       }
     }
+  }
   return 0;
 }
 
@@ -406,11 +423,32 @@ int32_t streamTaskProcessDispatchReq(SStreamTask* pTask, SMsgCb* pMsgCb, SStream
   return 0;
 }
 
+int32_t streamTaskProcessDispatchRsp(SStreamTask* pTask, SMsgCb* pMsgCb, SStreamDispatchRsp* pRsp) {
+  atomic_store_8(&pTask->inputStatus, pRsp->inputStatus);
+  if (pRsp->inputStatus == TASK_INPUT_STATUS__BLOCKED) {
+    // TODO: init recover timer
+  }
+  // continue dispatch
+  streamTaskSink(pTask, pMsgCb);
+  return 0;
+}
+
+int32_t streamTaskProcessRunReq(SStreamTask* pTask, SMsgCb* pMsgCb) {
+  streamTaskExec2(pTask, pMsgCb);
+  streamTaskSink(pTask, pMsgCb);
+  return 0;
+}
+
 int32_t streamTaskProcessRecoverReq(SStreamTask* pTask, char* msg) {
   //
   return 0;
 }
 
+int32_t streamTaskProcessRecoverRsp(SStreamTask* pTask, char* msg) {
+  //
+  return 0;
+}
+
 int32_t streamExecTask(SStreamTask* pTask, SMsgCb* pMsgCb, const void* input, int32_t inputType, int32_t workId) {
   SArray* pRes = NULL;
   // source

source/libs/sync/inc/syncIO.h

@@ -36,10 +36,10 @@ typedef struct SSyncIO {
   STaosQueue *pMsgQ;
   STaosQset * pQset;
   TdThread    consumerTid;
-
-  void * serverRpc;
-  void * clientRpc;
+  void       *serverRpc;
+  void       *clientRpc;
   SEpSet      myAddr;
+  SMsgCb      msgcb;
 
   tmr_h   qTimer;
   int32_t qTimerMS;
@@ -65,8 +65,8 @@ extern SSyncIO *gSyncIO;
 
 int32_t syncIOStart(char *host, uint16_t port);
 int32_t syncIOStop();
-int32_t syncIOSendMsg(void *clientRpc, const SEpSet *pEpSet, SRpcMsg *pMsg);
-int32_t syncIOEqMsg(void *queue, SRpcMsg *pMsg);
+int32_t syncIOSendMsg(const SEpSet *pEpSet, SRpcMsg *pMsg);
+int32_t syncIOEqMsg(const SMsgCb *msgcb, SRpcMsg *pMsg);
 
 int32_t syncIOQTimerStart();
 int32_t syncIOQTimerStop();

source/libs/sync/inc/syncInt.h

@@ -160,10 +160,9 @@ typedef struct SSyncNode {
 
   // sync io
   SWal*         pWal;
-  void* rpcClient;
-  int32_t (*FpSendMsg)(void* rpcClient, const SEpSet* pEpSet, SRpcMsg* pMsg);
-  void* queue;
-  int32_t (*FpEqMsg)(void* queue, SRpcMsg* pMsg);
+  const SMsgCb* msgcb;
+  int32_t (*FpSendMsg)(const SEpSet* pEpSet, SRpcMsg* pMsg);
+  int32_t (*FpEqMsg)(const SMsgCb* msgcb, SRpcMsg* pMsg);
 
   // init internal
   SNodeInfo myNodeInfo;

source/libs/sync/src/syncIO.c

@@ -66,7 +66,7 @@ int32_t syncIOStop() {
   return ret;
 }
 
-int32_t syncIOSendMsg(void *clientRpc, const SEpSet *pEpSet, SRpcMsg *pMsg) {
+int32_t syncIOSendMsg(const SEpSet *pEpSet, SRpcMsg *pMsg) {
   assert(pEpSet->inUse == 0);
   assert(pEpSet->numOfEps == 1);
 
@@ -83,11 +83,11 @@ int32_t syncIOSendMsg(void *clientRpc, const SEpSet *pEpSet, SRpcMsg *pMsg) {
 
   pMsg->info.handle = NULL;
   pMsg->info.noResp = 1;
-  rpcSendRequest(clientRpc, pEpSet, pMsg, NULL);
+  rpcSendRequest(gSyncIO->clientRpc, pEpSet, pMsg, NULL);
   return ret;
 }
 
-int32_t syncIOEqMsg(void *queue, SRpcMsg *pMsg) {
+int32_t syncIOEqMsg(const SMsgCb *msgcb, SRpcMsg *pMsg) {
   int32_t ret = 0;
   char    logBuf[128];
   syncRpcMsgLog2((char *)"==syncIOEqMsg==", pMsg);
@@ -96,7 +96,7 @@ int32_t syncIOEqMsg(void *queue, SRpcMsg *pMsg) {
   pTemp = taosAllocateQitem(sizeof(SRpcMsg), DEF_QITEM);
   memcpy(pTemp, pMsg, sizeof(SRpcMsg));
 
-  STaosQueue *pMsgQ = queue;
+  STaosQueue *pMsgQ = gSyncIO->pMsgQ;
   taosWriteQitem(pMsgQ, pTemp);
 
   return ret;
@@ -183,9 +183,6 @@ static int32_t syncIOStartInternal(SSyncIO *io) {
     rpcInit.sessions = 100;
     rpcInit.idleTime = 100;
     rpcInit.user = "sync-io";
-    rpcInit.secret = "sync-io";
-    rpcInit.ckey = "key";
-    rpcInit.spi = 0;
     rpcInit.connType = TAOS_CONN_CLIENT;
 
     io->clientRpc = rpcOpen(&rpcInit);
@@ -206,7 +203,6 @@ static int32_t syncIOStartInternal(SSyncIO *io) {
     rpcInit.cfp = syncIOProcessRequest;
     rpcInit.sessions = 1000;
     rpcInit.idleTime = 2 * 1500;
-    rpcInit.afp = syncIOAuth;
     rpcInit.parent = io;
     rpcInit.connType = TAOS_CONN_SERVER;
 

source/libs/sync/src/syncMain.c

@@ -240,26 +240,14 @@ int32_t syncGetAndDelRespRpc(int64_t rid, uint64_t index, SRpcMsg* msg) {
   return ret;
 }
 
-void syncSetQ(int64_t rid, void* queue) {
+void syncSetMsgCb(int64_t rid, const SMsgCb *msgcb) {
   SSyncNode* pSyncNode = (SSyncNode*)taosAcquireRef(tsNodeRefId, rid);
   if (pSyncNode == NULL) {
     sTrace("syncSetQ get pSyncNode is NULL, rid:%ld", rid);
     return;
   }
   assert(rid == pSyncNode->rid);
-  pSyncNode->queue = queue;
-
-  taosReleaseRef(tsNodeRefId, pSyncNode->rid);
-}
-
-void syncSetRpc(int64_t rid, void* rpcHandle) {
-  SSyncNode* pSyncNode = (SSyncNode*)taosAcquireRef(tsNodeRefId, rid);
-  if (pSyncNode == NULL) {
-    sTrace("syncSetRpc get pSyncNode is NULL, rid:%ld", rid);
-    return;
-  }
-  assert(rid == pSyncNode->rid);
-  pSyncNode->rpcClient = rpcHandle;
+  pSyncNode->msgcb = msgcb;
 
   taosReleaseRef(tsNodeRefId, pSyncNode->rid);
 }
@@ -332,7 +320,7 @@ int32_t syncPropose(int64_t rid, const SRpcMsg* pMsg, bool isWeak) {
     SRpcMsg            rpcMsg;
     syncClientRequest2RpcMsg(pSyncMsg, &rpcMsg);
     if (pSyncNode->FpEqMsg != NULL) {
-      pSyncNode->FpEqMsg(pSyncNode->queue, &rpcMsg);
+      pSyncNode->FpEqMsg(pSyncNode->msgcb, &rpcMsg);
     } else {
       sTrace("syncPropose pSyncNode->FpEqMsg is NULL");
     }
@@ -375,9 +363,8 @@ SSyncNode* syncNodeOpen(const SSyncInfo* pSyncInfo) {
   snprintf(pSyncNode->configPath, sizeof(pSyncNode->configPath), "%s/raft_config.json", pSyncInfo->path);
 
   pSyncNode->pWal = pSyncInfo->pWal;
-  pSyncNode->rpcClient = pSyncInfo->rpcClient;
+  pSyncNode->msgcb = pSyncInfo->msgcb;
   pSyncNode->FpSendMsg = pSyncInfo->FpSendMsg;
-  pSyncNode->queue = pSyncInfo->queue;
   pSyncNode->FpEqMsg = pSyncInfo->FpEqMsg;
 
   // init raft config
@@ -691,7 +678,7 @@ int32_t syncNodeSendMsgById(const SRaftId* destRaftId, SSyncNode* pSyncNode, SRp
     // htonl
     syncUtilMsgHtoN(pMsg->pCont);
 
-    pSyncNode->FpSendMsg(pSyncNode->rpcClient, &epSet, pMsg);
+    pSyncNode->FpSendMsg(&epSet, pMsg);
   } else {
     sTrace("syncNodeSendMsgById pSyncNode->FpSendMsg is NULL");
   }
@@ -706,7 +693,7 @@ int32_t syncNodeSendMsgByInfo(const SNodeInfo* nodeInfo, SSyncNode* pSyncNode, S
     // htonl
     syncUtilMsgHtoN(pMsg->pCont);
 
-    pSyncNode->FpSendMsg(pSyncNode->rpcClient, &epSet, pMsg);
+    pSyncNode->FpSendMsg(&epSet, pMsg);
   } else {
     sTrace("syncNodeSendMsgByInfo pSyncNode->FpSendMsg is NULL");
   }
@@ -728,12 +715,12 @@ cJSON* syncNode2Json(const SSyncNode* pSyncNode) {
     snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->pWal);
     cJSON_AddStringToObject(pRoot, "pWal", u64buf);
 
-    snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->rpcClient);
+    snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->msgcb);
     cJSON_AddStringToObject(pRoot, "rpcClient", u64buf);
     snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->FpSendMsg);
     cJSON_AddStringToObject(pRoot, "FpSendMsg", u64buf);
 
-    snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->queue);
+    snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->msgcb);
     cJSON_AddStringToObject(pRoot, "queue", u64buf);
     snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->FpEqMsg);
     cJSON_AddStringToObject(pRoot, "FpEqMsg", u64buf);
@@ -1095,7 +1082,7 @@ static void syncNodeEqPingTimer(void* param, void* tmrId) {
     syncTimeout2RpcMsg(pSyncMsg, &rpcMsg);
     syncRpcMsgLog2((char*)"==syncNodeEqPingTimer==", &rpcMsg);
     if (pSyncNode->FpEqMsg != NULL) {
-      pSyncNode->FpEqMsg(pSyncNode->queue, &rpcMsg);
+      pSyncNode->FpEqMsg(pSyncNode->msgcb, &rpcMsg);
     } else {
       sTrace("syncNodeEqPingTimer pSyncNode->FpEqMsg is NULL");
     }
@@ -1118,7 +1105,7 @@ static void syncNodeEqElectTimer(void* param, void* tmrId) {
     syncTimeout2RpcMsg(pSyncMsg, &rpcMsg);
     syncRpcMsgLog2((char*)"==syncNodeEqElectTimer==", &rpcMsg);
     if (pSyncNode->FpEqMsg != NULL) {
-      pSyncNode->FpEqMsg(pSyncNode->queue, &rpcMsg);
+      pSyncNode->FpEqMsg(pSyncNode->msgcb, &rpcMsg);
     } else {
       sTrace("syncNodeEqElectTimer pSyncNode->FpEqMsg is NULL");
     }
@@ -1145,7 +1132,7 @@ static void syncNodeEqHeartbeatTimer(void* param, void* tmrId) {
     syncTimeout2RpcMsg(pSyncMsg, &rpcMsg);
     syncRpcMsgLog2((char*)"==syncNodeEqHeartbeatTimer==", &rpcMsg);
     if (pSyncNode->FpEqMsg != NULL) {
-      pSyncNode->FpEqMsg(pSyncNode->queue, &rpcMsg);
+      pSyncNode->FpEqMsg(pSyncNode->msgcb, &rpcMsg);
     } else {
       sTrace("syncNodeEqHeartbeatTimer pSyncNode->FpEqMsg is NULL");
     }
@@ -1175,10 +1162,10 @@ static int32_t syncNodeEqNoop(SSyncNode* ths) {
   assert(pSyncMsg->dataLen == entryLen);
   memcpy(pSyncMsg->data, serialized, entryLen);
 
-  SRpcMsg rpcMsg;
+  SRpcMsg rpcMsg = {0};
   syncClientRequest2RpcMsg(pSyncMsg, &rpcMsg);
   if (ths->FpEqMsg != NULL) {
-    ths->FpEqMsg(ths->queue, &rpcMsg);
+    ths->FpEqMsg(ths->msgcb, &rpcMsg);
   } else {
     sTrace("syncNodeEqNoop pSyncNode->FpEqMsg is NULL");
   }

source/libs/sync/test/syncConfigChangeTest.cpp

@@ -100,9 +100,8 @@ SWal* createWal(char* path, int32_t vgId) {
 int64_t createSyncNode(int32_t replicaNum, int32_t myIndex, int32_t vgId, SWal* pWal, char* path, bool isStandBy) {
   SSyncInfo syncInfo;
   syncInfo.vgId = vgId;
-  syncInfo.rpcClient = gSyncIO->clientRpc;
+  syncInfo.msgcb = &gSyncIO->msgcb;
   syncInfo.FpSendMsg = syncIOSendMsg;
-  syncInfo.queue = gSyncIO->pMsgQ;
   syncInfo.FpEqMsg = syncIOEqMsg;
   syncInfo.pFsm = createFsm();
   snprintf(syncInfo.path, sizeof(syncInfo.path), "%s_sync_replica%d_index%d", path, replicaNum, myIndex);

source/libs/sync/test/syncElectTest.cpp

@@ -44,9 +44,8 @@ SWal* createWal(char* path, int32_t vgId) {
 SSyncNode* createSyncNode(int32_t replicaNum, int32_t myIndex, int32_t vgId, SWal* pWal, char* path) {
   SSyncInfo syncInfo;
   syncInfo.vgId = vgId;
-  syncInfo.rpcClient = gSyncIO->clientRpc;
+  syncInfo.msgcb = &gSyncIO->msgcb;
   syncInfo.FpSendMsg = syncIOSendMsg;
-  syncInfo.queue = gSyncIO->pMsgQ;
   syncInfo.FpEqMsg = syncIOEqMsg;
   syncInfo.pFsm = NULL;
   snprintf(syncInfo.path, sizeof(syncInfo.path), "%s_sync_replica%d_index%d", path, replicaNum, myIndex);

source/libs/sync/test/syncEncodeTest.cpp

@@ -31,9 +31,8 @@ SSyncNode *pSyncNode;
 
 SSyncNode *syncNodeInit() {
   syncInfo.vgId = 1234;
-  syncInfo.rpcClient = gSyncIO->clientRpc;
+  syncInfo.msgcb = &gSyncIO->msgcb;
   syncInfo.FpSendMsg = syncIOSendMsg;
-  syncInfo.queue = gSyncIO->pMsgQ;
   syncInfo.FpEqMsg = syncIOEqMsg;
   syncInfo.pFsm = pFsm;
   snprintf(syncInfo.path, sizeof(syncInfo.path), "%s", "./");

source/libs/sync/test/syncEnqTest.cpp

@@ -25,9 +25,7 @@ SSyncFSM* pFsm;
 
 SSyncNode* syncNodeInit() {
   syncInfo.vgId = 1234;
-  syncInfo.rpcClient = gSyncIO->clientRpc;
   syncInfo.FpSendMsg = syncIOSendMsg;
-  syncInfo.queue = gSyncIO->pMsgQ;
   syncInfo.FpEqMsg = syncIOEqMsg;
   syncInfo.pFsm = pFsm;
   snprintf(syncInfo.path, sizeof(syncInfo.path), "%s", "./");
@@ -99,7 +97,7 @@ int main(int argc, char** argv) {
     SyncPingReply* pSyncMsg = syncPingReplyBuild2(&pSyncNode->myRaftId, &pSyncNode->myRaftId, 1000, "syncEnqTest");
     SRpcMsg        rpcMsg;
     syncPingReply2RpcMsg(pSyncMsg, &rpcMsg);
-    pSyncNode->FpEqMsg(pSyncNode->queue, &rpcMsg);
+    pSyncNode->FpEqMsg(pSyncNode->msgcb, &rpcMsg);
     taosMsleep(1000);
   }
 

source/libs/sync/test/syncIOClientTest.cpp

@@ -43,7 +43,7 @@ int main() {
     SRpcMsg        rpcMsg;
     syncPingReply2RpcMsg(pSyncMsg, &rpcMsg);
 
-    syncIOSendMsg(gSyncIO->clientRpc, &epSet, &rpcMsg);
+    syncIOSendMsg(&epSet, &rpcMsg);
     taosSsleep(1);
   }
 

source/libs/sync/test/syncIOSendMsgTest.cpp

@@ -25,9 +25,8 @@ SSyncFSM* pFsm;
 
 SSyncNode* syncNodeInit() {
   syncInfo.vgId = 1234;
-  syncInfo.rpcClient = gSyncIO->clientRpc;
+  syncInfo.msgcb = &gSyncIO->msgcb;
   syncInfo.FpSendMsg = syncIOSendMsg;
-  syncInfo.queue = gSyncIO->pMsgQ;
   syncInfo.FpEqMsg = syncIOEqMsg;
   syncInfo.pFsm = pFsm;
   snprintf(syncInfo.path, sizeof(syncInfo.path), "%s", "./");
@@ -103,7 +102,7 @@ int main(int argc, char** argv) {
 
     SEpSet epSet;
     syncUtilnodeInfo2EpSet(&pSyncNode->myNodeInfo, &epSet);
-    pSyncNode->FpSendMsg(pSyncNode->rpcClient, &epSet, &rpcMsg);
+    pSyncNode->FpSendMsg(&epSet, &rpcMsg);
 
     taosMsleep(1000);
   }

source/libs/sync/test/syncIndexMgrTest.cpp

@@ -28,9 +28,8 @@ SSyncNode* pSyncNode;
 
 SSyncNode* syncNodeInit() {
   syncInfo.vgId = 1234;
-  syncInfo.rpcClient = gSyncIO->clientRpc;
+  syncInfo.msgcb = &gSyncIO->msgcb;
   syncInfo.FpSendMsg = syncIOSendMsg;
-  syncInfo.queue = gSyncIO->pMsgQ;
   syncInfo.FpEqMsg = syncIOEqMsg;
   syncInfo.pFsm = pFsm;
   snprintf(syncInfo.path, sizeof(syncInfo.path), "%s", "./");

source/libs/sync/test/syncInitTest.cpp

@@ -25,9 +25,8 @@ SSyncFSM* pFsm;
 
 SSyncNode* syncNodeInit() {
   syncInfo.vgId = 1234;
-  syncInfo.rpcClient = gSyncIO->clientRpc;
+  syncInfo.msgcb = &gSyncIO->msgcb;
   syncInfo.FpSendMsg = syncIOSendMsg;
-  syncInfo.queue = gSyncIO->pMsgQ;
   syncInfo.FpEqMsg = syncIOEqMsg;
   syncInfo.pFsm = pFsm;
   snprintf(syncInfo.path, sizeof(syncInfo.path), "%s", "./sync_init_test");

source/libs/sync/test/syncPingSelfTest.cpp

@@ -25,9 +25,8 @@ SSyncFSM* pFsm;
 
 SSyncNode* syncNodeInit() {
   syncInfo.vgId = 1234;
-  syncInfo.rpcClient = gSyncIO->clientRpc;
+  syncInfo.msgcb = &gSyncIO->msgcb;
   syncInfo.FpSendMsg = syncIOSendMsg;
-  syncInfo.queue = gSyncIO->pMsgQ;
   syncInfo.FpEqMsg = syncIOEqMsg;
   syncInfo.pFsm = pFsm;
   snprintf(syncInfo.path, sizeof(syncInfo.path), "%s", "./");

source/libs/sync/test/syncPingTimerTest.cpp

@@ -25,9 +25,8 @@ SSyncFSM* pFsm;
 
 SSyncNode* syncNodeInit() {
   syncInfo.vgId = 1234;
-  syncInfo.rpcClient = gSyncIO->clientRpc;
+  syncInfo.msgcb = &gSyncIO->msgcb;
   syncInfo.FpSendMsg = syncIOSendMsg;
-  syncInfo.queue = gSyncIO->pMsgQ;
   syncInfo.FpEqMsg = syncIOEqMsg;
   syncInfo.pFsm = pFsm;
   snprintf(syncInfo.path, sizeof(syncInfo.path), "%s", "./");

source/libs/sync/test/syncPingTimerTest2.cpp

@@ -25,9 +25,8 @@ SSyncFSM* pFsm;
 
 SSyncNode* syncNodeInit() {
   syncInfo.vgId = 1234;
-  syncInfo.rpcClient = gSyncIO->clientRpc;
+  syncInfo.msgcb = &gSyncIO->msgcb;
   syncInfo.FpSendMsg = syncIOSendMsg;
-  syncInfo.queue = gSyncIO->pMsgQ;
   syncInfo.FpEqMsg = syncIOEqMsg;
   syncInfo.pFsm = pFsm;
   snprintf(syncInfo.path, sizeof(syncInfo.path), "%s", "./");

source/libs/sync/test/syncReplicateTest.cpp

@@ -97,9 +97,8 @@ SWal* createWal(char* path, int32_t vgId) {
 int64_t createSyncNode(int32_t replicaNum, int32_t myIndex, int32_t vgId, SWal* pWal, char* path) {
   SSyncInfo syncInfo;
   syncInfo.vgId = vgId;
-  syncInfo.rpcClient = gSyncIO->clientRpc;
+  syncInfo.msgcb = &gSyncIO->msgcb;
   syncInfo.FpSendMsg = syncIOSendMsg;
-  syncInfo.queue = gSyncIO->pMsgQ;
   syncInfo.FpEqMsg = syncIOEqMsg;
   syncInfo.pFsm = createFsm();
   snprintf(syncInfo.path, sizeof(syncInfo.path), "%s_sync_replica%d_index%d", path, replicaNum, myIndex);

source/libs/sync/test/syncSnapshotTest.cpp

@@ -83,9 +83,8 @@ void initFsm() {
 
 SSyncNode *syncNodeInit() {
   syncInfo.vgId = 1234;
-  syncInfo.rpcClient = gSyncIO->clientRpc;
+  syncInfo.msgcb = &gSyncIO->msgcb;
   syncInfo.FpSendMsg = syncIOSendMsg;
-  syncInfo.queue = gSyncIO->pMsgQ;
   syncInfo.FpEqMsg = syncIOEqMsg;
   syncInfo.pFsm = pFsm;
   snprintf(syncInfo.path, sizeof(syncInfo.path), "%s", pDir);
@@ -200,7 +199,7 @@ int main(int argc, char **argv) {
     SyncClientRequest *pSyncClientRequest = pMsg1;
     SRpcMsg            rpcMsg;
     syncClientRequest2RpcMsg(pSyncClientRequest, &rpcMsg);
-    gSyncNode->FpEqMsg(gSyncNode->queue, &rpcMsg);
+    gSyncNode->FpEqMsg(gSyncNode->msgcb, &rpcMsg);
 
     taosMsleep(1000);
   }

source/libs/sync/test/syncVotesGrantedTest.cpp

@@ -27,9 +27,8 @@ SSyncNode* pSyncNode;
 
 SSyncNode* syncNodeInit() {
   syncInfo.vgId = 1234;
-  syncInfo.rpcClient = gSyncIO->clientRpc;
+  syncInfo.msgcb = &gSyncIO->msgcb;
   syncInfo.FpSendMsg = syncIOSendMsg;
-  syncInfo.queue = gSyncIO->pMsgQ;
   syncInfo.FpEqMsg = syncIOEqMsg;
   syncInfo.pFsm = pFsm;
   snprintf(syncInfo.path, sizeof(syncInfo.path), "%s", "./");

source/libs/sync/test/syncVotesRespondTest.cpp

@@ -27,9 +27,8 @@ SSyncNode* pSyncNode;
 
 SSyncNode* syncNodeInit() {
   syncInfo.vgId = 1234;
-  syncInfo.rpcClient = gSyncIO->clientRpc;
+  syncInfo.msgcb = &gSyncIO->msgcb;
   syncInfo.FpSendMsg = syncIOSendMsg;
-  syncInfo.queue = gSyncIO->pMsgQ;
   syncInfo.FpEqMsg = syncIOEqMsg;
   syncInfo.pFsm = pFsm;
   snprintf(syncInfo.path, sizeof(syncInfo.path), "%s", "./");

source/libs/sync/test/syncWriteTest.cpp

@@ -62,9 +62,8 @@ void initFsm() {
 
 SSyncNode *syncNodeInit() {
   syncInfo.vgId = 1234;
-  syncInfo.rpcClient = gSyncIO->clientRpc;
+  syncInfo.msgcb = &gSyncIO->msgcb;
   syncInfo.FpSendMsg = syncIOSendMsg;
-  syncInfo.queue = gSyncIO->pMsgQ;
   syncInfo.FpEqMsg = syncIOEqMsg;
   syncInfo.pFsm = pFsm;
   snprintf(syncInfo.path, sizeof(syncInfo.path), "%s", pDir);
@@ -178,7 +177,7 @@ int main(int argc, char **argv) {
     SyncClientRequest *pSyncClientRequest = pMsg1;
     SRpcMsg            rpcMsg;
     syncClientRequest2RpcMsg(pSyncClientRequest, &rpcMsg);
-    gSyncNode->FpEqMsg(gSyncNode->queue, &rpcMsg);
+    gSyncNode->FpEqMsg(gSyncNode->msgcb, &rpcMsg);
 
     taosMsleep(1000);
   }

source/libs/transport/inc/transportInt.h

@@ -52,23 +52,15 @@ typedef struct {
   int      idleTime;      // milliseconds;
   uint16_t localPort;
   int8_t   connType;
-  int64_t  index;
   char     label[TSDB_LABEL_LEN];
-
   char     user[TSDB_UNI_LEN];  // meter ID
-  char spi;                        // security parameter index
-  char encrypt;                    // encrypt algorithm
-  char secret[TSDB_PASSWORD_LEN];  // secret for the link
-  char ckey[TSDB_PASSWORD_LEN];    // ciphering key
 
   void (*cfp)(void* parent, SRpcMsg*, SEpSet*);
   bool (*retry)(int32_t code);
+  int index;
 
   int32_t       refCount;
   void*         parent;
-  void*         idPool;     // handle to ID pool
-  void*         tmrCtrl;    // handle to timer
-  SHashObj*     hash;       // handle returned by hash utility
   void*         tcphandle;  // returned handle from TCP initialization
   TdThreadMutex mutex;
 } SRpcInfo;

source/libs/transport/src/trans.c

@@ -69,9 +69,6 @@ void* rpcOpen(const SRpcInit* pInit) {
   if (pInit->user) {
     memcpy(pRpc->user, pInit->user, strlen(pInit->user));
   }
-  if (pInit->secret) {
-    memcpy(pRpc->secret, pInit->secret, strlen(pInit->secret));
-  }
   return pRpc;
 }
 void rpcClose(void* arg) {

source/libs/transport/test/CMakeLists.txt

@@ -110,3 +110,13 @@ target_link_libraries (pushServer
   transport 
 )
 
+
+add_test(
+  NAME transUT 
+  COMMAND transUT 
+)
+add_test(
+  NAME transUtilUt 
+  COMMAND transportTest
+)
+

source/libs/transport/test/pushServer.c

@@ -134,7 +134,6 @@ int main(int argc, char *argv[]) {
   rpcInit.cfp = processRequestMsg;
   rpcInit.sessions = 1000;
   rpcInit.idleTime = 2 * 1500;
-  rpcInit.afp = retrieveAuthInfo;
 
   for (int i = 1; i < argc; ++i) {
     if (strcmp(argv[i], "-p") == 0 && i < argc - 1) {

source/libs/transport/test/rclient.c

@@ -118,9 +118,6 @@ int main(int argc, char *argv[]) {
   rpcInit.sessions = 100;
   rpcInit.idleTime = 100;
   rpcInit.user = "michael";
-  rpcInit.secret = secret;
-  rpcInit.ckey = "key";
-  rpcInit.spi = 1;
   rpcInit.connType = TAOS_CONN_CLIENT;
   rpcDebugFlag = 131;
 
@@ -144,9 +141,7 @@ int main(int argc, char *argv[]) {
     } else if (strcmp(argv[i], "-u") == 0 && i < argc - 1) {
       rpcInit.user = argv[++i];
     } else if (strcmp(argv[i], "-k") == 0 && i < argc - 1) {
-      rpcInit.secret = argv[++i];
     } else if (strcmp(argv[i], "-spi") == 0 && i < argc - 1) {
-      rpcInit.spi = atoi(argv[++i]);
     } else if (strcmp(argv[i], "-d") == 0 && i < argc - 1) {
       rpcDebugFlag = atoi(argv[++i]);
     } else {
@@ -160,8 +155,6 @@ int main(int argc, char *argv[]) {
       printf("  [-n requests]: number of requests per thread, default is:%d\n", numOfReqs);
       printf("  [-o compSize]: compression message size, default is:%d\n", tsCompressMsgSize);
       printf("  [-u user]: user name for the connection, default is:%s\n", rpcInit.user);
-      printf("  [-k secret]: password for the connection, default is:%s\n", rpcInit.secret);
-      printf("  [-spi SPI]: security parameter index, default is:%d\n", rpcInit.spi);
       printf("  [-d debugFlag]: debug flag, default:%d\n", rpcDebugFlag);
       printf("  [-h help]: print out this help\n\n");
       exit(0);

source/libs/transport/test/rserver.c

@@ -123,7 +123,6 @@ int main(int argc, char *argv[]) {
   rpcInit.cfp = processRequestMsg;
   rpcInit.sessions = 1000;
   rpcInit.idleTime = 2 * 1500;
-  rpcInit.afp = retrieveAuthInfo;
 
   rpcDebugFlag = 131;
 

source/libs/transport/test/syncClient.c

@@ -119,9 +119,6 @@ int main(int argc, char *argv[]) {
   rpcInit.sessions = 100;
   rpcInit.idleTime = 100;
   rpcInit.user = "michael";
-  rpcInit.secret = secret;
-  rpcInit.ckey = "key";
-  rpcInit.spi = 1;
   rpcInit.connType = TAOS_CONN_CLIENT;
 
   for (int i = 1; i < argc; ++i) {
@@ -144,9 +141,7 @@ int main(int argc, char *argv[]) {
     } else if (strcmp(argv[i], "-u") == 0 && i < argc - 1) {
       rpcInit.user = argv[++i];
     } else if (strcmp(argv[i], "-k") == 0 && i < argc - 1) {
-      rpcInit.secret = argv[++i];
     } else if (strcmp(argv[i], "-spi") == 0 && i < argc - 1) {
-      rpcInit.spi = atoi(argv[++i]);
     } else if (strcmp(argv[i], "-d") == 0 && i < argc - 1) {
       rpcDebugFlag = atoi(argv[++i]);
     } else {
@@ -160,8 +155,6 @@ int main(int argc, char *argv[]) {
       printf("  [-n requests]: number of requests per thread, default is:%d\n", numOfReqs);
       printf("  [-o compSize]: compression message size, default is:%d\n", tsCompressMsgSize);
       printf("  [-u user]: user name for the connection, default is:%s\n", rpcInit.user);
-      printf("  [-k secret]: password for the connection, default is:%s\n", rpcInit.secret);
-      printf("  [-spi SPI]: security parameter index, default is:%d\n", rpcInit.spi);
       printf("  [-d debugFlag]: debug flag, default:%d\n", rpcDebugFlag);
       printf("  [-h help]: print out this help\n\n");
       exit(0);

source/libs/transport/test/transUT.cpp

@@ -43,15 +43,13 @@ static void processResp(void *parent, SRpcMsg *pMsg, SEpSet *pEpSet);
 class Client {
  public:
   void Init(int nThread) {
+    memcpy(tsTempDir, "/tmp", strlen("/tmp"));
     memset(&rpcInit_, 0, sizeof(rpcInit_));
     rpcInit_.localPort = 0;
     rpcInit_.label = (char *)label;
     rpcInit_.numOfThreads = nThread;
     rpcInit_.cfp = processResp;
     rpcInit_.user = (char *)user;
-    rpcInit_.secret = (char *)secret;
-    rpcInit_.ckey = (char *)ckey;
-    rpcInit_.spi = 1;
     rpcInit_.parent = this;
     rpcInit_.connType = TAOS_CONN_CLIENT;
     this->transCli = rpcOpen(&rpcInit_);
@@ -107,15 +105,15 @@ class Client {
 class Server {
  public:
   Server() {
+    memcpy(tsTempDir, "/tmp", strlen("/tmp"));
     memset(&rpcInit_, 0, sizeof(rpcInit_));
+
+    memcpy(rpcInit_.localFqdn, "localhost", strlen("localhost"));
     rpcInit_.localPort = port;
     rpcInit_.label = (char *)label;
     rpcInit_.numOfThreads = 5;
     rpcInit_.cfp = processReq;
     rpcInit_.user = (char *)user;
-    rpcInit_.secret = (char *)secret;
-    rpcInit_.ckey = (char *)ckey;
-    rpcInit_.spi = 1;
     rpcInit_.connType = TAOS_CONN_SERVER;
   }
   void Start() {
@@ -300,12 +298,14 @@ TEST_F(TransEnv, 02StopServer) {
   for (int i = 0; i < 1; i++) {
     SRpcMsg req = {0}, resp = {0};
     req.msgType = 0;
+    req.info.ahandle = (void *)0x35;
     req.pCont = rpcMallocCont(10);
     req.contLen = 10;
     tr->cliSendAndRecv(&req, &resp);
     assert(resp.code == 0);
   }
   SRpcMsg req = {0}, resp = {0};
+  req.info.ahandle = (void *)0x35;
   req.msgType = 1;
   req.pCont = rpcMallocCont(10);
   req.contLen = 10;
@@ -388,6 +388,7 @@ TEST_F(TransEnv, cliReleaseHandleExcept) {
     memset(&req, 0, sizeof(req));
     req.info = resp.info;
     req.info.persistHandle = 1;
+    req.info.ahandle = (void *)1234;
     req.msgType = 1;
     req.pCont = rpcMallocCont(10);
     req.contLen = 10;
@@ -406,12 +407,12 @@ TEST_F(TransEnv, srvContinueSend) {
   tr->SetSrvContinueSend(processContinueSend);
   SRpcMsg req = {0}, resp = {0};
   for (int i = 0; i < 10; i++) {
-    memset(&req, 0, sizeof(req));
-    memset(&resp, 0, sizeof(resp));
-    req.msgType = 1;
-    req.pCont = rpcMallocCont(10);
-    req.contLen = 10;
-    tr->cliSendAndRecv(&req, &resp);
+    // memset(&req, 0, sizeof(req));
+    // memset(&resp, 0, sizeof(resp));
+    // req.msgType = 1;
+    // req.pCont = rpcMallocCont(10);
+    // req.contLen = 10;
+    // tr->cliSendAndRecv(&req, &resp);
   }
   taosMsleep(1000);
 }
@@ -422,16 +423,16 @@ TEST_F(TransEnv, srvPersistHandleExcept) {
   SRpcMsg resp = {0};
   SRpcMsg req = {0};
   for (int i = 0; i < 5; i++) {
-    memset(&req, 0, sizeof(req));
-    req.info = resp.info;
-    req.msgType = 1;
-    req.pCont = rpcMallocCont(10);
-    req.contLen = 10;
-    tr->cliSendAndRecv(&req, &resp);
-    if (i > 2) {
-      tr->StopCli();
-      break;
-    }
+    // memset(&req, 0, sizeof(req));
+    // req.info = resp.info;
+    // req.msgType = 1;
+    // req.pCont = rpcMallocCont(10);
+    // req.contLen = 10;
+    // tr->cliSendAndRecv(&req, &resp);
+    // if (i > 2) {
+    //  tr->StopCli();
+    //  break;
+    //}
   }
   taosMsleep(2000);
   // conn broken
@@ -442,16 +443,16 @@ TEST_F(TransEnv, cliPersistHandleExcept) {
   SRpcMsg resp = {0};
   SRpcMsg req = {0};
   for (int i = 0; i < 5; i++) {
-    memset(&req, 0, sizeof(req));
-    req.info = resp.info;
-    req.msgType = 1;
-    req.pCont = rpcMallocCont(10);
-    req.contLen = 10;
-    tr->cliSendAndRecv(&req, &resp);
-    if (i > 2) {
-      tr->StopSrv();
-      break;
-    }
+    // memset(&req, 0, sizeof(req));
+    // req.info = resp.info;
+    // req.msgType = 1;
+    // req.pCont = rpcMallocCont(10);
+    // req.contLen = 10;
+    // tr->cliSendAndRecv(&req, &resp);
+    // if (i > 2) {
+    //  tr->StopSrv();
+    //  break;
+    //}
   }
   taosMsleep(2000);
   // conn broken
@@ -465,34 +466,34 @@ TEST_F(TransEnv, queryExcept) {
   tr->SetSrvContinueSend(processRegisterFailure);
   SRpcMsg resp = {0};
   SRpcMsg req = {0};
-  for (int i = 0; i < 5; i++) {
-    memset(&req, 0, sizeof(req));
-    req.info = resp.info;
-    req.info.persistHandle = 1;
-    req.msgType = 1;
-    req.pCont = rpcMallocCont(10);
-    req.contLen = 10;
-    tr->cliSendAndRecv(&req, &resp);
-    if (i == 2) {
-      rpcReleaseHandle(resp.info.handle, TAOS_CONN_CLIENT);
-      tr->StopCli();
-      break;
-    }
-  }
+  // for (int i = 0; i < 5; i++) {
+  //  memset(&req, 0, sizeof(req));
+  //  req.info = resp.info;
+  //  req.info.persistHandle = 1;
+  //  req.msgType = 1;
+  //  req.pCont = rpcMallocCont(10);
+  //  req.contLen = 10;
+  //  tr->cliSendAndRecv(&req, &resp);
+  //  if (i == 2) {
+  //    rpcReleaseHandle(resp.info.handle, TAOS_CONN_CLIENT);
+  //    tr->StopCli();
+  //    break;
+  //  }
+  //}
   taosMsleep(4 * 1000);
 }
 TEST_F(TransEnv, noResp) {
   SRpcMsg resp = {0};
   SRpcMsg req = {0};
-  for (int i = 0; i < 5; i++) {
-    memset(&req, 0, sizeof(req));
-    req.info.noResp = 1;
-    req.msgType = 1;
-    req.pCont = rpcMallocCont(10);
-    req.contLen = 10;
-    tr->cliSendAndRecv(&req, &resp);
-  }
-  taosMsleep(2000);
+  // for (int i = 0; i < 5; i++) {
+  //  memset(&req, 0, sizeof(req));
+  //  req.info.noResp = 1;
+  //  req.msgType = 1;
+  //  req.pCont = rpcMallocCont(10);
+  //  req.contLen = 10;
+  //  tr->cliSendAndRecv(&req, &resp);
+  //}
+  // taosMsleep(2000);
 
   // no resp
 }

source/libs/transport/test/transportTests.cpp

@@ -150,20 +150,26 @@ class TransCtxEnv : public ::testing::Test {
   STransCtx *ctx;
 };
 
+int32_t cloneVal(void *src, void **dst) {
+  int sz = (int)strlen((char *)src);
+  *dst = taosMemoryCalloc(1, sz + 1);
+  memcpy(*dst, src, sz);
+  return 0;
+}
 TEST_F(TransCtxEnv, mergeTest) {
   int key = 1;
   {
     STransCtx *src = (STransCtx *)taosMemoryCalloc(1, sizeof(STransCtx));
     transCtxInit(src);
     {
-      STransCtxVal val1 = { NULL, NULL, (void (*)(const void*))taosMemoryFree};
+      STransCtxVal val1 = {NULL, NULL, (void (*)(const void *))taosMemoryFree};
       val1.val = taosMemoryMalloc(12);
 
       taosHashPut(src->args, &key, sizeof(key), &val1, sizeof(val1));
       key++;
     }
     {
-      STransCtxVal val1 = { NULL, NULL, (void (*)(const void*))taosMemoryFree};
+      STransCtxVal val1 = {NULL, NULL, (void (*)(const void *))taosMemoryFree};
       val1.val = taosMemoryMalloc(12);
       taosHashPut(src->args, &key, sizeof(key), &val1, sizeof(val1));
       key++;
@@ -176,14 +182,14 @@ TEST_F(TransCtxEnv, mergeTest) {
     STransCtx *src = (STransCtx *)taosMemoryCalloc(1, sizeof(STransCtx));
     transCtxInit(src);
     {
-      STransCtxVal val1 = { NULL, NULL, (void (*)(const void*))taosMemoryFree};
+      STransCtxVal val1 = {NULL, NULL, (void (*)(const void *))taosMemoryFree};
       val1.val = taosMemoryMalloc(12);
 
       taosHashPut(src->args, &key, sizeof(key), &val1, sizeof(val1));
       key++;
     }
     {
-      STransCtxVal val1 = { NULL, NULL, (void (*)(const void*))taosMemoryFree};
+      STransCtxVal val1 = {NULL, NULL, (void (*)(const void *))taosMemoryFree};
       val1.val = taosMemoryMalloc(12);
       taosHashPut(src->args, &key, sizeof(key), &val1, sizeof(val1));
       key++;
@@ -198,16 +204,18 @@ TEST_F(TransCtxEnv, mergeTest) {
     STransCtx *src = (STransCtx *)taosMemoryCalloc(1, sizeof(STransCtx));
     transCtxInit(src);
     {
-      STransCtxVal val1 = { NULL, NULL, (void (*)(const void*))taosMemoryFree};
+      STransCtxVal val1 = {NULL, NULL, (void (*)(const void *))taosMemoryFree};
       val1.val = taosMemoryCalloc(1, 11);
+      val1.clone = cloneVal;
       memcpy(val1.val, val.c_str(), val.size());
 
       taosHashPut(src->args, &key, sizeof(key), &val1, sizeof(val1));
       key++;
     }
     {
-      STransCtxVal val1 = { NULL, NULL, (void (*)(const void*))taosMemoryFree};
+      STransCtxVal val1 = {NULL, NULL, (void (*)(const void *))taosMemoryFree};
       val1.val = taosMemoryCalloc(1, 11);
+      val1.clone = cloneVal;
       memcpy(val1.val, val.c_str(), val.size());
       taosHashPut(src->args, &key, sizeof(key), &val1, sizeof(val1));
       key++;

source/libs/transport/test/uv.c

 #include <assert.h>
-#include <uv.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <uv.h>
 
 #include "task.h"
 
@@ -11,23 +11,23 @@
 
 typedef struct SThreadObj {
   TdThread    thread;
-  uv_pipe_t *pipe;
-  uv_loop_t *loop;
+  uv_pipe_t * pipe;
+  uv_loop_t * loop;
   uv_async_t *workerAsync;  //
   int         fd;
 } SThreadObj;
 
 typedef struct SServerObj {
   uv_tcp_t     server;
-  uv_loop_t *loop;
+  uv_loop_t *  loop;
   int          workerIdx;
   int          numOfThread;
   SThreadObj **pThreadObj;
-  uv_pipe_t **pipe;
+  uv_pipe_t ** pipe;
 } SServerObj;
 
 typedef struct SConnCtx {
-  uv_tcp_t *pClient;
+  uv_tcp_t *  pClient;
   uv_timer_t *pTimer;
   uv_async_t *pWorkerAsync;
   int         ref;
@@ -42,7 +42,6 @@ void echo_write(uv_write_t *req, int status) {
 }
 
 void echo_read(uv_stream_t *client, ssize_t nread, const uv_buf_t *buf) {
-
   SConnCtx *pConn = container_of(client, SConnCtx, pClient);
   pConn->ref += 1;
   printf("read data %d\n", nread, buf->base, buf->len);
@@ -59,8 +58,7 @@ void echo_read(uv_stream_t *client, ssize_t nread, const uv_buf_t *buf) {
   }
 
   if (nread < 0) {
-    if (nread != UV_EOF)
-      fprintf(stderr, "Read error %s\n", uv_err_name(nread));
+    if (nread != UV_EOF) fprintf(stderr, "Read error %s\n", uv_err_name(nread));
     uv_close((uv_handle_t *)client, NULL);
   }
   taosMemoryFree(buf->base);
@@ -86,18 +84,16 @@ void on_new_connection(uv_stream_t *s, int status) {
     uv_buf_t    dummy_buf = uv_buf_init("a", 1);
     // despatch to worker thread
     pObj->workerIdx = (pObj->workerIdx + 1) % pObj->numOfThread;
-    uv_write2(write_req, (uv_stream_t *)&(pObj->pipe[pObj->workerIdx][0]),
-              &dummy_buf, 1, (uv_stream_t *)client, echo_write);
+    uv_write2(write_req, (uv_stream_t *)&(pObj->pipe[pObj->workerIdx][0]), &dummy_buf, 1, (uv_stream_t *)client,
+              echo_write);
   } else {
     uv_close((uv_handle_t *)client, NULL);
   }
 }
-void child_on_new_connection(uv_stream_t *q, ssize_t nread,
-                             const uv_buf_t *buf) {
+void child_on_new_connection(uv_stream_t *q, ssize_t nread, const uv_buf_t *buf) {
   printf("x child_on_new_connection \n");
   if (nread < 0) {
-    if (nread != UV_EOF)
-      fprintf(stderr, "Read error %s\n", uv_err_name(nread));
+    if (nread != UV_EOF) fprintf(stderr, "Read error %s\n", uv_err_name(nread));
     uv_close((uv_handle_t *)q, NULL);
     return;
   }
@@ -152,19 +148,16 @@ void *worker_thread(void *arg) {
 
   pObj->workerAsync = taosMemoryMalloc(sizeof(uv_async_t));
   uv_async_init(pObj->loop, pObj->workerAsync, workerAsyncCallback);
-  uv_read_start((uv_stream_t *)pObj->pipe, alloc_buffer,
-                child_on_new_connection);
+  uv_read_start((uv_stream_t *)pObj->pipe, alloc_buffer, child_on_new_connection);
 
   uv_run(pObj->loop, UV_RUN_DEFAULT);
 }
 int main() {
-
   SServerObj *server = taosMemoryCalloc(1, sizeof(SServerObj));
   server->loop = (uv_loop_t *)taosMemoryMalloc(sizeof(uv_loop_t));
   server->numOfThread = NUM_OF_THREAD;
   server->workerIdx = 0;
-  server->pThreadObj =
-      (SThreadObj **)taosMemoryCalloc(server->numOfThread, sizeof(SThreadObj *));
+  server->pThreadObj = (SThreadObj **)taosMemoryCalloc(server->numOfThread, sizeof(SThreadObj *));
   server->pipe = (uv_pipe_t **)taosMemoryCalloc(server->numOfThread, sizeof(uv_pipe_t *));
 
   uv_loop_init(server->loop);
@@ -173,8 +166,7 @@ int main() {
     server->pThreadObj[i] = (SThreadObj *)taosMemoryCalloc(1, sizeof(SThreadObj));
     server->pipe[i] = (uv_pipe_t *)taosMemoryCalloc(2, sizeof(uv_pipe_t));
     int fds[2];
-    if (uv_socketpair(AF_UNIX, SOCK_STREAM, fds, UV_NONBLOCK_PIPE,
-                      UV_NONBLOCK_PIPE) != 0) {
+    if (uv_socketpair(AF_UNIX, SOCK_STREAM, fds, UV_NONBLOCK_PIPE, UV_NONBLOCK_PIPE) != 0) {
       return -1;
     }
     uv_pipe_init(server->loop, &(server->pipe[i][0]), 1);
@@ -182,8 +174,7 @@ int main() {
 
     server->pThreadObj[i]->fd = fds[0];
     server->pThreadObj[i]->pipe = &(server->pipe[i][1]);  // init read
-    int err = taosThreadCreate(&(server->pThreadObj[i]->thread), NULL,
-                             worker_thread, (void *)(server->pThreadObj[i]));
+    int err = taosThreadCreate(&(server->pThreadObj[i]->thread), NULL, worker_thread, (void *)(server->pThreadObj[i]));
     if (err == 0) {
       printf("thread %d create\n", i);
     } else {
@@ -195,8 +186,7 @@ int main() {
     uv_ip4_addr("0.0.0.0", 7000, &bind_addr);
     uv_tcp_bind(&server->server, (const struct sockaddr *)&bind_addr, 0);
     int err = 0;
-    if ((err = uv_listen((uv_stream_t *)&server->server, 128,
-                         on_new_connection)) != 0) {
+    if ((err = uv_listen((uv_stream_t *)&server->server, 128, on_new_connection)) != 0) {
       fprintf(stderr, "Listen error %s\n", uv_err_name(err));
       return 2;
     }

tests/system-test/0-others/udfTest.py

+from distutils.log import error
 import taos
 import sys
 import time
@@ -43,12 +44,14 @@ class TDTestCase:
         libudf1 = subprocess.Popen('find %s -name "libudf1.so"|grep lib|head -n1'%projPath , shell=True, stdout=subprocess.PIPE,stderr=subprocess.STDOUT).stdout.read().decode("utf-8")
         libudf2 = subprocess.Popen('find %s -name "libudf2.so"|grep lib|head -n1'%projPath , shell=True, stdout=subprocess.PIPE,stderr=subprocess.STDOUT).stdout.read().decode("utf-8")
         os.system("mkdir /tmp/udf/")
-        os.system("sudo cp %s /tmp/udf/ "%libudf1.replace("\n" ,""))
-        os.system("sudo cp  %s /tmp/udf/ "%libudf2.replace("\n" ,""))
+        os.system("cp %s /tmp/udf/ "%libudf1.replace("\n" ,""))
+        os.system("cp  %s /tmp/udf/ "%libudf2.replace("\n" ,""))
 
 
     def prepare_data(self):
         
+        tdSql.execute("drop database if exists db ")
+        tdSql.execute("create database if not exists db  days 300")
         tdSql.execute("use db")
         tdSql.execute(
         '''create table stb1
@@ -117,6 +120,17 @@ class TDTestCase:
             '''
         )
 
+        # udf functions with join
+        ts_start = 1652517451000
+        tdSql.execute("create stable st (ts timestamp , c1 int , c2 int ,c3 double ,c4 double ) tags(ind int)")
+        tdSql.execute("create table sub1 using st tags(1)")
+        tdSql.execute("create table sub2 using st tags(2)")
+
+        for i in range(10):
+            ts = ts_start + i *1000
+            tdSql.execute(" insert into sub1 values({} , {},{},{},{})".format(ts,i ,i*10,i*100.0,i*1000.0))
+            tdSql.execute(" insert into sub2 values({} , {},{},{},{})".format(ts,i ,i*10,i*100.0,i*1000.0))
+
 
     def create_udf_function(self):
 
@@ -329,14 +343,14 @@ class TDTestCase:
 
         # # bug need fix 
 
-        tdSql.query("select udf1(num1) , csum(num1) from tb;")
-        tdSql.checkRows(9)
-        tdSql.query("select ceil(num1) , csum(num1) from tb;")
-        tdSql.checkRows(9)
-        tdSql.query("select udf1(c1) , csum(c1) from stb1;")
-        tdSql.checkRows(22)
-        tdSql.query("select floor(c1) , csum(c1) from stb1;")
-        tdSql.checkRows(22)
+        #tdSql.query("select udf1(num1) , csum(num1) from tb;")
+        #tdSql.checkRows(9)
+        #tdSql.query("select ceil(num1) , csum(num1) from tb;")
+        #tdSql.checkRows(9)
+        #tdSql.query("select udf1(c1) , csum(c1) from stb1;")
+        #tdSql.checkRows(22)
+        #tdSql.query("select floor(c1) , csum(c1) from stb1;")
+        #tdSql.checkRows(22)
 
         # stable  with compute functions
         tdSql.query("select udf1(c1) , abs(c1) from stb1;")
@@ -379,17 +393,6 @@ class TDTestCase:
         tdSql.checkData(0,2,-99.990000000)
         tdSql.checkData(0,3,88)
         
-        # udf functions with join
-        ts_start = 1652517451000
-        tdSql.execute("create stable st (ts timestamp , c1 int , c2 int ,c3 double ,c4 double ) tags(ind int)")
-        tdSql.execute("create table sub1 using st tags(1)")
-        tdSql.execute("create table sub2 using st tags(2)")
-
-        for i in range(10):
-            ts = ts_start + i *1000
-            tdSql.execute(" insert into sub1 values({} , {},{},{},{})".format(ts,i ,i*10,i*100.0,i*1000.0))
-            tdSql.execute(" insert into sub2 values({} , {},{},{},{})".format(ts,i ,i*10,i*100.0,i*1000.0))
-        
         tdSql.query("select sub1.c1, sub2.c2 from sub1, sub2 where sub1.ts=sub2.ts and sub1.c1 is not null")
         tdSql.checkData(0,0,0)
         tdSql.checkData(0,1,0)
@@ -468,10 +471,103 @@ class TDTestCase:
         tdSql.checkData(0,0,169.661427555)
         tdSql.checkData(0,1,169.661427555)
 
+    def try_query_sql(self):
+        udf1_sqls = [ 
+        "select num1 , udf1(num1) ,num2 ,udf1(num2),num3 ,udf1(num3),num4 ,udf1(num4) from tb" ,
+        "select c1 , udf1(c1) ,c2 ,udf1(c2), c3 ,udf1(c3), c4 ,udf1(c4) from stb1 order by c1" ,
+        "select udf1(num1) , max(num1) from tb;" ,
+        "select udf1(num1) , min(num1) from tb;" ,
+        #"select udf1(num1) , top(num1,1) from tb;" ,
+        #"select udf1(num1) , bottom(num1,1) from tb;" ,
+        "select udf1(c1) , max(c1) from stb1;" ,
+        "select udf1(c1) , min(c1) from stb1;" ,
+        #"select udf1(c1) , top(c1 ,1) from stb1;" ,
+        #"select udf1(c1) , bottom(c1,1) from stb1;" ,
+        "select udf1(num1) , abs(num1) from tb;" ,
+        #"select udf1(num1) , csum(num1) from tb;" ,
+        #"select udf1(c1) , csum(c1) from stb1;" ,
+        "select udf1(c1) , abs(c1) from stb1;" ,
+        "select abs(udf1(c1)) , abs(ceil(c1)) from stb1 order by ts;" ,
+        "select abs(udf1(c1)) , abs(ceil(c1)) from ct1 order by ts;" ,
+        "select abs(udf1(c1)) , abs(ceil(c1)) from stb1 where c1 is null  order by ts;" ,
+        "select c1 ,udf1(c1) , c6 ,udf1(c6) from stb1 where c1 > 8  order by ts" ,
+        "select udf1(sub1.c1), udf1(sub2.c2) from sub1, sub2 where sub1.ts=sub2.ts and sub1.c1 is not null" ,
+        "select sub1.c1 , udf1(sub1.c1), sub2.c2 ,udf1(sub2.c2) from sub1, sub2 where sub1.ts=sub2.ts and sub1.c1 is not null" ,
+        "select udf1(c1) from ct1 group by c1" ,
+        "select udf1(c1) from stb1 group by c1" ,
+        "select c1,c2, udf1(c1,c2) from ct1 group by c1,c2" ,
+        "select c1,c2, udf1(c1,c2) from stb1 group by c1,c2" ,
+        "select num1,num2,num3,udf1(num1,num2,num3) from tb" ,
+        "select c1,c6,udf1(c1,c6) from stb1 order by ts" ,
+        "select abs(udf1(c1,c6,c1,c6)) , abs(ceil(c1)) from stb1 where c1 is not null  order by ts;" 
+        ]
+        udf2_sqls = ["select udf2(sub1.c1), udf2(sub2.c2) from sub1, sub2 where sub1.ts=sub2.ts and sub1.c1 is not null" ,
+        "select udf2(c1) from stb1 group by 1-udf1(c1)" ,
+        "select udf2(num1) ,udf2(num2), udf2(num3) from tb" ,
+        "select udf2(num1)+100 ,udf2(num2)-100, udf2(num3)*100 ,udf2(num3)/100 from tb" ,
+        "select udf2(c1) ,udf2(c6) from stb1 " ,
+        "select udf2(c1)+100 ,udf2(c6)-100 ,udf2(c1)*100 ,udf2(c6)/100 from stb1 " ,
+        "select udf2(c1+100) ,udf2(c6-100) ,udf2(c1*100) ,udf2(c6/100) from ct1" ,
+        "select udf2(c1+100) ,udf2(c6-100) ,udf2(c1*100) ,udf2(c6/100) from stb1 " ,
+        "select udf2(c1) from ct1 group by c1" ,
+        "select udf2(c1) from stb1 group by c1" ,
+        "select c1,c2, udf2(c1,c6) from ct1 group by c1,c2" ,
+        "select c1,c2, udf2(c1,c6) from stb1 group by c1,c2" ,
+        "select udf2(c1) from stb1 group by udf1(c1)" ,
+        "select udf2(c1) from stb1 group by floor(c1)" ,
+        "select udf2(c1) from stb1 group by floor(c1) order by udf2(c1)" ,
+    
+        "select udf2(sub1.c1 ,sub1.c2), udf2(sub2.c2 ,sub2.c1) from sub1, sub2 where sub1.ts=sub2.ts and sub1.c1 is not null" ,
+        "select udf2(sub1.c1 ,sub1.c2), udf2(sub2.c2 ,sub2.c1) from sub1, sub2 where sub1.ts=sub2.ts and sub1.c1 is not null" ,
+        "select udf2(sub1.c1 ,sub1.c2), udf2(sub2.c2 ,sub2.c1) from sub1, sub2 where sub1.ts=sub2.ts and sub1.c1 is not null" ,
+        "select udf2(sub1.c1 ,sub1.c2), udf2(sub2.c2 ,sub2.c1) from sub1, sub2 where sub1.ts=sub2.ts and sub1.c1 is not null"]
+
+        return udf1_sqls ,udf2_sqls
+
+
 
     def unexpected_create(self):
 
-        tdSql.query("select udf2(sub1.c1 ,sub1.c2), udf2(sub2.c2 ,sub2.c1) from sub1, sub2 where sub1.ts=sub2.ts and sub1.c1 is not null")
+        tdLog.info(" create function with out bufsize ")
+        tdSql.query("drop function udf1 ")
+        tdSql.query("drop function udf2 ")
+
+        # create function without buffer
+        tdSql.execute("create function udf1 as '/tmp/udf/libudf1.so' outputtype int")
+        tdSql.execute("create aggregate function udf2 as '/tmp/udf/libudf2.so' outputtype double")
+        udf1_sqls ,udf2_sqls = self.try_query_sql()
+
+        for scalar_sql in udf1_sqls:
+            tdSql.query(scalar_sql)
+        for aggregate_sql in udf2_sqls:
+            tdSql.error(aggregate_sql)
+
+        # create function without aggregate 
+
+        tdLog.info(" create function with out aggregate ")
+        tdSql.query("drop function udf1 ")
+        tdSql.query("drop function udf2 ")
+
+        # create function without buffer
+        tdSql.execute("create  aggregate function udf1 as '/tmp/udf/libudf1.so' outputtype int bufSize 8 ")
+        tdSql.execute("create  function udf2 as '/tmp/udf/libudf2.so' outputtype double bufSize 8")
+        udf1_sqls ,udf2_sqls = self.try_query_sql()
+
+        for scalar_sql in udf1_sqls:
+            tdSql.error(scalar_sql)
+        for aggregate_sql in udf2_sqls:
+            tdSql.error(aggregate_sql)
+
+        tdSql.execute(" create function db as '/tmp/udf/libudf1.so' outputtype int bufSize 8 ")
+        tdSql.execute(" create aggregate function test as '/tmp/udf/libudf1.so' outputtype int bufSize 8 ")
+        tdSql.error(" select db(c1) from stb1 ")
+        tdSql.error(" select db(c1,c6), db(c6) from stb1 ")
+        tdSql.error(" select db(num1,num2), db(num1) from tb ")
+        tdSql.error(" select test(c1) from stb1 ")
+        tdSql.error(" select test(c1,c6), test(c6) from stb1 ")
+        tdSql.error(" select test(num1,num2), test(num1) from tb ")
+        
+        
 
     def loop_kill_udfd(self):
 
@@ -484,7 +580,7 @@ class TDTestCase:
         cfgPath = buildPath + "/../sim/dnode1/cfg"
         udfdPath = buildPath +'/build/bin/udfd'
 
-        for i in range(5):
+        for i in range(3):
 
             tdLog.info(" loop restart udfd  %d_th" % i)
 
@@ -492,7 +588,7 @@ class TDTestCase:
             tdSql.checkData(0,0,169.661427555)
             tdSql.checkData(0,1,169.661427555)
             # stop udfd cmds 
-            get_processID = "ps -ef | grep -w udfd | grep 'root' | grep -v grep| grep -v defunct | awk '{print $2}'"
+            get_processID = "ps -ef | grep -w udfd | grep -v grep| grep -v defunct | awk '{print $2}'"
             processID = subprocess.check_output(get_processID, shell=True).decode("utf-8")
             stop_udfd = " kill -9 %s" % processID
             os.system(stop_udfd)
@@ -507,11 +603,27 @@ class TDTestCase:
             # start_udfd = "nohup " + udfdPath +'-c' +cfgPath +" > /dev/null 2>&1 &"
             # tdLog.info("start udfd : %s " % start_udfd)
 
+    def test_function_name(self):
+        tdLog.info(" create function name is not build_in functions ")
+        tdSql.execute(" drop function udf1 ")
+        tdSql.execute(" drop function udf2 ")
+        tdSql.error("create function max as '/tmp/udf/libudf1.so' outputtype int bufSize 8")
+        tdSql.error("create aggregate function sum as '/tmp/udf/libudf2.so' outputtype double bufSize 8")
+        tdSql.error("create function max as '/tmp/udf/libudf1.so' outputtype int bufSize 8")
+        tdSql.error("create aggregate function sum as '/tmp/udf/libudf2.so' outputtype double bufSize 8")
+        tdSql.error("create aggregate function tbname as '/tmp/udf/libudf2.so' outputtype double bufSize 8")
+        tdSql.error("create aggregate function function as '/tmp/udf/libudf2.so' outputtype double bufSize 8")
+        tdSql.error("create aggregate function stable as '/tmp/udf/libudf2.so' outputtype double bufSize 8")
+        tdSql.error("create aggregate function union as '/tmp/udf/libudf2.so' outputtype double bufSize 8")
+        tdSql.error("create aggregate function 123 as '/tmp/udf/libudf2.so' outputtype double bufSize 8")
+        tdSql.error("create aggregate function 123db as '/tmp/udf/libudf2.so' outputtype double bufSize 8")
+        tdSql.error("create aggregate function mnode as '/tmp/udf/libudf2.so' outputtype double bufSize 8")
 
     def restart_taosd_query_udf(self):
 
+        self.create_udf_function()
+
         for i in range(5):
-            time.sleep(5)
             tdLog.info("  this is %d_th restart taosd " %i)
             tdSql.execute("use db ")
             tdSql.query("select count(*) from stb1")
@@ -520,21 +632,29 @@ class TDTestCase:
             tdSql.checkData(0,0,169.661427555)
             tdSql.checkData(0,1,169.661427555)
             tdDnodes.stop(1)
-            time.sleep(2)
             tdDnodes.start(1)
-            time.sleep(5)
-            
+            time.sleep(2)
             
             
     def run(self):  # sourcery skip: extract-duplicate-method, remove-redundant-fstring
-        tdSql.prepare()
         
+        print(" env is ok for all ") 
         self.prepare_udf_so()
         self.prepare_data()
         self.create_udf_function()
         self.basic_udf_query()
         self.loop_kill_udfd()
-        # self.restart_taosd_query_udf()
+        
+        self.unexpected_create()
+        tdSql.execute(" drop function udf1 ")
+        tdSql.execute(" drop function udf2 ")
+        self.create_udf_function()
+        time.sleep(2)
+        self.basic_udf_query()
+        self.test_function_name()
+        self.restart_taosd_query_udf()
+       
+        
 
     def stop(self):
         tdSql.close()

tests/system-test/0-others/udf_cluster.py

+import taos
+import sys
+import time
+import os 
+
+from util.log import *
+from util.sql import *
+from util.cases import *
+from util.dnodes import TDDnodes
+from util.dnodes import TDDnode
+import socket
+import subprocess
+
+class MyDnodes(TDDnodes):
+    def __init__(self ,dnodes_lists):
+        super(MyDnodes,self).__init__()
+        self.dnodes = dnodes_lists  # dnode must be TDDnode instance
+        self.simDeployed = False
+        
+class TDTestCase:
+
+    def init(self,conn ,logSql):
+        tdLog.debug(f"start to excute {__file__}")
+        self.TDDnodes = None
+        self.depoly_cluster(3)
+        self.master_dnode = self.TDDnodes.dnodes[0]
+        conn1 = taos.connect(self.master_dnode.cfgDict["fqdn"] , config=self.master_dnode.cfgDir)
+        tdSql.init(conn1.cursor())
+        
+
+    def getBuildPath(self):
+        selfPath = os.path.dirname(os.path.realpath(__file__))
+
+        if ("community" in selfPath):
+            projPath = selfPath[:selfPath.find("community")]
+        else:
+            projPath = selfPath[:selfPath.find("tests")]
+
+        for root, dirs, files in os.walk(projPath):
+            if ("taosd" in files):
+                rootRealPath = os.path.dirname(os.path.realpath(root))
+                if ("packaging" not in rootRealPath):
+                    buildPath = root[:len(root) - len("/build/bin")]
+                    break
+        return buildPath
+    
+    def prepare_udf_so(self):
+        selfPath = os.path.dirname(os.path.realpath(__file__))
+
+        if ("community" in selfPath):
+            projPath = selfPath[:selfPath.find("community")]
+        else:
+            projPath = selfPath[:selfPath.find("tests")]
+        print(projPath)
+
+        libudf1 = subprocess.Popen('find %s -name "libudf1.so"|grep lib|head -n1'%projPath , shell=True, stdout=subprocess.PIPE,stderr=subprocess.STDOUT).stdout.read().decode("utf-8")
+        libudf2 = subprocess.Popen('find %s -name "libudf2.so"|grep lib|head -n1'%projPath , shell=True, stdout=subprocess.PIPE,stderr=subprocess.STDOUT).stdout.read().decode("utf-8")
+        os.system("mkdir /tmp/udf/")
+        os.system("sudo cp %s /tmp/udf/ "%libudf1.replace("\n" ,""))
+        os.system("sudo cp  %s /tmp/udf/ "%libudf2.replace("\n" ,""))
+
+
+    def prepare_data(self):
+    
+        tdSql.execute("drop database if exists db")
+        tdSql.execute("create database if not exists db replica 1 days 300")
+        tdSql.execute("use db")
+        tdSql.execute(
+        '''create table stb1
+        (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp)
+        tags (t1 int)
+        '''
+        )
+        
+        tdSql.execute(
+            '''
+            create table t1
+            (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp)
+            '''
+        )
+        for i in range(4):
+            tdSql.execute(f'create table ct{i+1} using stb1 tags ( {i+1} )')
+
+        for i in range(9):
+            tdSql.execute(
+                f"insert into ct1 values ( now()-{i*10}s, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a )"
+            )
+            tdSql.execute(
+                f"insert into ct4 values ( now()-{i*90}d, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a )"
+            )
+        tdSql.execute("insert into ct1 values (now()-45s, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar0', now()+8a )")
+        tdSql.execute("insert into ct1 values (now()+10s, 9, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a )")
+        tdSql.execute("insert into ct1 values (now()+15s, 9, -99999, -999, -99, -9.99, NULL, 1, 'binary9', 'nchar9', now()+9a )")
+        tdSql.execute("insert into ct1 values (now()+20s, 9, -99999, -999, NULL, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a )")
+
+        tdSql.execute("insert into ct4 values (now()-810d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ")
+        tdSql.execute("insert into ct4 values (now()-400d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ")
+        tdSql.execute("insert into ct4 values (now()+9d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL  ) ")
+
+        tdSql.execute(
+            f'''insert into t1 values
+            ( '2020-04-21 01:01:01.000', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
+            ( '2020-10-21 01:01:01.000', 1, 11111, 111, 11, 1.11, 11.11, 1, "binary1", "nchar1", now()+1a )
+            ( '2020-12-31 01:01:01.000', 2, 22222, 222, 22, 2.22, 22.22, 0, "binary2", "nchar2", now()+2a )
+            ( '2021-01-01 01:01:06.000', 3, 33333, 333, 33, 3.33, 33.33, 0, "binary3", "nchar3", now()+3a )
+            ( '2021-05-07 01:01:10.000', 4, 44444, 444, 44, 4.44, 44.44, 1, "binary4", "nchar4", now()+4a )
+            ( '2021-07-21 01:01:01.000', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
+            ( '2021-09-30 01:01:16.000', 5, 55555, 555, 55, 5.55, 55.55, 0, "binary5", "nchar5", now()+5a )
+            ( '2022-02-01 01:01:20.000', 6, 66666, 666, 66, 6.66, 66.66, 1, "binary6", "nchar6", now()+6a )
+            ( '2022-10-28 01:01:26.000', 7, 00000, 000, 00, 0.00, 00.00, 1, "binary7", "nchar7", "1970-01-01 08:00:00.000" )
+            ( '2022-12-01 01:01:30.000', 8, -88888, -888, -88, -8.88, -88.88, 0, "binary8", "nchar8", "1969-01-01 01:00:00.000" )
+            ( '2022-12-31 01:01:36.000', 9, -99999999999999999, -999, -99, -9.99, -999999999999999999999.99, 1, "binary9", "nchar9", "1900-01-01 00:00:00.000" )
+            ( '2023-02-21 01:01:01.000', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
+            '''
+        )
+
+        tdSql.execute("create table tb (ts timestamp , num1 int , num2 int, num3 double , num4 binary(30))")
+        tdSql.execute(
+            f'''insert into tb values
+            ( '2020-04-21 01:01:01.000',   NULL,    1,       1,     "binary1" )
+            ( '2020-10-21 01:01:01.000',   1,       1,      1.11,   "binary1" )
+            ( '2020-12-31 01:01:01.000',   2,    22222,      22,    "binary1" )
+            ( '2021-01-01 01:01:06.000',   3,    33333,      33,    "binary1" )
+            ( '2021-05-07 01:01:10.000',   4,    44444,      44,    "binary1" )
+            ( '2021-07-21 01:01:01.000',   NULL,   NULL,     NULL,  "binary1" )
+            ( '2021-09-30 01:01:16.000',   5,    55555,      55,    "binary1" )
+            ( '2022-02-01 01:01:20.000',   6,    66666,      66,    "binary1" )
+            ( '2022-10-28 01:01:26.000',   0,    00000,      00,    "binary1" )
+            ( '2022-12-01 01:01:30.000',   8,   -88888,     -88,    "binary1" )
+            ( '2022-12-31 01:01:36.000',   9, -9999999,     -99,    "binary1" )
+            ( '2023-02-21 01:01:01.000',  NULL,    NULL,    NULL,   "binary1" )
+            '''
+        )
+
+
+    def create_udf_function(self ):
+
+        for i in range(10):
+            # create  scalar functions
+            tdSql.execute("create function udf1 as '/tmp/udf/libudf1.so' outputtype int bufSize 8;")
+
+            # create aggregate functions
+
+            tdSql.execute("create aggregate function udf2 as '/tmp/udf/libudf2.so' outputtype double bufSize 8;")
+            
+            # functions = tdSql.getResult("show functions")
+            # function_nums = len(functions)
+            # if function_nums == 2:
+            #     tdLog.info("create two udf functions success ")
+
+            # drop functions
+
+            tdSql.execute("drop function udf1")
+            tdSql.execute("drop function udf2")
+
+            functions = tdSql.getResult("show functions")
+            for function in functions:
+                if "udf1" in function[0] or  "udf2" in function[0]:
+                    tdLog.info("drop udf functions failed ")
+                    tdLog.exit("drop udf functions failed")
+
+                tdLog.info("drop two udf functions success ")
+
+        # create  scalar functions
+        tdSql.execute("create function udf1 as '/tmp/udf/libudf1.so' outputtype int bufSize 8;")
+
+        # create aggregate functions
+
+        tdSql.execute("create aggregate function udf2 as '/tmp/udf/libudf2.so' outputtype double bufSize 8;")
+        
+        functions = tdSql.getResult("show functions")
+        function_nums = len(functions)
+        if function_nums == 2:
+            tdLog.info("create two udf functions success ")
+       
+    def basic_udf_query(self , dnode):
+        
+        mytdSql = self.getConnection(dnode)
+        # scalar functions
+
+        mytdSql.execute("use db ")
+
+        result = mytdSql.query("select num1 , udf1(num1) ,num2 ,udf1(num2),num3 ,udf1(num3),num4 ,udf1(num4) from tb")
+        data = result.fetch_all()
+        print(data)
+        if data == [(None, None, 1, 88, 1.0, 88, 'binary1', 88), (1, 88, 1, 88, 1.11, 88, 'binary1', 88), (2, 88, 22222, 88, 22.0, 88, 'binary1', 88), (3, 88, 33333, 88, 33.0, 88, 'binary1', 88), (4, 88, 44444, 88, 44.0, 88, 'binary1', 88), (None, None, None, None, None, None, 'binary1', 88), (5, 88, 55555, 88, 55.0, 88, 'binary1', 88), (6, 88, 66666, 88, 66.0, 88, 'binary1', 88), (0, 88, 0, 88, 0.0, 88, 'binary1', 88), (8, 88, -88888, 88, -88.0, 88, 'binary1', 88), (9, 88, -9999999, 88, -99.0, 88, 'binary1', 88), (None, None, None, None, None, None, 'binary1', 88)]:
+            tdLog.info(" UDF query check ok at :dnode_index %s" %dnode.index)
+        else:
+            tdLog.info(" UDF query check failed at :dnode_index %s" %dnode.index)
+            tdLog.exit("query check failed at :dnode_index %s" %dnode.index )
+
+        result = mytdSql.query("select udf1(c1,c6), udf1(c1) ,udf1(c6) from stb1 order by ts")
+        data = result.fetch_all()
+        print(data)
+        if data == [(None, None, None), (88, 88, 88), (88, 88, 88), (88, 88, 88), (88, 88, 88), (None, None, None), (88, 88, 88), (88, 88, 88), (88, 88, 88), (88, 88, 88), (88, 88, 88), (88, 88, 88), (88, 88, 88), (88, 88, 88), (88, 88, 88), (88, 88, 88), (88, 88, 88), (88, 88, 88), (88, 88, 88), (88, 88, 88), (88, 88, 88), (88, 88, 88), (None, 88, None), (88, 88, 88), (None, None, None)]:
+            tdLog.info(" UDF query check ok at :dnode_index %s" %dnode.index)
+        else:
+            tdLog.info(" UDF query check failed at :dnode_index %s" %dnode.index)
+            tdLog.exit("query check failed at :dnode_index %s" %dnode.index )
+
+        result = mytdSql.query("select udf2(c1,c6), udf2(c1) ,udf2(c6) from stb1 ")
+        data = result.fetch_all()
+        print(data)
+        expect_data = [(266.47194411419747, 25.514701644346147, 265.247614503882)]
+        status = True
+        for index in range(len(expect_data[0])):
+            if abs(expect_data[0][index] - data[0][index]) >0.0001:
+                status = False
+                break
+
+        if status :
+            tdLog.info(" UDF query check ok at :dnode_index %s" %dnode.index)
+        else:
+            tdLog.info(" UDF query check failed at :dnode_index %s" %dnode.index)
+            tdLog.exit("query check failed at :dnode_index %s" %dnode.index )
+
+        result = mytdSql.query("select udf2(num1,num2,num3), udf2(num1) ,udf2(num2) from tb ")
+        data = result.fetch_all()
+        print(data)
+        expect_data = [(10000949.554622812, 15.362291495737216, 10000949.553189287)]
+        status = True
+        for index in range(len(expect_data[0])):
+            if abs(expect_data[0][index] - data[0][index]) >0.0001:
+                status = False
+                break
+
+        if status :
+            tdLog.info(" UDF query check ok at :dnode_index %s" %dnode.index)
+        else:
+            tdLog.info(" UDF query check failed at :dnode_index %s" %dnode.index)
+            tdLog.exit("query check failed at :dnode_index %s" %dnode.index )
+        
+
+    def check_UDF_query(self):
+
+        for i in range(20):
+            for dnode in self.TDDnodes.dnodes:
+                self.basic_udf_query(dnode)
+
+
+    def depoly_cluster(self ,dnodes_nums): 
+
+        testCluster = False
+        valgrind = 0  
+        hostname = socket.gethostname()
+        dnodes = []
+        start_port = 6030
+        for num in range(1, dnodes_nums+1):
+            dnode = TDDnode(num)
+            dnode.addExtraCfg("firstEp", f"{hostname}:{start_port}")
+            dnode.addExtraCfg("fqdn", f"{hostname}")
+            dnode.addExtraCfg("serverPort", f"{start_port + (num-1)*100}")
+            dnode.addExtraCfg("monitorFqdn", hostname)
+            dnode.addExtraCfg("monitorPort", 7043)
+            dnodes.append(dnode)
+        
+        self.TDDnodes = MyDnodes(dnodes)
+        self.TDDnodes.init("")
+        self.TDDnodes.setTestCluster(testCluster)
+        self.TDDnodes.setValgrind(valgrind)
+        self.TDDnodes.stopAll()
+        for dnode in self.TDDnodes.dnodes:
+            self.TDDnodes.deploy(dnode.index,{})
+            
+        for dnode in self.TDDnodes.dnodes:
+            self.TDDnodes.start(dnode.index)
+
+        # create cluster 
+
+        for dnode in self.TDDnodes.dnodes:
+            print(dnode.cfgDict)
+            dnode_id = dnode.cfgDict["fqdn"] +  ":" +dnode.cfgDict["serverPort"]
+            dnode_first_host = dnode.cfgDict["firstEp"].split(":")[0]
+            dnode_first_port = dnode.cfgDict["firstEp"].split(":")[-1]
+            cmd = f" taos -h {dnode_first_host} -P {dnode_first_port} -s ' create dnode \"{dnode_id} \" ' ;"
+            print(cmd)
+            os.system(cmd)
+        
+        time.sleep(2)
+        tdLog.info(" create cluster done! ")
+        
+
+        
+    def getConnection(self, dnode):
+        host = dnode.cfgDict["fqdn"]
+        port = dnode.cfgDict["serverPort"]
+        config_dir = dnode.cfgDir
+        return taos.connect(host=host, port=int(port), config=config_dir)
+
+    def restart_udfd(self, dnode):
+        
+        buildPath = self.getBuildPath()
+
+        if (buildPath == ""):
+            tdLog.exit("taosd not found!")
+        else:
+            tdLog.info("taosd found in %s" % buildPath)
+        
+        cfgPath = dnode.cfgDir
+        
+        udfdPath = buildPath +'/build/bin/udfd'
+
+        for i in range(5):
+
+            tdLog.info(" loop restart udfd  %d_th  at dnode_index : %s" % (i ,dnode.index))
+            self.basic_udf_query(dnode)
+            # stop udfd cmds 
+            get_processID = "ps -ef | grep -w udfd | grep %s | grep 'root' | grep -v grep| grep -v defunct | awk '{print $2}'"%cfgPath
+            processID = subprocess.check_output(get_processID, shell=True).decode("utf-8")
+            stop_udfd = " kill -9 %s" % processID
+            os.system(stop_udfd)
+            self.basic_udf_query(dnode)
+
+    def test_restart_udfd_All_dnodes(self):
+
+        for dnode in self.TDDnodes.dnodes:
+            tdLog.info(" start restart udfd for dnode_index :%s" %dnode.index )
+            self.restart_udfd(dnode)
+
+
+    def run(self):  # sourcery skip: extract-duplicate-method, remove-redundant-fstring
+        print(self.master_dnode.cfgDict)
+        self.prepare_data()
+        self.prepare_udf_so()
+        self.create_udf_function()
+        self.basic_udf_query(self.master_dnode)
+        # self.check_UDF_query()
+        self.restart_udfd(self.master_dnode)
+        # self.test_restart_udfd_All_dnodes()
+        
+        
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success(f"{__file__} successfully executed")
+
+tdCases.addLinux(__file__, TDTestCase())
+tdCases.addWindows(__file__, TDTestCase())
\ No newline at end of file

tests/system-test/0-others/user_control.py

@@ -8,11 +8,24 @@ from util.sql import *
 from util.cases import *
 from util.dnodes import *
 
-
 PRIVILEGES_ALL      = "ALL"
 PRIVILEGES_READ     = "READ"
 PRIVILEGES_WRITE    = "WRITE"
 
+PRIMARY_COL = "ts"
+
+INT_COL     = "c1"
+BINT_COL    = "c2"
+SINT_COL    = "c3"
+TINT_COL    = "c4"
+FLOAT_COL   = "c5"
+DOUBLE_COL  = "c6"
+BOOL_COL    = "c7"
+
+BINARY_COL  = "c8"
+NCHAR_COL   = "c9"
+TS_COL      = "c10"
+
 class TDconnect:
     def __init__(self,
                  host       = None,
@@ -189,10 +202,100 @@ class TDTestCase:
         for sql in sqls:
             tdSql.error(sql)
 
-
-    def grant_user_privileges(self, privilege,  dbname=None, user_name="root"):
+    def __grant_user_privileges(self, privilege,  dbname=None, user_name="root"):
         return f"GRANT {privilege} ON {self.__priv_level(dbname)} TO {user_name} "
 
+    def grant_check(self, user="root", passwd="taosdata", priv=PRIVILEGES_ALL):
+        with taos_connect(user=user, passwd=passwd) as user:
+            user.query("use db")
+            user.query("show tables")
+            if priv in [PRIVILEGES_ALL, PRIVILEGES_READ]:
+                user.query("select * from ct1")
+            else:
+                user.error("select * from ct1")
+            if priv in [PRIVILEGES_ALL, PRIVILEGES_WRITE]:
+                user.query("insert into t1 (ts) values (now())")
+            else:
+                user.error("insert into t1 (ts) values (now())")
+
+    def test_grant_current(self):
+        tdLog.printNoPrefix("==========step 1.0: if do not grant, can not read/write")
+        self.grant_check(user=self.__user_list[0], passwd=self.__passwd_list[0], priv=None)
+
+        tdLog.printNoPrefix("==========step 1.1: grant read, can read, can not write")
+        sql = self.__grant_user_privileges(privilege=PRIVILEGES_READ, user_name=self.__user_list[0])
+        tdLog.info(sql)
+        tdSql.query(sql)
+        self.grant_check(user=self.__user_list[0], passwd=self.__passwd_list[0], priv=PRIVILEGES_READ)
+
+        tdLog.printNoPrefix("==========step 1.2: grant write, can write, can not read")
+        sql = self.__grant_user_privileges(privilege=PRIVILEGES_WRITE, user_name=self.__user_list[1])
+        tdLog.info(sql)
+        tdSql.query(sql)
+        self.grant_check(user=self.__user_list[1], passwd=self.__passwd_list[1], priv=PRIVILEGES_WRITE)
+
+        tdLog.printNoPrefix("==========step 1.3: grant all, can write and read")
+        sql = self.__grant_user_privileges(privilege=PRIVILEGES_ALL, user_name=self.__user_list[2])
+        tdLog.info(sql)
+        tdSql.query(sql)
+        self.grant_check(user=self.__user_list[2], passwd=self.__passwd_list[2], priv=PRIVILEGES_ALL)
+
+        tdLog.printNoPrefix("==========step 1.4: change grant read to write, can write , can not read")
+        sql = self.__grant_user_privileges(privilege=PRIVILEGES_WRITE, user_name=self.__user_list[0])
+        tdLog.info(sql)
+        tdSql.query(sql)
+        self.grant_check(user=self.__user_list[0], passwd=self.__passwd_list[0], priv=PRIVILEGES_WRITE)
+
+        tdLog.printNoPrefix("==========step 1.5: change grant write to read, can not write , can read")
+        sql = self.__grant_user_privileges(privilege=PRIVILEGES_READ, user_name=self.__user_list[0])
+        tdLog.info(sql)
+        tdSql.query(sql)
+        self.grant_check(user=self.__user_list[0], passwd=self.__passwd_list[0], priv=PRIVILEGES_READ)
+
+        tdLog.printNoPrefix("==========step 1.6: change grant read to all, can write , can read")
+        sql = self.__grant_user_privileges(privilege=PRIVILEGES_ALL, user_name=self.__user_list[0])
+        tdLog.info(sql)
+        tdSql.query(sql)
+        self.grant_check(user=self.__user_list[0], passwd=self.__passwd_list[0], priv=PRIVILEGES_ALL)
+
+        tdLog.printNoPrefix("==========step 1.7: change grant all to write, can write , can not read")
+        sql = self.__grant_user_privileges(privilege=PRIVILEGES_WRITE, user_name=self.__user_list[0])
+        tdLog.info(sql)
+        tdSql.query(sql)
+        self.grant_check(user=self.__user_list[0], passwd=self.__passwd_list[0], priv=PRIVILEGES_WRITE)
+
+        tdLog.printNoPrefix("==========step 1.8: change grant write to all, can write , can read")
+        sql = self.__grant_user_privileges(privilege=PRIVILEGES_ALL, user_name=self.__user_list[0])
+        tdLog.info(sql)
+        tdSql.query(sql)
+        self.grant_check(user=self.__user_list[0], passwd=self.__passwd_list[0], priv=PRIVILEGES_ALL)
+
+        tdLog.printNoPrefix("==========step 1.9: change grant all to read, can not write , can read")
+        sql = self.__grant_user_privileges(privilege=PRIVILEGES_READ, user_name=self.__user_list[0])
+        tdLog.info(sql)
+        tdSql.query(sql)
+        self.grant_check(user=self.__user_list[0], passwd=self.__passwd_list[0], priv=PRIVILEGES_READ)
+
+    def __grant_err(self):
+        return [
+            self.__grant_user_privileges(privilege=self.__privilege[0], user_name="") ,
+            self.__grant_user_privileges(privilege=self.__privilege[0], user_name="*") ,
+            self.__grant_user_privileges(privilege=self.__privilege[1], dbname="not_exist_db", user_name=self.__user_list[0]),
+            self.__grant_user_privileges(privilege="any_priv", user_name=self.__user_list[0]),
+            self.__grant_user_privileges(privilege="", dbname="db", user_name=self.__user_list[0]) ,
+            self.__grant_user_privileges(privilege=" ".join(self.__privilege), user_name=self.__user_list[0]) ,
+            f"GRANT {self.__privilege[0]} ON * TO {self.__user_list[0]}" ,
+            f"GRANT {self.__privilege[0]} ON db.t1 TO {self.__user_list[0]}" ,
+        ]
+
+    def test_grant_err(self):
+        for sql in self.__grant_err():
+            tdSql.error(sql)
+
+    def test_grant(self):
+        self.test_grant_err()
+        self.test_grant_current()
+
     def test_user_create(self):
         self.create_user_current()
         self.create_user_err()
@@ -218,7 +321,6 @@ class TDTestCase:
         else:
             tdLog.info("connect successfully, user and pass matched!")
 
-
     def login_err(self, user, passwd):
         login_except, _ = self.user_login(user, passwd)
         if login_except:
@@ -253,7 +355,110 @@ class TDTestCase:
         self.drop_user_error()
         self.drop_user_current()
 
+    def __create_tb(self):
+
+        tdLog.printNoPrefix("==========step1:create table")
+        create_stb_sql  =  f'''create table stb1(
+                ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint,
+                 {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool,
+                 {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp
+            ) tags (t1 int)
+            '''
+        create_ntb_sql = f'''create table t1(
+                ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint,
+                 {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool,
+                 {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp
+            )
+            '''
+        tdSql.execute(create_stb_sql)
+        tdSql.execute(create_ntb_sql)
+
+        for i in range(4):
+            tdSql.execute(f'create table ct{i+1} using stb1 tags ( {i+1} )')
+            { i % 32767 }, { i % 127}, { i * 1.11111 }, { i * 1000.1111 }, { i % 2}
+
+    def __insert_data(self, rows):
+        now_time = int(datetime.datetime.timestamp(datetime.datetime.now()) * 1000)
+        for i in range(rows):
+            tdSql.execute(
+                f"insert into ct1 values ( { now_time - i * 1000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )"
+            )
+            tdSql.execute(
+                f"insert into ct4 values ( { now_time - i * 7776000000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )"
+            )
+            tdSql.execute(
+                f"insert into ct2 values ( { now_time - i * 7776000000 }, {-i},  {-11111 * i}, {-111 * i % 32767 }, {-11 * i % 127}, {-1.11*i}, {-1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )"
+            )
+        tdSql.execute(
+            f'''insert into ct1 values
+            ( { now_time - rows * 5 }, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar_测试_0', { now_time + 8 } )
+            ( { now_time + 10000 }, { rows }, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar_测试_9', { now_time + 9 } )
+            '''
+        )
+
+        tdSql.execute(
+            f'''insert into ct4 values
+            ( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
+            ( { now_time - rows * 3888000000 + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
+            ( { now_time +  7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
+            (
+                { now_time + 5184000000}, {pow(2,31)-pow(2,15)}, {pow(2,63)-pow(2,30)}, 32767, 127,
+                { 3.3 * pow(10,38) }, { 1.3 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000}
+                )
+            (
+                { now_time + 2592000000 }, {pow(2,31)-pow(2,16)}, {pow(2,63)-pow(2,31)}, 32766, 126,
+                { 3.2 * pow(10,38) }, { 1.2 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000}
+                )
+            '''
+        )
+
+        tdSql.execute(
+            f'''insert into ct2 values
+            ( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
+            ( { now_time - rows * 3888000000 + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
+            ( { now_time + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
+            (
+                { now_time + 5184000000 }, { -1 * pow(2,31) + pow(2,15) }, { -1 * pow(2,63) + pow(2,30) }, -32766, -126,
+                { -1 * 3.2 * pow(10,38) }, { -1.2 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 }
+                )
+            (
+                { now_time + 2592000000 }, { -1 * pow(2,31) + pow(2,16) }, { -1 * pow(2,63) + pow(2,31) }, -32767, -127,
+                { - 3.3 * pow(10,38) }, { -1.3 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 }
+                )
+            '''
+        )
+
+        for i in range(rows):
+            insert_data = f'''insert into t1 values
+                ( { now_time - i * 3600000 }, {i}, {i * 11111}, { i % 32767 }, { i % 127}, { i * 1.11111 }, { i * 1000.1111 }, { i % 2},
+                "binary_{i}", "nchar_测试_{i}", { now_time - 1000 * i } )
+                '''
+            tdSql.execute(insert_data)
+        tdSql.execute(
+            f'''insert into t1 values
+            ( { now_time + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
+            ( { now_time - (( rows // 2 ) * 60 + 30) * 60000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
+            ( { now_time - rows * 3600000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
+            ( { now_time + 7200000 }, { pow(2,31) - pow(2,15) }, { pow(2,63) - pow(2,30) }, 32767, 127,
+                { 3.3 * pow(10,38) }, { 1.3 * pow(10,308) }, { rows % 2 },
+                "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 }
+                )
+            (
+                { now_time + 3600000 } , { pow(2,31) - pow(2,16) }, { pow(2,63) - pow(2,31) }, 32766, 126,
+                { 3.2 * pow(10,38) }, { 1.2 * pow(10,308) }, { (rows-1) % 2 },
+                "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 }
+                )
+            '''
+        )
+
     def run(self):
+        tdSql.prepare()
+        self.__create_tb()
+        self.rows = 10
+        self.__insert_data(self.rows)
+
+        tdDnodes.stop(1)
+        tdDnodes.start(1)
 
         # 默认只有 root 用户
         tdLog.printNoPrefix("==========step0: init, user list only has root account")
@@ -276,6 +481,9 @@ class TDTestCase:
         self.login_currrent(self.__user_list[0], self.__passwd_list[0])
         self.login_err(self.__user_list[0], f"new{self.__passwd_list[0]}")
 
+        # 用户权限设置
+        self.test_grant()
+
         # 修改密码
         tdLog.printNoPrefix("==========step3: alter user pass test")
         self.test_alter_pass()

tests/system-test/2-query/nestedQuery.py

@@ -736,7 +736,7 @@ class TDTestCase:
             sql += ")"
             tdLog.info(sql) 
             tdLog.info(len(sql))      
-            tdSql.error(sql)
+            #tdSql.error(sql)
             #TD-15610 tdSql.query(sql)
             # tdSql.checkRows(100)
 

tests/system-test/7-tmq/subscribeStb.py

+
+import taos
+import sys
+import time
+import socket
+import os
+import threading
+from enum import Enum
+
+from util.log import *
+from util.sql import *
+from util.cases import *
+from util.dnodes import *
+
+class actionType(Enum):
+    CREATE_DATABASE = 0
+    CREATE_STABLE   = 1
+    CREATE_CTABLE   = 2
+    INSERT_DATA     = 3
+
+class TDTestCase:
+    hostname = socket.gethostname()
+    #rpcDebugFlagVal = '143'
+    #clientCfgDict = {'serverPort': '', 'firstEp': '', 'secondEp':'', 'rpcDebugFlag':'135', 'fqdn':''}
+    #clientCfgDict["rpcDebugFlag"]  = rpcDebugFlagVal
+    #updatecfgDict = {'clientCfg': {}, 'serverPort': '', 'firstEp': '', 'secondEp':'', 'rpcDebugFlag':'135', 'fqdn':''}
+    #updatecfgDict["rpcDebugFlag"] = rpcDebugFlagVal
+    #print ("===================: ", updatecfgDict)
+
+    def init(self, conn, logSql):
+        tdLog.debug(f"start to excute {__file__}")
+        #tdSql.init(conn.cursor())
+        tdSql.init(conn.cursor(), logSql)  # output sql.txt file
+
+    def getBuildPath(self):
+        selfPath = os.path.dirname(os.path.realpath(__file__))
+
+        if ("community" in selfPath):
+            projPath = selfPath[:selfPath.find("community")]
+        else:
+            projPath = selfPath[:selfPath.find("tests")]
+
+        for root, dirs, files in os.walk(projPath):
+            if ("taosd" in files):
+                rootRealPath = os.path.dirname(os.path.realpath(root))
+                if ("packaging" not in rootRealPath):
+                    buildPath = root[:len(root) - len("/build/bin")]
+                    break
+        return buildPath
+
+    def newcur(self,cfg,host,port):
+        user = "root"
+        password = "taosdata"
+        con=taos.connect(host=host, user=user, password=password, config=cfg ,port=port)
+        cur=con.cursor()
+        print(cur)
+        return cur
+
+    def initConsumerTable(self,cdbName='cdb'):        
+        tdLog.info("create consume database, and consume info table, and consume result table")
+        tdSql.query("create database if not exists %s vgroups 1"%(cdbName))
+        tdSql.query("drop table if exists %s.consumeinfo "%(cdbName))
+        tdSql.query("drop table if exists %s.consumeresult "%(cdbName))
+
+        tdSql.query("create table %s.consumeinfo (ts timestamp, consumerid int, topiclist binary(1024), keylist binary(1024), expectmsgcnt bigint, ifcheckdata int, ifmanualcommit int)"%cdbName)
+        tdSql.query("create table %s.consumeresult (ts timestamp, consumerid int, consummsgcnt bigint, consumrowcnt bigint, checkresult int)"%cdbName)
+
+    def initConsumerInfoTable(self,cdbName='cdb'):        
+        tdLog.info("drop consumeinfo table")
+        tdSql.query("drop table if exists %s.consumeinfo "%(cdbName))
+        tdSql.query("create table %s.consumeinfo (ts timestamp, consumerid int, topiclist binary(1024), keylist binary(1024), expectmsgcnt bigint, ifcheckdata int, ifmanualcommit int)"%cdbName)
+
+    def insertConsumerInfo(self,consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifmanualcommit,cdbName='cdb'):    
+        sql = "insert into %s.consumeinfo values "%cdbName
+        sql += "(now, %d, '%s', '%s', %d, %d, %d)"%(consumerId, topicList, keyList, expectrowcnt, ifcheckdata, ifmanualcommit)
+        tdLog.info("consume info sql: %s"%sql)
+        tdSql.query(sql)
+
+    def selectConsumeResult(self,expectRows,cdbName='cdb'):
+        resultList=[]
+        while 1:
+            tdSql.query("select * from %s.consumeresult"%cdbName)
+            #tdLog.info("row: %d, %l64d, %l64d"%(tdSql.getData(0, 1),tdSql.getData(0, 2),tdSql.getData(0, 3))
+            if tdSql.getRows() == expectRows:
+                break
+            else:
+                time.sleep(5)
+        
+        for i in range(expectRows):
+            tdLog.info ("consume id: %d, consume msgs: %d, consume rows: %d"%(tdSql.getData(i , 1), tdSql.getData(i , 2), tdSql.getData(i , 3)))
+            resultList.append(tdSql.getData(i , 3))
+        
+        return resultList
+
+    def startTmqSimProcess(self,buildPath,cfgPath,pollDelay,dbName,showMsg=1,showRow=1,cdbName='cdb',valgrind=0):
+        shellCmd = 'nohup '
+        if valgrind == 1:
+            logFile = cfgPath + '/../log/valgrind-tmq.log'
+            shellCmd = 'nohup valgrind --log-file=' + logFile
+            shellCmd += '--tool=memcheck --leak-check=full --show-reachable=no --track-origins=yes --show-leak-kinds=all --num-callers=20 -v --workaround-gcc296-bugs=yes '
+        
+        shellCmd += buildPath + '/build/bin/tmq_sim -c ' + cfgPath
+        shellCmd += " -y %d -d %s -g %d -r %d -w %s "%(pollDelay, dbName, showMsg, showRow, cdbName) 
+        shellCmd += "> /dev/null 2>&1 &"
+        tdLog.info(shellCmd)
+        os.system(shellCmd)
+
+    def create_database(self,tsql, dbName,dropFlag=1,vgroups=4,replica=1):
+        if dropFlag == 1:
+            tsql.execute("drop database if exists %s"%(dbName))
+
+        tsql.execute("create database if not exists %s vgroups %d replica %d"%(dbName, vgroups, replica))
+        tdLog.debug("complete to create database %s"%(dbName))
+        return
+
+    def create_stable(self,tsql, dbName,stbName):
+        tsql.execute("create table if not exists %s.%s (ts timestamp, c1 bigint, c2 binary(16)) tags(t1 int)"%(dbName, stbName))
+        tdLog.debug("complete to create %s.%s" %(dbName, stbName))
+        return
+
+    def create_ctables(self,tsql, dbName,stbName,ctbNum):
+        tsql.execute("use %s" %dbName)
+        pre_create = "create table"
+        sql = pre_create
+        #tdLog.debug("doing create one  stable %s and %d  child table in %s  ..." %(stbname, count ,dbname))
+        for i in range(ctbNum):
+            sql += " %s_%d using %s tags(%d)"%(stbName,i,stbName,i+1)
+            if (i > 0) and (i%100 == 0):
+                tsql.execute(sql)
+                sql = pre_create
+        if sql != pre_create:
+            tsql.execute(sql)
+        
+        tdLog.debug("complete to create %d child tables in %s.%s" %(ctbNum, dbName, stbName))
+        return
+
+    def insert_data(self,tsql,dbName,stbName,ctbNum,rowsPerTbl,batchNum,startTs=0):
+        tdLog.debug("start to insert data ............")
+        tsql.execute("use %s" %dbName)
+        pre_insert = "insert into "
+        sql = pre_insert
+
+        if startTs == 0:
+            t = time.time()
+            startTs = int(round(t * 1000))
+
+        #tdLog.debug("doing insert data into stable:%s rows:%d ..."%(stbName, allRows))
+        rowsOfSql = 0        
+        for i in range(ctbNum):
+            sql += " %s_%d values "%(stbName,i)
+            for j in range(rowsPerTbl):
+                sql += "(%d, %d, 'tmqrow_%d') "%(startTs + j, j, j)
+                rowsOfSql += 1
+                if (j > 0) and ((rowsOfSql == batchNum) or (j == rowsPerTbl - 1)):
+                    tsql.execute(sql)
+                    rowsOfSql = 0
+                    if j < rowsPerTbl - 1:
+                        sql = "insert into %s_%d values " %(stbName,i)
+                    else:
+                        sql = "insert into "
+        #end sql
+        if sql != pre_insert:
+            #print("insert sql:%s"%sql)
+            tsql.execute(sql)
+        tdLog.debug("insert data ............ [OK]")
+        return
+        
+    def prepareEnv(self, **parameterDict):            
+        # create new connector for my thread
+        tsql=self.newcur(parameterDict['cfg'], 'localhost', 6030)
+
+        if parameterDict["actionType"] == actionType.CREATE_DATABASE:
+            self.create_database(tsql, parameterDict["dbName"])
+        elif parameterDict["actionType"] == actionType.CREATE_STABLE:
+            self.create_stable(tsql, parameterDict["dbName"], parameterDict["stbName"])
+        elif parameterDict["actionType"] == actionType.CREATE_CTABLE:
+            self.create_ctables(tsql, parameterDict["dbName"], parameterDict["stbName"], parameterDict["ctbNum"])
+        elif parameterDict["actionType"] == actionType.INSERT_DATA:
+            self.insert_data(tsql, parameterDict["dbName"], parameterDict["stbName"], parameterDict["ctbNum"],\
+                            parameterDict["rowsPerTbl"],parameterDict["batchNum"])
+        else:
+            tdLog.exit("not support's action: ", parameterDict["actionType"])
+
+        return
+
+    def tmqCase1(self, cfgPath, buildPath):
+        tdLog.printNoPrefix("======== test case 1: ")       
+        
+        self.initConsumerTable()
+
+        # create and start thread
+        parameterDict = {'cfg':        '',       \
+                         'actionType': 0,        \
+                         'dbName':     'db1',    \
+                         'dropFlag':   1,        \
+                         'vgroups':    4,        \
+                         'replica':    1,        \
+                         'stbName':    'stb1',    \
+                         'ctbNum':     10,       \
+                         'rowsPerTbl': 10000,    \
+                         'batchNum':   100,      \
+                         'startTs':    1640966400000}  # 2022-01-01 00:00:00.000
+        parameterDict['cfg'] = cfgPath
+        
+        self.create_database(tdSql, parameterDict["dbName"])
+        self.create_stable(tdSql, parameterDict["dbName"], parameterDict["stbName"])
+
+        tdLog.info("create topics from stb1")
+        topicFromStb1 = 'topic_stb1'
+        
+        tdSql.execute("create topic %s as select ts, c1, c2 from %s.%s" %(topicFromStb1, parameterDict['dbName'], parameterDict['stbName']))
+        consumerId     = 0
+        expectrowcnt   = parameterDict["rowsPerTbl"] * parameterDict["ctbNum"]
+        topicList      = topicFromStb1
+        ifcheckdata    = 0
+        ifManualCommit = 0
+        keyList        = 'group.id:cgrp1,\
+                        enable.auto.commit:false,\
+                        auto.commit.interval.ms:6000,\
+                        auto.offset.reset:earliest'
+        self.insertConsumerInfo(consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifManualCommit)
+
+        tdLog.info("start consume processor")
+        pollDelay = 100
+        showMsg   = 1
+        showRow   = 1
+        self.startTmqSimProcess(buildPath,cfgPath,pollDelay,parameterDict["dbName"],showMsg, showRow)
+
+        time.sleep(5)
+        self.create_ctables(tdSql, parameterDict["dbName"], parameterDict["stbName"], parameterDict["ctbNum"])
+        self.insert_data(tdSql,\
+                         parameterDict["dbName"],\
+                         parameterDict["stbName"],\
+                         parameterDict["ctbNum"],\
+                         parameterDict["rowsPerTbl"],\
+                         parameterDict["batchNum"])
+
+        tdLog.info("insert process end, and start to check consume result")
+        expectRows = 1
+        resultList = self.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+        
+        if totalConsumeRows != expectrowcnt:
+            tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, expectrowcnt))
+            tdLog.exit("tmq consume rows error!")
+
+        tdSql.query("drop topic %s"%topicFromStb1)
+
+        tdLog.printNoPrefix("======== test case 1 end ...... ")
+
+    def tmqCase2(self, cfgPath, buildPath):
+        tdLog.printNoPrefix("======== test case 2: ")       
+        
+        self.initConsumerTable()
+
+        # create and start thread
+        parameterDict = {'cfg':        '',       \
+                         'actionType': 0,        \
+                         'dbName':     'db2',    \
+                         'dropFlag':   1,        \
+                         'vgroups':    4,        \
+                         'replica':    1,        \
+                         'stbName':    'stb1',    \
+                         'ctbNum':     10,       \
+                         'rowsPerTbl': 10000,    \
+                         'batchNum':   100,      \
+                         'startTs':    1640966400000}  # 2022-01-01 00:00:00.000
+        parameterDict['cfg'] = cfgPath
+
+        parameterDict2 = {'cfg':        '',       \
+                         'actionType': 0,        \
+                         'dbName':     'db2',    \
+                         'dropFlag':   1,        \
+                         'vgroups':    4,        \
+                         'replica':    1,        \
+                         'stbName':    'stb2',    \
+                         'ctbNum':     10,       \
+                         'rowsPerTbl': 10000,    \
+                         'batchNum':   100,      \
+                         'startTs':    1640966400000}  # 2022-01-01 00:00:00.000
+        parameterDict2['cfg'] = cfgPath
+
+        self.create_database(tdSql, parameterDict["dbName"])
+        self.create_stable(tdSql, parameterDict["dbName"], parameterDict["stbName"])
+        self.create_stable(tdSql, parameterDict2["dbName"], parameterDict2["stbName"])
+
+        tdLog.info("create topics from stb1")
+        topicFromStb1 = 'topic_stb1'
+        
+        tdSql.execute("create topic %s as select ts, c1, c2 from %s.%s" %(topicFromStb1, parameterDict['dbName'], parameterDict['stbName']))
+        consumerId     = 0
+        expectrowcnt   = parameterDict["rowsPerTbl"] * parameterDict["ctbNum"]
+        topicList      = topicFromStb1
+        ifcheckdata    = 0
+        ifManualCommit = 0
+        keyList        = 'group.id:cgrp1,\
+                        enable.auto.commit:false,\
+                        auto.commit.interval.ms:6000,\
+                        auto.offset.reset:earliest'
+        self.insertConsumerInfo(consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifManualCommit)
+
+        tdLog.info("start consume processor")
+        pollDelay = 100
+        showMsg   = 1
+        showRow   = 1
+        self.startTmqSimProcess(buildPath,cfgPath,pollDelay,parameterDict["dbName"],showMsg, showRow)
+
+        tdLog.info("start create child tables of stb1 and stb2")
+        parameterDict['actionType'] = actionType.CREATE_CTABLE
+        parameterDict2['actionType'] = actionType.CREATE_CTABLE
+
+        prepareEnvThread = threading.Thread(target=self.prepareEnv, kwargs=parameterDict)
+        prepareEnvThread.start()
+        prepareEnvThread2 = threading.Thread(target=self.prepareEnv, kwargs=parameterDict2)
+        prepareEnvThread2.start()
+
+        prepareEnvThread.join()
+        prepareEnvThread2.join()
+
+        tdLog.info("start insert data into child tables of stb1 and stb2")
+        parameterDict['actionType'] = actionType.INSERT_DATA
+        parameterDict2['actionType'] = actionType.INSERT_DATA
+
+        prepareEnvThread = threading.Thread(target=self.prepareEnv, kwargs=parameterDict)
+        prepareEnvThread.start()
+        prepareEnvThread2 = threading.Thread(target=self.prepareEnv, kwargs=parameterDict2)
+        prepareEnvThread2.start()
+
+        prepareEnvThread.join()
+        prepareEnvThread2.join()
+
+        tdLog.info("insert process end, and start to check consume result")
+        expectRows = 1
+        resultList = self.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+        
+        if totalConsumeRows != expectrowcnt:
+            tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, expectrowcnt))
+            tdLog.exit("tmq consume rows error!")
+
+        tdSql.query("drop topic %s"%topicFromStb1)
+
+        tdLog.printNoPrefix("======== test case 2 end ...... ")
+
+    def tmqCase3(self, cfgPath, buildPath):
+        tdLog.printNoPrefix("======== test case 3: ")       
+        
+        self.initConsumerTable()
+
+        # create and start thread
+        parameterDict = {'cfg':        '',       \
+                         'actionType': 0,        \
+                         'dbName':     'db3',    \
+                         'dropFlag':   1,        \
+                         'vgroups':    4,        \
+                         'replica':    1,        \
+                         'stbName':    'stb1',    \
+                         'ctbNum':     10,       \
+                         'rowsPerTbl': 10000,    \
+                         'batchNum':   13,       \
+                         'startTs':    1640966400000}  # 2022-01-01 00:00:00.000
+        parameterDict['cfg'] = cfgPath
+
+        self.create_database(tdSql, parameterDict["dbName"])
+        self.create_stable(tdSql, parameterDict["dbName"], parameterDict["stbName"])
+        self.create_ctables(tdSql, parameterDict["dbName"], parameterDict["stbName"], parameterDict["ctbNum"])
+        self.insert_data(tdSql,parameterDict["dbName"],parameterDict["stbName"],parameterDict["ctbNum"],parameterDict["rowsPerTbl"],parameterDict["batchNum"])
+
+        tdLog.info("create topics from stb1")
+        topicFromStb1 = 'topic_stb1'
+        
+        tdSql.execute("create topic %s as select ts, c1, c2 from %s.%s" %(topicFromStb1, parameterDict['dbName'], parameterDict['stbName']))
+        consumerId     = 0
+        expectrowcnt   = parameterDict["rowsPerTbl"] * parameterDict["ctbNum"]
+        topicList      = topicFromStb1
+        ifcheckdata    = 0
+        ifManualCommit = 0
+        keyList        = 'group.id:cgrp1,\
+                        enable.auto.commit:false,\
+                        auto.commit.interval.ms:6000,\
+                        auto.offset.reset:earliest'
+        self.insertConsumerInfo(consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifManualCommit)
+
+        tdLog.info("start consume processor")
+        pollDelay = 5
+        showMsg   = 1
+        showRow   = 1
+        self.startTmqSimProcess(buildPath,cfgPath,pollDelay,parameterDict["dbName"],showMsg, showRow)
+        
+        time.sleep(2)
+        tdLog.info("drop som child table of stb1")
+        dropTblNum = 4
+        tdSql.query("drop table if exists %s.%s_9"%(parameterDict["dbName"], parameterDict["stbName"]))
+        tdSql.query("drop table if exists %s.%s_8"%(parameterDict["dbName"], parameterDict["stbName"]))
+        tdSql.query("drop table if exists %s.%s_7"%(parameterDict["dbName"], parameterDict["stbName"]))
+        tdSql.query("drop table if exists %s.%s_3"%(parameterDict["dbName"], parameterDict["stbName"]))
+
+        tdLog.info("drop some child tables, then start to check consume result")
+        expectRows = 1
+        resultList = self.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+                
+        remaindrowcnt = parameterDict["rowsPerTbl"] * (parameterDict["ctbNum"] - dropTblNum)
+
+        if not (totalConsumeRows < expectrowcnt and totalConsumeRows > remaindrowcnt):
+            tdLog.info("act consume rows: %d, expect consume rows: between %d and %d"%(totalConsumeRows, remaindrowcnt, expectrowcnt))
+            tdLog.exit("tmq consume rows error!")
+
+        tdSql.query("drop topic %s"%topicFromStb1)
+
+        tdLog.printNoPrefix("======== test case 3 end ...... ")
+
+    def tmqCase4(self, cfgPath, buildPath):
+        tdLog.printNoPrefix("======== test case 4: ")
+        
+        self.initConsumerTable()
+
+        # create and start thread
+        parameterDict = {'cfg':        '',       \
+                         'actionType': 0,        \
+                         'dbName':     'db4',    \
+                         'dropFlag':   1,        \
+                         'vgroups':    4,        \
+                         'replica':    1,        \
+                         'stbName':    'stb1',   \
+                         'ctbNum':     10,       \
+                         'rowsPerTbl': 10000,    \
+                         'batchNum':   100,      \
+                         'startTs':    1640966400000}  # 2022-01-01 00:00:00.000
+        parameterDict['cfg'] = cfgPath
+        
+        self.create_database(tdSql, parameterDict["dbName"])
+        self.create_stable(tdSql, parameterDict["dbName"], parameterDict["stbName"])
+        self.create_ctables(tdSql, parameterDict["dbName"], parameterDict["stbName"], parameterDict["ctbNum"])
+        self.insert_data(tdSql,\
+                         parameterDict["dbName"],\
+                         parameterDict["stbName"],\
+                         parameterDict["ctbNum"],\
+                         parameterDict["rowsPerTbl"],\
+                         parameterDict["batchNum"])
+
+        tdLog.info("create topics from stb1")
+        topicFromStb1 = 'topic_stb1'
+        
+        tdSql.execute("create topic %s as select ts, c1, c2 from %s.%s" %(topicFromStb1, parameterDict['dbName'], parameterDict['stbName']))
+        consumerId     = 0
+        expectrowcnt   = parameterDict["rowsPerTbl"] * parameterDict["ctbNum"]
+        topicList      = topicFromStb1
+        ifcheckdata    = 0
+        ifManualCommit = 1
+        keyList        = 'group.id:cgrp1,\
+                        enable.auto.commit:false,\
+                        auto.commit.interval.ms:6000,\
+                        auto.offset.reset:earliest'
+        self.insertConsumerInfo(consumerId, expectrowcnt/4,topicList,keyList,ifcheckdata,ifManualCommit)
+
+        tdLog.info("start consume processor")
+        pollDelay = 5
+        showMsg   = 1
+        showRow   = 1
+        self.startTmqSimProcess(buildPath,cfgPath,pollDelay,parameterDict["dbName"],showMsg, showRow)
+
+        tdLog.info("start to check consume result")
+        expectRows = 1
+        resultList = self.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+        
+        if totalConsumeRows != expectrowcnt/4:
+            tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, expectrowcnt/4))
+            tdLog.exit("tmq consume rows error!")
+
+        self.initConsumerInfoTable()
+        consumerId = 1
+        self.insertConsumerInfo(consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifManualCommit)
+
+        tdLog.info("again start consume processor")
+        self.startTmqSimProcess(buildPath,cfgPath,pollDelay,parameterDict["dbName"],showMsg, showRow)
+
+        tdLog.info("again check consume result")
+        expectRows = 2
+        resultList = self.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+        
+        if totalConsumeRows != expectrowcnt:
+            tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, expectrowcnt))
+            tdLog.exit("tmq consume rows error!")
+
+        tdSql.query("drop topic %s"%topicFromStb1)
+
+        tdLog.printNoPrefix("======== test case 4 end ...... ")
+
+    def tmqCase5(self, cfgPath, buildPath):
+        tdLog.printNoPrefix("======== test case 5: ")
+        
+        self.initConsumerTable()
+
+        # create and start thread
+        parameterDict = {'cfg':        '',       \
+                         'actionType': 0,        \
+                         'dbName':     'db5',    \
+                         'dropFlag':   1,        \
+                         'vgroups':    4,        \
+                         'replica':    1,        \
+                         'stbName':    'stb1',   \
+                         'ctbNum':     10,       \
+                         'rowsPerTbl': 10000,    \
+                         'batchNum':   100,      \
+                         'startTs':    1640966400000}  # 2022-01-01 00:00:00.000
+        parameterDict['cfg'] = cfgPath
+        
+        self.create_database(tdSql, parameterDict["dbName"])
+        self.create_stable(tdSql, parameterDict["dbName"], parameterDict["stbName"])
+        self.create_ctables(tdSql, parameterDict["dbName"], parameterDict["stbName"], parameterDict["ctbNum"])
+        self.insert_data(tdSql,\
+                         parameterDict["dbName"],\
+                         parameterDict["stbName"],\
+                         parameterDict["ctbNum"],\
+                         parameterDict["rowsPerTbl"],\
+                         parameterDict["batchNum"])
+
+        tdLog.info("create topics from stb1")
+        topicFromStb1 = 'topic_stb1'
+        
+        tdSql.execute("create topic %s as select ts, c1, c2 from %s.%s" %(topicFromStb1, parameterDict['dbName'], parameterDict['stbName']))
+        consumerId     = 0
+        expectrowcnt   = parameterDict["rowsPerTbl"] * parameterDict["ctbNum"]
+        topicList      = topicFromStb1
+        ifcheckdata    = 0
+        ifManualCommit = 0
+        keyList        = 'group.id:cgrp1,\
+                        enable.auto.commit:false,\
+                        auto.commit.interval.ms:6000,\
+                        auto.offset.reset:earliest'
+        self.insertConsumerInfo(consumerId, expectrowcnt/4,topicList,keyList,ifcheckdata,ifManualCommit)
+
+        tdLog.info("start consume processor")
+        pollDelay = 5
+        showMsg   = 1
+        showRow   = 1
+        self.startTmqSimProcess(buildPath,cfgPath,pollDelay,parameterDict["dbName"],showMsg, showRow)
+
+        tdLog.info("start to check consume result")
+        expectRows = 1
+        resultList = self.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+        
+        if totalConsumeRows != expectrowcnt/4:
+            tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, expectrowcnt/4))
+            tdLog.exit("tmq consume rows error!")
+
+        self.initConsumerInfoTable()
+        consumerId = 1
+        self.insertConsumerInfo(consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifManualCommit)
+
+        tdLog.info("again start consume processor")
+        self.startTmqSimProcess(buildPath,cfgPath,pollDelay,parameterDict["dbName"],showMsg, showRow)
+
+        tdLog.info("again check consume result")
+        expectRows = 2
+        resultList = self.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+        
+        if totalConsumeRows != (expectrowcnt * (1 + 1/4)):
+            tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, expectrowcnt))
+            tdLog.exit("tmq consume rows error!")
+
+        tdSql.query("drop topic %s"%topicFromStb1)
+
+        tdLog.printNoPrefix("======== test case 5 end ...... ")
+
+    def tmqCase6(self, cfgPath, buildPath):
+        tdLog.printNoPrefix("======== test case 6: ")
+        
+        self.initConsumerTable()
+
+        # create and start thread
+        parameterDict = {'cfg':        '',       \
+                         'actionType': 0,        \
+                         'dbName':     'db6',    \
+                         'dropFlag':   1,        \
+                         'vgroups':    4,        \
+                         'replica':    1,        \
+                         'stbName':    'stb1',   \
+                         'ctbNum':     10,       \
+                         'rowsPerTbl': 10000,    \
+                         'batchNum':   100,      \
+                         'startTs':    1640966400000}  # 2022-01-01 00:00:00.000
+        parameterDict['cfg'] = cfgPath
+        
+        self.create_database(tdSql, parameterDict["dbName"])
+        self.create_stable(tdSql, parameterDict["dbName"], parameterDict["stbName"])
+        self.create_ctables(tdSql, parameterDict["dbName"], parameterDict["stbName"], parameterDict["ctbNum"])
+        self.insert_data(tdSql,\
+                         parameterDict["dbName"],\
+                         parameterDict["stbName"],\
+                         parameterDict["ctbNum"],\
+                         parameterDict["rowsPerTbl"],\
+                         parameterDict["batchNum"])
+
+        tdLog.info("create topics from stb1")
+        topicFromStb1 = 'topic_stb1'
+        
+        tdSql.execute("create topic %s as select ts, c1, c2 from %s.%s" %(topicFromStb1, parameterDict['dbName'], parameterDict['stbName']))
+        consumerId     = 0
+        expectrowcnt   = parameterDict["rowsPerTbl"] * parameterDict["ctbNum"]
+        topicList      = topicFromStb1
+        ifcheckdata    = 0
+        ifManualCommit = 1
+        keyList        = 'group.id:cgrp1,\
+                        enable.auto.commit:false,\
+                        auto.commit.interval.ms:6000,\
+                        auto.offset.reset:earliest'
+        self.insertConsumerInfo(consumerId, expectrowcnt/4,topicList,keyList,ifcheckdata,ifManualCommit)
+
+        tdLog.info("start consume processor")
+        pollDelay = 5
+        showMsg   = 1
+        showRow   = 1
+        self.startTmqSimProcess(buildPath,cfgPath,pollDelay,parameterDict["dbName"],showMsg, showRow)
+
+        tdLog.info("start to check consume result")
+        expectRows = 1
+        resultList = self.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+        
+        if totalConsumeRows != expectrowcnt/4:
+            tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, expectrowcnt/4))
+            tdLog.exit("tmq consume rows error!")
+
+        self.initConsumerInfoTable()
+        consumerId = 1
+        keyList        = 'group.id:cgrp1,\
+                        enable.auto.commit:false,\
+                        auto.commit.interval.ms:6000,\
+                        auto.offset.reset:latest'
+        self.insertConsumerInfo(consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifManualCommit)
+
+        tdLog.info("again start consume processor")
+        self.startTmqSimProcess(buildPath,cfgPath,pollDelay,parameterDict["dbName"],showMsg, showRow)
+
+        tdLog.info("again check consume result")
+        expectRows = 2
+        resultList = self.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+        
+        if totalConsumeRows != expectrowcnt:
+            tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, expectrowcnt))
+            tdLog.exit("tmq consume rows error!")
+
+        tdSql.query("drop topic %s"%topicFromStb1)
+
+        tdLog.printNoPrefix("======== test case 6 end ...... ")
+
+    def tmqCase7(self, cfgPath, buildPath):
+        tdLog.printNoPrefix("======== test case 7: ")
+        
+        self.initConsumerTable()
+
+        # create and start thread
+        parameterDict = {'cfg':        '',       \
+                         'actionType': 0,        \
+                         'dbName':     'db7',    \
+                         'dropFlag':   1,        \
+                         'vgroups':    4,        \
+                         'replica':    1,        \
+                         'stbName':    'stb1',   \
+                         'ctbNum':     10,       \
+                         'rowsPerTbl': 10000,    \
+                         'batchNum':   100,      \
+                         'startTs':    1640966400000}  # 2022-01-01 00:00:00.000
+        parameterDict['cfg'] = cfgPath
+        
+        self.create_database(tdSql, parameterDict["dbName"])
+        self.create_stable(tdSql, parameterDict["dbName"], parameterDict["stbName"])
+        self.create_ctables(tdSql, parameterDict["dbName"], parameterDict["stbName"], parameterDict["ctbNum"])
+        self.insert_data(tdSql,\
+                         parameterDict["dbName"],\
+                         parameterDict["stbName"],\
+                         parameterDict["ctbNum"],\
+                         parameterDict["rowsPerTbl"],\
+                         parameterDict["batchNum"])
+
+        tdLog.info("create topics from stb1")
+        topicFromStb1 = 'topic_stb1'
+        
+        tdSql.execute("create topic %s as select ts, c1, c2 from %s.%s" %(topicFromStb1, parameterDict['dbName'], parameterDict['stbName']))
+        consumerId     = 0
+        expectrowcnt   = parameterDict["rowsPerTbl"] * parameterDict["ctbNum"]
+        topicList      = topicFromStb1
+        ifcheckdata    = 0
+        ifManualCommit = 1
+        keyList        = 'group.id:cgrp1,\
+                        enable.auto.commit:false,\
+                        auto.commit.interval.ms:6000,\
+                        auto.offset.reset:latest'
+        self.insertConsumerInfo(consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifManualCommit)
+
+        tdLog.info("start consume processor")
+        pollDelay = 5
+        showMsg   = 1
+        showRow   = 1
+        self.startTmqSimProcess(buildPath,cfgPath,pollDelay,parameterDict["dbName"],showMsg, showRow)
+
+        tdLog.info("start to check consume result")
+        expectRows = 1
+        resultList = self.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+        
+        if totalConsumeRows != 0:
+            tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, 0))
+            tdLog.exit("tmq consume rows error!")
+
+        self.initConsumerInfoTable()
+        consumerId = 1
+        self.insertConsumerInfo(consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifManualCommit)
+
+        tdLog.info("again start consume processor")
+        self.startTmqSimProcess(buildPath,cfgPath,pollDelay,parameterDict["dbName"],showMsg, showRow)
+
+        tdLog.info("again check consume result")
+        expectRows = 2
+        resultList = self.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+        
+        if totalConsumeRows != 0:
+            tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, 0))
+            tdLog.exit("tmq consume rows error!")
+
+        tdSql.query("drop topic %s"%topicFromStb1)
+
+        tdLog.printNoPrefix("======== test case 7 end ...... ")
+
+    def tmqCase8(self, cfgPath, buildPath):
+        tdLog.printNoPrefix("======== test case 8: ")       
+        
+        self.initConsumerTable()
+
+        # create and start thread
+        parameterDict = {'cfg':        '',       \
+                         'actionType': 0,        \
+                         'dbName':     'db8',    \
+                         'dropFlag':   1,        \
+                         'vgroups':    4,        \
+                         'replica':    1,        \
+                         'stbName':    'stb1',    \
+                         'ctbNum':     10,       \
+                         'rowsPerTbl': 10000,    \
+                         'batchNum':   100,      \
+                         'startTs':    1640966400000}  # 2022-01-01 00:00:00.000
+        parameterDict['cfg'] = cfgPath
+
+        self.create_database(tdSql, parameterDict["dbName"])
+        self.create_stable(tdSql, parameterDict["dbName"], parameterDict["stbName"])
+        self.create_ctables(tdSql, parameterDict["dbName"], parameterDict["stbName"], parameterDict["ctbNum"])
+        self.insert_data(tdSql,\
+                         parameterDict["dbName"],\
+                         parameterDict["stbName"],\
+                         parameterDict["ctbNum"],\
+                         parameterDict["rowsPerTbl"],\
+                         parameterDict["batchNum"])
+
+        tdLog.info("create topics from stb1")
+        topicFromStb1 = 'topic_stb1'
+        
+        tdSql.execute("create topic %s as select ts, c1, c2 from %s.%s" %(topicFromStb1, parameterDict['dbName'], parameterDict['stbName']))
+        consumerId     = 0
+        expectrowcnt   = parameterDict["rowsPerTbl"] * parameterDict["ctbNum"]
+        topicList      = topicFromStb1
+        ifcheckdata    = 0
+        ifManualCommit = 1
+        keyList        = 'group.id:cgrp1,\
+                        enable.auto.commit:false,\
+                        auto.commit.interval.ms:6000,\
+                        auto.offset.reset:latest'
+        self.insertConsumerInfo(consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifManualCommit)
+
+        tdLog.info("start consume 0 processor")
+        pollDelay = 10
+        showMsg   = 1
+        showRow   = 1
+        self.startTmqSimProcess(buildPath,cfgPath,pollDelay,parameterDict["dbName"],showMsg, showRow)
+
+        tdLog.info("start to check consume 0 result")
+        expectRows = 1
+        resultList = self.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+        
+        if totalConsumeRows != 0:
+            tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, 0))
+            tdLog.exit("tmq consume rows error!")
+
+        tdLog.info("start consume 1 processor")
+        self.startTmqSimProcess(buildPath,cfgPath,pollDelay,parameterDict["dbName"],showMsg, showRow)
+
+        tdLog.info("start one new thread to insert data")
+        parameterDict['actionType'] = actionType.INSERT_DATA
+        prepareEnvThread = threading.Thread(target=self.prepareEnv, kwargs=parameterDict)
+        prepareEnvThread.start()
+        prepareEnvThread.join()
+
+        tdLog.info("start to check consume 0 and 1 result")
+        expectRows = 2
+        resultList = self.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+        
+        if totalConsumeRows != expectrowcnt:
+            tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, expectrowcnt))
+            tdLog.exit("tmq consume rows error!")
+
+        tdLog.info("start consume 2 processor")
+        self.startTmqSimProcess(buildPath,cfgPath,pollDelay,parameterDict["dbName"],showMsg, showRow)
+
+        tdLog.info("start one new thread to insert data")
+        parameterDict['actionType'] = actionType.INSERT_DATA
+        prepareEnvThread = threading.Thread(target=self.prepareEnv, kwargs=parameterDict)
+        prepareEnvThread.start()
+        prepareEnvThread.join()
+
+        tdLog.info("start to check consume 0 and 1 and 2 result")
+        expectRows = 3
+        resultList = self.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+        
+        if totalConsumeRows != expectrowcnt*2:
+            tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, expectrowcnt*2))
+            tdLog.exit("tmq consume rows error!")
+
+        tdSql.query("drop topic %s"%topicFromStb1)
+
+        tdLog.printNoPrefix("======== test case 8 end ...... ")
+
+    def tmqCase9(self, cfgPath, buildPath):
+        tdLog.printNoPrefix("======== test case 9: ")       
+        
+        self.initConsumerTable()
+
+        # create and start thread
+        parameterDict = {'cfg':        '',       \
+                         'actionType': 0,        \
+                         'dbName':     'db9',    \
+                         'dropFlag':   1,        \
+                         'vgroups':    4,        \
+                         'replica':    1,        \
+                         'stbName':    'stb1',    \
+                         'ctbNum':     10,       \
+                         'rowsPerTbl': 10000,    \
+                         'batchNum':   100,      \
+                         'startTs':    1640966400000}  # 2022-01-01 00:00:00.000
+        parameterDict['cfg'] = cfgPath
+
+        self.create_database(tdSql, parameterDict["dbName"])
+        self.create_stable(tdSql, parameterDict["dbName"], parameterDict["stbName"])
+        self.create_ctables(tdSql, parameterDict["dbName"], parameterDict["stbName"], parameterDict["ctbNum"])
+        self.insert_data(tdSql,\
+                         parameterDict["dbName"],\
+                         parameterDict["stbName"],\
+                         parameterDict["ctbNum"],\
+                         parameterDict["rowsPerTbl"],\
+                         parameterDict["batchNum"])
+
+        tdLog.info("create topics from stb1")
+        topicFromStb1 = 'topic_stb1'
+        
+        tdSql.execute("create topic %s as select ts, c1, c2 from %s.%s" %(topicFromStb1, parameterDict['dbName'], parameterDict['stbName']))
+        consumerId     = 0
+        expectrowcnt   = parameterDict["rowsPerTbl"] * parameterDict["ctbNum"]
+        topicList      = topicFromStb1
+        ifcheckdata    = 0
+        ifManualCommit = 1
+        keyList        = 'group.id:cgrp1,\
+                        enable.auto.commit:false,\
+                        auto.commit.interval.ms:6000,\
+                        auto.offset.reset:latest'
+        self.insertConsumerInfo(consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifManualCommit)
+
+        tdLog.info("start consume 0 processor")
+        pollDelay = 10
+        showMsg   = 1
+        showRow   = 1
+        self.startTmqSimProcess(buildPath,cfgPath,pollDelay,parameterDict["dbName"],showMsg, showRow)
+
+        tdLog.info("start to check consume 0 result")
+        expectRows = 1
+        resultList = self.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+        
+        if totalConsumeRows != 0:
+            tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, 0))
+            tdLog.exit("tmq consume rows error!")
+
+        tdLog.info("start consume 1 processor")
+        self.initConsumerInfoTable()
+        consumerId     = 1
+        ifManualCommit = 0
+        self.insertConsumerInfo(consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifManualCommit)
+        self.startTmqSimProcess(buildPath,cfgPath,pollDelay,parameterDict["dbName"],showMsg, showRow)
+
+        tdLog.info("start one new thread to insert data")
+        parameterDict['actionType'] = actionType.INSERT_DATA
+        prepareEnvThread = threading.Thread(target=self.prepareEnv, kwargs=parameterDict)
+        prepareEnvThread.start()
+        prepareEnvThread.join()
+
+        tdLog.info("start to check consume 0 and 1 result")
+        expectRows = 2
+        resultList = self.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+        
+        if totalConsumeRows != expectrowcnt:
+            tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, expectrowcnt))
+            tdLog.exit("tmq consume rows error!")
+
+        tdLog.info("start consume 2 processor")
+        self.startTmqSimProcess(buildPath,cfgPath,pollDelay,parameterDict["dbName"],showMsg, showRow)
+
+        tdLog.info("start one new thread to insert data")
+        parameterDict['actionType'] = actionType.INSERT_DATA
+        prepareEnvThread = threading.Thread(target=self.prepareEnv, kwargs=parameterDict)
+        prepareEnvThread.start()
+        prepareEnvThread.join()
+
+        tdLog.info("start to check consume 0 and 1 and 2 result")
+        expectRows = 3
+        resultList = self.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+        
+        if totalConsumeRows != expectrowcnt*2:
+            tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, expectrowcnt*2))
+            tdLog.exit("tmq consume rows error!")
+
+        tdSql.query("drop topic %s"%topicFromStb1)
+
+        tdLog.printNoPrefix("======== test case 9 end ...... ")
+
+    def tmqCase10(self, cfgPath, buildPath):
+        tdLog.printNoPrefix("======== test case 10: ")       
+        
+        self.initConsumerTable()
+
+        # create and start thread
+        parameterDict = {'cfg':        '',       \
+                         'actionType': 0,        \
+                         'dbName':     'db10',    \
+                         'dropFlag':   1,        \
+                         'vgroups':    4,        \
+                         'replica':    1,        \
+                         'stbName':    'stb1',    \
+                         'ctbNum':     10,       \
+                         'rowsPerTbl': 10000,    \
+                         'batchNum':   100,      \
+                         'startTs':    1640966400000}  # 2022-01-01 00:00:00.000
+        parameterDict['cfg'] = cfgPath
+
+        self.create_database(tdSql, parameterDict["dbName"])
+        self.create_stable(tdSql, parameterDict["dbName"], parameterDict["stbName"])
+        self.create_ctables(tdSql, parameterDict["dbName"], parameterDict["stbName"], parameterDict["ctbNum"])
+        self.insert_data(tdSql,\
+                         parameterDict["dbName"],\
+                         parameterDict["stbName"],\
+                         parameterDict["ctbNum"],\
+                         parameterDict["rowsPerTbl"],\
+                         parameterDict["batchNum"])
+
+        tdLog.info("create topics from stb1")
+        topicFromStb1 = 'topic_stb1'
+        
+        tdSql.execute("create topic %s as select ts, c1, c2 from %s.%s" %(topicFromStb1, parameterDict['dbName'], parameterDict['stbName']))
+        consumerId     = 0
+        expectrowcnt   = parameterDict["rowsPerTbl"] * parameterDict["ctbNum"]
+        topicList      = topicFromStb1
+        ifcheckdata    = 0
+        ifManualCommit = 1
+        keyList        = 'group.id:cgrp1,\
+                        enable.auto.commit:false,\
+                        auto.commit.interval.ms:6000,\
+                        auto.offset.reset:latest'
+        self.insertConsumerInfo(consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifManualCommit)
+
+        tdLog.info("start consume 0 processor")
+        pollDelay = 10
+        showMsg   = 1
+        showRow   = 1
+        self.startTmqSimProcess(buildPath,cfgPath,pollDelay,parameterDict["dbName"],showMsg, showRow)
+
+        tdLog.info("start to check consume 0 result")
+        expectRows = 1
+        resultList = self.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+        
+        if totalConsumeRows != 0:
+            tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, 0))
+            tdLog.exit("tmq consume rows error!")
+
+        tdLog.info("start consume 1 processor")
+        self.initConsumerInfoTable()
+        consumerId     = 1
+        ifManualCommit = 1
+        self.insertConsumerInfo(consumerId, expectrowcnt-10000,topicList,keyList,ifcheckdata,ifManualCommit)
+        self.startTmqSimProcess(buildPath,cfgPath,pollDelay,parameterDict["dbName"],showMsg, showRow)
+
+        tdLog.info("start one new thread to insert data")
+        parameterDict['actionType'] = actionType.INSERT_DATA
+        prepareEnvThread = threading.Thread(target=self.prepareEnv, kwargs=parameterDict)
+        prepareEnvThread.start()
+        prepareEnvThread.join()
+
+        tdLog.info("start to check consume 0 and 1 result")
+        expectRows = 2
+        resultList = self.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+        
+        if totalConsumeRows != expectrowcnt-10000:
+            tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, expectrowcnt-10000))
+            tdLog.exit("tmq consume rows error!")
+
+        tdLog.info("start consume 2 processor")
+        self.initConsumerInfoTable()
+        consumerId     = 2
+        ifManualCommit = 1
+        self.insertConsumerInfo(consumerId, expectrowcnt+10000,topicList,keyList,ifcheckdata,ifManualCommit)
+        self.startTmqSimProcess(buildPath,cfgPath,pollDelay,parameterDict["dbName"],showMsg, showRow)
+
+        tdLog.info("start one new thread to insert data")
+        parameterDict['actionType'] = actionType.INSERT_DATA
+        prepareEnvThread = threading.Thread(target=self.prepareEnv, kwargs=parameterDict)
+        prepareEnvThread.start()
+        prepareEnvThread.join()
+
+        tdLog.info("start to check consume 0 and 1 and 2 result")
+        expectRows = 3
+        resultList = self.selectConsumeResult(expectRows)
+        totalConsumeRows = 0
+        for i in range(expectRows):
+            totalConsumeRows += resultList[i]
+        
+        if totalConsumeRows != expectrowcnt*2:
+            tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, expectrowcnt*2))
+            tdLog.exit("tmq consume rows error!")
+
+        tdSql.query("drop topic %s"%topicFromStb1)
+
+        tdLog.printNoPrefix("======== test case 10 end ...... ")
+
+    def run(self):
+        tdSql.prepare()
+
+        buildPath = self.getBuildPath()
+        if (buildPath == ""):
+            tdLog.exit("taosd not found!")
+        else:
+            tdLog.info("taosd found in %s" % buildPath)
+        cfgPath = buildPath + "/../sim/psim/cfg"
+        tdLog.info("cfgPath: %s" % cfgPath)
+
+        self.tmqCase1(cfgPath, buildPath)
+        self.tmqCase2(cfgPath, buildPath) 
+        #self.tmqCase3(cfgPath, buildPath)
+        self.tmqCase4(cfgPath, buildPath)
+        self.tmqCase5(cfgPath, buildPath)
+        self.tmqCase6(cfgPath, buildPath)
+        self.tmqCase7(cfgPath, buildPath)
+        self.tmqCase8(cfgPath, buildPath)
+        self.tmqCase9(cfgPath, buildPath)
+        self.tmqCase10(cfgPath, buildPath)
+
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success(f"{__file__} successfully executed")
+
+event = threading.Event()
+
+tdCases.addLinux(__file__, TDTestCase())
+tdCases.addWindows(__file__, TDTestCase())

tests/system-test/fulltest.sh

@@ -9,7 +9,8 @@ python3 ./test.py -f 0-others/telemetry.py
 python3 ./test.py -f 0-others/taosdMonitor.py
 python3 ./test.py -f 0-others/udfTest.py
 
-python3 ./test.py -f 0-others/user_control.py
+# TODO privilege has error
+# python3 ./test.py -f 0-others/user_control.py
 
 #python3 ./test.py -f 2-query/between.py
 python3 ./test.py -f 2-query/distinct.py
@@ -63,3 +64,4 @@ python3 ./test.py -f 2-query/nestedQuery.py
 python3 ./test.py -f 7-tmq/basic5.py
 python3 ./test.py -f 7-tmq/subscribeDb.py
 python3 ./test.py -f 7-tmq/subscribeDb1.py
+python3 ./test.py -f 7-tmq/subscribeStb.py

tests/test/c/tmqSim.c

@@ -98,16 +98,28 @@ static void printHelp() {
   exit(EXIT_SUCCESS);
 }
 
+char* getCurrentTimeString(char* timeString) {
+  time_t	tTime = taosGetTimestampSec();
+  struct tm tm = *taosLocalTime(&tTime, NULL);
+  sprintf(timeString, "%d-%02d-%02d %02d:%02d:%02d", 
+  	                  tm.tm_year + 1900, 
+  	                  tm.tm_mon + 1,
+					  tm.tm_mday, 
+					  tm.tm_hour, 
+					  tm.tm_min, 
+					  tm.tm_sec);
+
+  return timeString;
+}
+
+
 void initLogFile() {
-  time_t    now;
-  struct tm curTime;
   char filename[256];
+  char tmpString[128];  
+
+  sprintf(filename,"%s/../log/tmqlog_%s.txt", configDir, getCurrentTimeString(tmpString));  
+  //sprintf(filename, "%s/../log/tmqlog.txt", configDir);
   
-  now = taosTime(NULL);
-  taosLocalTime(&now, &curTime);
-  sprintf(filename, "%s/../log/tmqlog_%04d-%02d-%02d %02d-%02d-%02d.txt", configDir, curTime.tm_year + 1900,
-          curTime.tm_mon + 1, curTime.tm_mday, curTime.tm_hour, curTime.tm_min, curTime.tm_sec);
-  // sprintf(filename, "%s/../log/tmqlog.txt", configDir);
   TdFilePtr pFile = taosOpenFile(filename, TD_FILE_TEXT | TD_FILE_WRITE | TD_FILE_TRUNC | TD_FILE_STREAM);
   if (NULL == pFile) {
     fprintf(stderr, "Failed to open %s for save result\n", filename);
@@ -117,9 +129,6 @@ void initLogFile() {
 }
 
 void saveConfigToLogFile() {
-  time_t    tTime = taosGetTimestampSec();
-  struct tm tm = *taosLocalTime(&tTime, NULL);
-
   taosFprintfFile(g_fp, "###################################################################\n");
   taosFprintfFile(g_fp, "# configDir:           %s\n", configDir);
   taosFprintfFile(g_fp, "# dbName:              %s\n", g_stConfInfo.dbName);
@@ -144,10 +153,11 @@ void saveConfigToLogFile() {
       taosFprintfFile(g_fp, "%s:%s, ", g_stConfInfo.stThreads[i].key[k], g_stConfInfo.stThreads[i].value[k]);
     }
     taosFprintfFile(g_fp, "\n");
+    taosFprintfFile(g_fp, "  expect rows: %d\n", g_stConfInfo.stThreads[i].expectMsgCnt);
   }
 
-  taosFprintfFile(g_fp, "# Test time:                %d-%02d-%02d %02d:%02d:%02d\n", tm.tm_year + 1900, tm.tm_mon + 1,
-                  tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
+  char tmpString[128];
+  taosFprintfFile(g_fp, "# Test time:                %s\n", getCurrentTimeString(tmpString));
   taosFprintfFile(g_fp, "###################################################################\n");
 }
 
@@ -316,10 +326,8 @@ int32_t saveConsumeResult(SThreadInfo* pInfo) {
   sprintf(sqlStr, "insert into %s.consumeresult values (now, %d, %" PRId64 ", %" PRId64 ", %d)", g_stConfInfo.cdbName,
           pInfo->consumerId, pInfo->consumeMsgCnt, pInfo->consumeRowCnt, pInfo->checkresult);
 
-  time_t    tTime = taosGetTimestampSec();
-  struct tm tm = *taosLocalTime(&tTime, NULL);
-  taosFprintfFile(g_fp, "# save result:	%d-%02d-%02d %02d:%02d:%02d, sql: %s\n", tm.tm_year + 1900, tm.tm_mon + 1,
-                  tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, sqlStr);
+  char tmpString[128];
+  taosFprintfFile(g_fp, "%s, consume id %d result: %s\n", getCurrentTimeString(tmpString), pInfo->consumerId ,sqlStr);
 
   TAOS_RES* pRes = taos_query(pConn, sqlStr);
   if (taos_errno(pRes) != 0) {
@@ -339,6 +347,9 @@ void loop_consume(SThreadInfo* pInfo) {
   int64_t totalMsgs = 0;
   int64_t totalRows = 0;
 
+  char tmpString[128];
+  taosFprintfFile(g_fp, "%s consumer id %d start to loop pull msg\n", getCurrentTimeString(tmpString), pInfo->consumerId);
+
   while (running) {
     TAOS_RES* tmqMsg = tmq_consumer_poll(pInfo->tmq, g_stConfInfo.consumeDelay * 1000);
     if (tmqMsg) {
@@ -351,11 +362,13 @@ void loop_consume(SThreadInfo* pInfo) {
       totalMsgs++;
 
       if (totalRows >= pInfo->expectMsgCnt) {
-        taosFprintfFile(g_fp, "==== totalRows >= pInfo->expectMsgCnt, so break\n");
+	  	char tmpString[128];
+        taosFprintfFile(g_fp, "%s over than expect rows, so break consume\n", getCurrentTimeString(tmpString));
         break;
       }
     } else {
-      taosFprintfFile(g_fp, "==== delay over time, so break\n");
+      char tmpString[128];
+      taosFprintfFile(g_fp, "%s no poll more msg when time over, break consume\n", getCurrentTimeString(tmpString));
       break;
     }
   }

tools/shell/src/shellNettest.c

@@ -31,9 +31,6 @@ static void shellWorkAsClient() {
   rpcInit.connType = TAOS_CONN_CLIENT;
   rpcInit.idleTime = tsShellActivityTimer * 1000;
   rpcInit.user = "_dnd";
-  rpcInit.ckey = "_key";
-  rpcInit.spi = 1;
-  rpcInit.secret = pass;
 
   clientRpc = rpcOpen(&rpcInit);
   if (clientRpc == NULL) {