Merge branch '3.0' into test/jcy

Jenkinsfile2

@@ -33,7 +33,7 @@ def abort_previous(){
     milestone(buildNumber)
 }
 def pre_test(){
-    sh'hostname'
+    sh 'hostname'
     sh '''
         date
         sudo rmtaos || echo "taosd has not installed"
@@ -50,35 +50,32 @@ def pre_test(){
                 cd ${WKC}
                 git checkout master
             '''
-        }
+        } else if(env.CHANGE_TARGET == '2.0') {
-      else if(env.CHANGE_TARGET == '2.0'){
             sh '''
                 cd ${WKC}
                 git checkout 2.0
             '''
-      }
+        } else if(env.CHANGE_TARGET == '3.0') {
-      else if(env.CHANGE_TARGET == '3.0'){
             sh '''
                 cd ${WKC}
                 git checkout 3.0
                 [ -d contrib/bdb ] && cd contrib/bdb && git clean -fxd && cd ../..
             '''
-      }
+        } else {
-      else{
             sh '''
                 cd ${WKC}
                 git checkout develop
             '''
         }
     }
-    sh'''
+    sh '''
         cd ${WKC}
         git pull >/dev/null
         git fetch origin +refs/pull/${CHANGE_ID}/merge
         git checkout -qf FETCH_HEAD
         git submodule update --init --recursive
     '''
-    sh'''
+    sh '''
         cd ${WKC}
         export TZ=Asia/Harbin
         date
@@ -88,7 +85,7 @@ def pre_test(){
         cmake .. > /dev/null
         make -j4> /dev/null
     '''
-    sh'''
+    sh '''
         cd ${WKPY}
         git reset --hard
         git pull
@@ -96,6 +93,69 @@ def pre_test(){
     '''
     return 1
 }
+def pre_test_win(){
+    bat '''
+        hostname
+        date /t
+        time /t
+        taskkill /f /t /im python.exe
+        taskkill /f /t /im bash.exe
+        cd C:\\workspace\\%EXECUTOR_NUMBER%\\TDengine
+        rd /s /Q C:\\workspace\\%EXECUTOR_NUMBER%\\TDengine\\debug
+        exit 0
+    '''
+    bat '''
+        cd C:\\workspace\\%EXECUTOR_NUMBER%\\TDengine
+        git reset --hard
+        git fetch || git fetch
+        git checkout -f
+    '''
+    script {
+        if (env.CHANGE_TARGET == 'master') {
+            bat '''
+                cd C:\\workspace\\%EXECUTOR_NUMBER%\\TDengine
+                git checkout master
+            '''
+        } else if(env.CHANGE_TARGET == '2.0') {
+            bat '''
+                cd C:\\workspace\\%EXECUTOR_NUMBER%\\TDengine
+                git checkout 2.0
+            '''
+        } else if(env.CHANGE_TARGET == '3.0') {
+            bat '''
+                cd C:\\workspace\\%EXECUTOR_NUMBER%\\TDengine
+                git checkout 3.0
+            '''
+        } else {
+            bat '''
+                cd C:\\workspace\\%EXECUTOR_NUMBER%\\TDengine
+                git checkout develop
+            '''
+        }
+    }
+    bat '''
+        cd C:\\workspace\\%EXECUTOR_NUMBER%\\TDengine
+        git branch
+        git pull || git pull
+        git fetch origin +refs/pull/%CHANGE_ID%/merge
+        git checkout -qf FETCH_HEAD
+    '''
+}
+def pre_test_build_win() {
+    bat '''
+        echo "building ..."
+        time /t
+        cd C:\\workspace\\%EXECUTOR_NUMBER%\\TDengine
+        mkdir debug
+        cd debug
+        call "C:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\Community\\VC\\Auxiliary\\Build\\vcvarsall.bat" x64
+        set CL=/MP8
+        cmake .. -G "NMake Makefiles JOM"
+        jom -j 4 || exit 8
+        time /t
+    '''
+    return 1
+}
 
 pipeline {
     agent none
@@ -106,29 +166,34 @@ pipeline {
         WKPY= '/var/lib/jenkins/workspace/taos-connector-python'
     }
     stages {
-      stage('pre_build'){
+        stage('run test') {
+            parallel {
+                stage('windows test') {
+                    agent {label " windows11 "}
+                    steps {
+                        pre_test_win()
+                        pre_test_build_win()
+                    }
+                }
+                stage('linux test') {
                     agent{label " slave3_0 || slave15 || slave16 || slave17 "}
                     options { skipDefaultCheckout() } 
                     when {
                         changeRequest()
                     }
                     steps {
-            script{
-              abort_previous()
-              abortPreviousBuilds()
-            }
                         timeout(time: 45, unit: 'MINUTES'){
                             pre_test()
-              sh'''
+                            sh '''
                                 cd ${WKC}/debug
                                 ctest -VV
                             '''
-              sh'''
+                            sh '''
                                 export LD_LIBRARY_PATH=${WKC}/debug/build/lib
                                 cd ${WKC}/tests/system-test
                                 ./fulltest.sh
                             '''
-              sh'''
+                            sh '''
                                 cd ${WKC}/tests
                                 ./test-all.sh b1fq
                             '''
@@ -136,6 +201,8 @@ pipeline {
                     }
                 }
             }
+        }
+    }
     post {  
         success {
             emailext (

include/common/tmsg.h

@@ -73,7 +73,8 @@ typedef uint16_t tmsg_t;
 enum { CONN_TYPE__QUERY = 1, CONN_TYPE__TMQ, CONN_TYPE__MAX };
 
 enum {
-  HEARTBEAT_KEY_DBINFO = 1,
+  HEARTBEAT_KEY_USER_AUTHINFO = 1,
+  HEARTBEAT_KEY_DBINFO,
   HEARTBEAT_KEY_STBINFO,
   HEARTBEAT_KEY_MQ_TMP,
 };
@@ -426,7 +427,9 @@ int32_t tDeserializeSGetUserAuthReq(void* buf, int32_t bufLen, SGetUserAuthReq*
 
 typedef struct {
   char      user[TSDB_USER_LEN];
+  int32_t   version;
   int8_t    superAuth;
+  SHashObj* createdDbs;
   SHashObj* readDbs;
   SHashObj* writeDbs;
 } SGetUserAuthRsp;
@@ -669,10 +672,20 @@ typedef struct {
   SArray* pArray;  // Array of SUseDbRsp
 } SUseDbBatchRsp;
 
+
 int32_t tSerializeSUseDbBatchRsp(void* buf, int32_t bufLen, SUseDbBatchRsp* pRsp);
 int32_t tDeserializeSUseDbBatchRsp(void* buf, int32_t bufLen, SUseDbBatchRsp* pRsp);
 void    tFreeSUseDbBatchRsp(SUseDbBatchRsp* pRsp);
 
+typedef struct {
+  SArray* pArray;  // Array of SGetUserAuthRsp
+} SUserAuthBatchRsp;
+
+int32_t tSerializeSUserAuthBatchRsp(void* buf, int32_t bufLen, SUserAuthBatchRsp* pRsp);
+int32_t tDeserializeSUserAuthBatchRsp(void* buf, int32_t bufLen, SUserAuthBatchRsp* pRsp);
+void    tFreeSUserAuthBatchRsp(SUserAuthBatchRsp* pRsp);
+
+
 typedef struct {
   char db[TSDB_DB_FNAME_LEN];
 } SCompactDbReq;
@@ -2578,6 +2591,28 @@ static FORCE_INLINE void tDeleteSMqAskEpRsp(SMqAskEpRsp* pRsp) {
   taosArrayDestroyEx(pRsp->topics, (void (*)(void*))tDeleteSMqSubTopicEp);
 }
 
+#define TD_AUTO_CREATE_TABLE 0x1
+typedef struct {
+  int64_t       suid;
+  int64_t       uid;
+  int32_t       sver;
+  uint64_t      nData;
+  const void*   pData;
+  SVCreateTbReq cTbReq;
+} SVSubmitBlk;
+
+typedef struct {
+  int32_t flags;
+  int32_t nBlocks;
+  union {
+    SArray*      pArray;
+    SVSubmitBlk* pBlocks;
+  };
+} SVSubmitReq;
+
+int32_t tEncodeSVSubmitReq(SCoder* pCoder, const SVSubmitReq* pReq);
+int32_t tDecodeSVSubmitReq(SCoder* pCoder, SVSubmitReq* pReq);
+
 #pragma pack(pop)
 
 #ifdef __cplusplus

include/common/trow.h

@@ -141,7 +141,7 @@ typedef struct {
   /// row total length
   uint32_t len;
   /// row version
-  uint64_t ver;
+  // uint64_t ver;
   /// the inline data, maybe a tuple or a k-v tuple
   char data[];
 } STSRow;
@@ -176,7 +176,7 @@ typedef struct {
 #define TD_ROW_DATA(r)     ((r)->data)
 #define TD_ROW_LEN(r)      ((r)->len)
 #define TD_ROW_KEY(r)      ((r)->ts)
-#define TD_ROW_VER(r)      ((r)->ver)
+// #define TD_ROW_VER(r)      ((r)->ver)
 #define TD_ROW_KEY_ADDR(r) (r)
 
 // N.B. If without STSchema, getExtendedRowSize() is used to get the rowMaxBytes and

include/libs/catalog/catalog.h

@@ -40,6 +40,11 @@ enum {
   CTG_DBG_STB_RENT_NUM,
 };
 
+typedef enum {
+  AUTH_TYPE_READ = 1,
+  AUTH_TYPE_WRITE,
+  AUTH_TYPE_OTHER,
+} AUTH_TYPE;
 
 typedef struct SCatalogReq {
   SArray *pTableName;     // element is SNAME
@@ -57,6 +62,7 @@ typedef struct SMetaData {
 typedef struct SCatalogCfg {
   uint32_t maxTblCacheNum;
   uint32_t maxDBCacheNum;
+  uint32_t maxUserCacheNum;
   uint32_t dbRentSec;
   uint32_t stbRentSec;
 } SCatalogCfg;
@@ -77,6 +83,11 @@ typedef struct SDbVgVersion {
   int32_t numOfTable; // unit is TSDB_TABLE_NUM_UNIT
 } SDbVgVersion;
 
+typedef struct SUserAuthVersion {
+  char    user[TSDB_USER_LEN];
+  int32_t version;
+} SUserAuthVersion;
+
 typedef SDbCfgRsp SDbCfgInfo;
 typedef SUserIndexRsp SIndexInfo;
 
@@ -219,12 +230,18 @@ int32_t catalogGetExpiredSTables(SCatalog* pCatalog, SSTableMetaVersion **stable
 
 int32_t catalogGetExpiredDBs(SCatalog* pCatalog, SDbVgVersion **dbs, uint32_t *num);
 
+int32_t catalogGetExpiredUsers(SCatalog* pCtg, SUserAuthVersion **users, uint32_t *num);
+
 int32_t catalogGetDBCfg(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const char* dbFName, SDbCfgInfo* pDbCfg);
 
 int32_t catalogGetIndexInfo(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const char* indexName, SIndexInfo* pInfo);
 
 int32_t catalogGetUdfInfo(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const char* funcName, SFuncInfo** pInfo);
 
+int32_t catalogChkAuth(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const char* user, const char* dbFName, AUTH_TYPE type, bool *pass);
+
+int32_t catalogUpdateUserAuthInfo(SCatalog* pCtg, SGetUserAuthRsp* pAuth);
+
 
 /**
  * Destroy catalog and relase all resources

include/libs/function/tudf.h

@@ -29,7 +29,11 @@ extern "C" {
 #endif
 
 #define UDF_LISTEN_PIPE_NAME_LEN 32
-#define UDF_LISTEN_PIPE_NAME_PREFIX "udfd.sock."
+#ifdef _WIN32
+#define UDF_LISTEN_PIPE_NAME_PREFIX "\\\\?\\pipe\\udfd.sock"
+#else
+#define UDF_LISTEN_PIPE_NAME_PREFIX ".udfd.sock."
+#endif
 #define UDF_DNODE_ID_ENV_NAME "DNODE_ID"
 
 //======================================================================================
@@ -129,8 +133,8 @@ int32_t udfAggFinalize(struct SqlFunctionCtx *pCtx, SSDataBlock* pBlock);
 // begin API to UDF writer.
 
 // dynamic lib init and destroy
-typedef int32_t (*TUdfSetupFunc)();
+typedef int32_t (*TUdfInitFunc)();
-typedef int32_t (*TUdfTeardownFunc)();
+typedef int32_t (*TUdfDestroyFunc)();
 
 //TODO: add API to check function arguments type, number etc.
 
@@ -242,7 +246,6 @@ static FORCE_INLINE int32_t udfColSetRow(SUdfColumn* pColumn, uint32_t currentRo
   return 0;
 }
 
-typedef int32_t (*TUdfFreeUdfColumnFunc)(SUdfColumn* column);
 typedef int32_t (*TUdfScalarProcFunc)(SUdfDataBlock* block, SUdfColumn *resultCol);
 
 typedef int32_t (*TUdfAggStartFunc)(SUdfInterBuf *buf);

include/libs/scalar/scalar.h

@@ -91,6 +91,8 @@ int32_t winDurFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOu
 int32_t qStartTsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 int32_t qEndTsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 
+int32_t qTbnameFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+
 #ifdef __cplusplus
 }
 #endif

include/libs/transport/trpc.h

@@ -68,6 +68,7 @@ typedef int (*RpcAfp)(void *parent, char *tableId, char *spi, char *encrypt, cha
 typedef bool (*RpcRfp)(int32_t code);
 
 typedef struct SRpcInit {
+  char     localFqdn[TSDB_FQDN_LEN];
   uint16_t localPort;     // local port
   char *   label;         // for debug purpose
   int      numOfThreads;  // number of threads to handle connections

include/os/osSocket.h

@@ -161,6 +161,7 @@ int taosCreateSocketWithTimeOutOpt(uint32_t conn_timeout_sec);
 
 TdSocketPtr       taosOpenUdpSocket(uint32_t localIp, uint16_t localPort);
 TdSocketPtr       taosOpenTcpClientSocket(uint32_t ip, uint16_t port, uint32_t localIp);
+bool              taosValidIpAndPort(uint32_t ip, uint16_t port);
 TdSocketServerPtr taosOpenTcpServerSocket(uint32_t ip, uint16_t port);
 int32_t           taosKeepTcpAlive(TdSocketPtr pSocket);
 TdSocketPtr       taosAcceptTcpConnectSocket(TdSocketServerPtr pServerSocket, struct sockaddr *destAddr, int *addrLen);

include/util/taoserror.h

@@ -621,6 +621,14 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_INVALID_TOPIC_QUERY       TAOS_DEF_ERROR_CODE(0, 0x2639)
 #define TSDB_CODE_PAR_INVALID_DROP_STABLE       TAOS_DEF_ERROR_CODE(0, 0x263A)
 #define TSDB_CODE_PAR_INVALID_FILL_TIME_RANGE   TAOS_DEF_ERROR_CODE(0, 0x263B)
+#define TSDB_CODE_PAR_DUPLICATED_COLUMN         TAOS_DEF_ERROR_CODE(0, 0x263C)
+#define TSDB_CODE_PAR_INVALID_TAGS_LENGTH       TAOS_DEF_ERROR_CODE(0, 0x263D)
+#define TSDB_CODE_PAR_INVALID_ROW_LENGTH        TAOS_DEF_ERROR_CODE(0, 0x263E)
+#define TSDB_CODE_PAR_INVALID_COLUMNS_NUM       TAOS_DEF_ERROR_CODE(0, 0x263F)
+#define TSDB_CODE_PAR_TOO_MANY_COLUMNS          TAOS_DEF_ERROR_CODE(0, 0x2640)
+#define TSDB_CODE_PAR_INVALID_FIRST_COLUMN      TAOS_DEF_ERROR_CODE(0, 0x2641)
+#define TSDB_CODE_PAR_INVALID_VAR_COLUMN_LEN    TAOS_DEF_ERROR_CODE(0, 0x2642)
+#define TSDB_CODE_PAR_INVALID_TAGS_NUM          TAOS_DEF_ERROR_CODE(0, 0x2643)
 
 //planner
 #define TSDB_CODE_PLAN_INTERNAL_ERROR           TAOS_DEF_ERROR_CODE(0, 0x2700)

source/client/src/clientHb.c

@@ -28,6 +28,27 @@ static int32_t hbMqHbReqHandle(SClientHbKey *connKey, void *param, SClientHbReq
 
 static int32_t hbMqHbRspHandle(SAppHbMgr *pAppHbMgr, SClientHbRsp *pRsp) { return 0; }
 
+static int32_t hbProcessUserAuthInfoRsp(void *value, int32_t valueLen, struct SCatalog *pCatalog) {
+  int32_t code = 0;
+
+  SUserAuthBatchRsp batchRsp = {0};
+  if (tDeserializeSUserAuthBatchRsp(value, valueLen, &batchRsp) != 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    return -1;
+  }
+
+  int32_t numOfBatchs = taosArrayGetSize(batchRsp.pArray);
+  for (int32_t i = 0; i < numOfBatchs; ++i) {
+    SGetUserAuthRsp *rsp = taosArrayGet(batchRsp.pArray, i);
+    tscDebug("hb user auth rsp, user:%s, version:%d", rsp->user, rsp->version);
+
+    catalogUpdateUserAuthInfo(pCatalog, rsp);
+  }
+
+  tFreeSUserAuthBatchRsp(&batchRsp);
+  return TSDB_CODE_SUCCESS;
+}
+
 static int32_t hbProcessDBInfoRsp(void *value, int32_t valueLen, struct SCatalog *pCatalog) {
   int32_t code = 0;
 
@@ -148,6 +169,24 @@ static int32_t hbQueryHbRspHandle(SAppHbMgr *pAppHbMgr, SClientHbRsp *pRsp) {
   for (int32_t i = 0; i < kvNum; ++i) {
     SKv *kv = taosArrayGet(pRsp->info, i);
     switch (kv->key) {
+      case HEARTBEAT_KEY_USER_AUTHINFO: {
+        if (kv->valueLen <= 0 || NULL == kv->value) {
+          tscError("invalid hb user auth info, len:%d, value:%p", kv->valueLen, kv->value);
+          break;
+        }
+
+        int64_t         *clusterId = (int64_t *)info->param;
+        struct SCatalog *pCatalog = NULL;
+
+        int32_t code = catalogGetHandle(*clusterId, &pCatalog);
+        if (code != TSDB_CODE_SUCCESS) {
+          tscWarn("catalogGetHandle failed, clusterId:%" PRIx64 ", error:%s", *clusterId, tstrerror(code));
+          break;
+        }
+
+        hbProcessUserAuthInfoRsp(kv->value, kv->valueLen, pCatalog);
+        break;
+      }
       case HEARTBEAT_KEY_DBINFO: {
         if (kv->valueLen <= 0 || NULL == kv->value) {
           tscError("invalid hb db info, len:%d, value:%p", kv->valueLen, kv->value);
@@ -327,6 +366,39 @@ int32_t hbGetQueryBasicInfo(SClientHbKey *connKey, SClientHbReq *req) {
   return TSDB_CODE_SUCCESS;
 }
 
+int32_t hbGetExpiredUserInfo(SClientHbKey *connKey, struct SCatalog *pCatalog, SClientHbReq *req) {
+  SUserAuthVersion *users = NULL;
+  uint32_t          userNum = 0;
+  int32_t           code = 0;
+
+  code = catalogGetExpiredUsers(pCatalog, &users, &userNum);
+  if (TSDB_CODE_SUCCESS != code) {
+    return code;
+  }
+
+  if (userNum <= 0) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  for (int32_t i = 0; i < userNum; ++i) {
+    SUserAuthVersion *user = &users[i];
+    user->version = htonl(user->version);
+  }
+
+  SKv kv = {
+      .key = HEARTBEAT_KEY_USER_AUTHINFO,
+      .valueLen = sizeof(SUserAuthVersion) * userNum,
+      .value = users,
+  };
+
+  tscDebug("hb got %d expired users, valueLen:%d", userNum, kv.valueLen);
+
+  taosHashPut(req->info, &kv.key, sizeof(kv.key), &kv, sizeof(kv));
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
 int32_t hbGetExpiredDBInfo(SClientHbKey *connKey, struct SCatalog *pCatalog, SClientHbReq *req) {
   SDbVgVersion *dbs = NULL;
   uint32_t      dbNum = 0;
@@ -407,6 +479,11 @@ int32_t hbQueryHbReqHandle(SClientHbKey *connKey, void *param, SClientHbReq *req
 
   hbGetQueryBasicInfo(connKey, req);
 
+  code = hbGetExpiredUserInfo(connKey, pCatalog, req);
+  if (TSDB_CODE_SUCCESS != code) {
+    return code;
+  }
+
   code = hbGetExpiredDBInfo(connKey, pCatalog, req);
   if (TSDB_CODE_SUCCESS != code) {
     return code;

source/client/test/clientTests.cpp

@@ -587,15 +587,34 @@ TEST(testCase, projection_query_tables) {
   }
   taos_free_result(pRes);
 
+  pRes = taos_query(pConn, "create stable st2 (ts timestamp, k int) tags(a int)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create table tu, reason:%s\n", taos_errstr(pRes));
+  }
+  taos_free_result(pRes);
+
   pRes = taos_query(pConn, "create table tu using st1 tags(1)");
   if (taos_errno(pRes) != 0) {
     printf("failed to create table tu, reason:%s\n", taos_errstr(pRes));
   }
   taos_free_result(pRes);
 
-  for(int32_t i = 0; i < 10000; ++i) {
+  pRes = taos_query(pConn, "create table tu2 using st2 tags(1)");
-    char sql[512] = {0};
+  if (taos_errno(pRes) != 0) {
-    sprintf(sql, "insert into tu values(now+%da, %d)", i, i);
+    printf("failed to create table tu, reason:%s\n", taos_errstr(pRes));
+  }
+  taos_free_result(pRes);
+
+  for(int32_t i = 0; i < 10000000; i += 20) {
+    char sql[1024] = {0};
+    sprintf(sql,
+            "insert into tu values(now+%da, %d)(now+%da, %d)(now+%da, %d)(now+%da, %d)"
+            "(now+%da, %d)(now+%da, %d)(now+%da, %d)(now+%da, %d)(now+%da, %d)(now+%da, %d)"
+            "(now+%da, %d)(now+%da, %d)(now+%da, %d)(now+%da, %d)"
+            "(now+%da, %d)(now+%da, %d)(now+%da, %d)(now+%da, %d)(now+%da, %d)(now+%da, %d)",
+            i, i, i + 1, i + 1, i + 2, i + 2, i + 3, i + 3, i + 4, i + 4, i + 5, i + 5, i + 6, i + 6, i + 7, i + 7,
+            i + 8, i + 8, i + 9, i + 9, i + 10, i + 10, i + 11, i + 11, i + 12, i + 12, i + 13, i + 13, i + 14, i + 14,
+            i + 15, i + 15, i + 16, i + 16, i + 17, i + 17, i + 18, i + 18, i + 19, i + 19);
     TAOS_RES* p = taos_query(pConn, sql);
     if (taos_errno(p) != 0) {
       printf("failed to insert data, reason:%s\n", taos_errstr(p));
@@ -604,24 +623,44 @@ TEST(testCase, projection_query_tables) {
     taos_free_result(p);
   }
 
-  pRes = taos_query(pConn, "select * from tu");
+  printf("start to insert next table\n");
-  if (taos_errno(pRes) != 0) {
+
-    printf("failed to select from table, reason:%s\n", taos_errstr(pRes));
+  for(int32_t i = 0; i < 10000000; i += 20) {
-    taos_free_result(pRes);
+    char sql[1024] = {0};
-    ASSERT_TRUE(false);
+    sprintf(sql,
+            "insert into tu2 values(now+%da, %d)(now+%da, %d)(now+%da, %d)(now+%da, %d)"
+            "(now+%da, %d)(now+%da, %d)(now+%da, %d)(now+%da, %d)(now+%da, %d)(now+%da, %d)"
+            "(now+%da, %d)(now+%da, %d)(now+%da, %d)(now+%da, %d)"
+            "(now+%da, %d)(now+%da, %d)(now+%da, %d)(now+%da, %d)(now+%da, %d)(now+%da, %d)",
+            i, i, i + 1, i + 1, i + 2, i + 2, i + 3, i + 3, i + 4, i + 4, i + 5, i + 5, i + 6, i + 6, i + 7, i + 7,
+            i + 8, i + 8, i + 9, i + 9, i + 10, i + 10, i + 11, i + 11, i + 12, i + 12, i + 13, i + 13, i + 14, i + 14,
+            i + 15, i + 15, i + 16, i + 16, i + 17, i + 17, i + 18, i + 18, i + 19, i + 19);
+    TAOS_RES* p = taos_query(pConn, sql);
+    if (taos_errno(p) != 0) {
+      printf("failed to insert data, reason:%s\n", taos_errstr(p));
     }
 
-  TAOS_ROW    pRow = NULL;
+    taos_free_result(p);
-  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
-  int32_t     numOfFields = taos_num_fields(pRes);
-
-  char str[512] = {0};
-  while ((pRow = taos_fetch_row(pRes)) != NULL) {
-    int32_t code = taos_print_row(str, pRow, pFields, numOfFields);
-    printf("%s\n", str);
   }
 
-  taos_free_result(pRes);
+//  pRes = taos_query(pConn, "select * from tu");
+//  if (taos_errno(pRes) != 0) {
+//    printf("failed to select from table, reason:%s\n", taos_errstr(pRes));
+//    taos_free_result(pRes);
+//    ASSERT_TRUE(false);
+//  }
+
+//  TAOS_ROW    pRow = NULL;
+//  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
+//  int32_t     numOfFields = taos_num_fields(pRes);
+//
+//  char str[512] = {0};
+//  while ((pRow = taos_fetch_row(pRes)) != NULL) {
+//    int32_t code = taos_print_row(str, pRow, pFields, numOfFields);
+//    printf("%s\n", str);
+//  }
+
+//  taos_free_result(pRes);
   taos_close(pConn);
 }
 
@@ -659,7 +698,7 @@ TEST(testCase, agg_query_tables) {
   TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
   ASSERT_NE(pConn, nullptr);
 
-  TAOS_RES* pRes = taos_query(pConn, "use db");
+  TAOS_RES* pRes = taos_query(pConn, "use abc1");
   if (taos_errno(pRes) != 0) {
     printf("failed to use db, reason:%s\n", taos_errstr(pRes));
     taos_free_result(pRes);

source/common/src/tdatablock.c

@@ -363,9 +363,9 @@ int32_t blockDataMerge(SSDataBlock* pDest, const SSDataBlock* pSrc, SArray* pInd
 
   for (int32_t i = 0; i < pDest->info.numOfCols; ++i) {
     int32_t mapIndex = i;
-    if (pIndexMap) {
+//    if (pIndexMap) {
-      mapIndex = *(int32_t*)taosArrayGet(pIndexMap, i);
+//      mapIndex = *(int32_t*)taosArrayGet(pIndexMap, i);
-    }
+//    }
 
     SColumnInfoData* pCol2 = taosArrayGet(pDest->pDataBlock, i);
     SColumnInfoData* pCol1 = taosArrayGet(pSrc->pDataBlock, mapIndex);
@@ -493,12 +493,12 @@ SSDataBlock* blockDataExtractBlock(SSDataBlock* pBlock, int32_t startIndex, int3
     for (int32_t j = startIndex; j < (startIndex + rowCount); ++j) {
       bool isNull = false;
       if (pBlock->pBlockAgg == NULL) {
-        isNull = colDataIsNull(pColData, pBlock->info.rows, j, NULL);
+        isNull = colDataIsNull_s(pColData, pBlock->info.rows);
       } else {
         isNull = colDataIsNull(pColData, pBlock->info.rows, j, pBlock->pBlockAgg[i]);
       }
-      char* p = colDataGetData(pColData, j);
 
+      char* p = colDataGetData(pColData, j);
       colDataAppend(pDstCol, j - startIndex, p, isNull);
     }
   }

source/common/src/tmsg.c

@@ -1164,31 +1164,47 @@ int32_t tDeserializeSGetUserAuthReq(void *buf, int32_t bufLen, SGetUserAuthReq *
   return 0;
 }
 
-int32_t tSerializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pRsp) {
+int32_t tSerializeSGetUserAuthRspImpl(SCoder *pEncoder, SGetUserAuthRsp *pRsp) {
-  SCoder encoder = {0};
+  if (tEncodeCStr(pEncoder, pRsp->user) < 0) return -1;
-  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+  if (tEncodeI8(pEncoder, pRsp->superAuth) < 0) return -1;
-
+  if (tEncodeI32(pEncoder, pRsp->version) < 0) return -1;
-  if (tStartEncode(&encoder) < 0) return -1;
-  if (tEncodeCStr(&encoder, pRsp->user) < 0) return -1;
-  if (tEncodeI8(&encoder, pRsp->superAuth) < 0) return -1;
 
+  int32_t numOfCreatedDbs = taosHashGetSize(pRsp->createdDbs);
   int32_t numOfReadDbs = taosHashGetSize(pRsp->readDbs);
   int32_t numOfWriteDbs = taosHashGetSize(pRsp->writeDbs);
-  if (tEncodeI32(&encoder, numOfReadDbs) < 0) return -1;
+  if (tEncodeI32(pEncoder, numOfCreatedDbs) < 0) return -1;
-  if (tEncodeI32(&encoder, numOfWriteDbs) < 0) return -1;
+  if (tEncodeI32(pEncoder, numOfReadDbs) < 0) return -1;
+  if (tEncodeI32(pEncoder, numOfWriteDbs) < 0) return -1;
 
-  char *db = taosHashIterate(pRsp->readDbs, NULL);
+  char *db = taosHashIterate(pRsp->createdDbs, NULL);
   while (db != NULL) {
-    if (tEncodeCStr(&encoder, db) < 0) return -1;
+    if (tEncodeCStr(pEncoder, db) < 0) return -1;
+    db = taosHashIterate(pRsp->createdDbs, db);
+  }
+
+  db = taosHashIterate(pRsp->readDbs, NULL);
+  while (db != NULL) {
+    if (tEncodeCStr(pEncoder, db) < 0) return -1;
     db = taosHashIterate(pRsp->readDbs, db);
   }
 
   db = taosHashIterate(pRsp->writeDbs, NULL);
   while (db != NULL) {
-    if (tEncodeCStr(&encoder, db) < 0) return -1;
+    if (tEncodeCStr(pEncoder, db) < 0) return -1;
     db = taosHashIterate(pRsp->writeDbs, db);
   }
 
+  return 0;
+}
+
+int32_t tSerializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pRsp) {
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+
+  if (tSerializeSGetUserAuthRspImpl(&encoder, pRsp) < 0) return -1;
+
   tEndEncode(&encoder);
 
   int32_t tlen = encoder.pos;
@@ -1196,39 +1212,58 @@ int32_t tSerializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pR
   return tlen;
 }
 
-int32_t tDeserializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pRsp) {
+int32_t tDeserializeSGetUserAuthRspImpl(SCoder *pDecoder, SGetUserAuthRsp *pRsp) {
-  pRsp->readDbs = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+  pRsp->createdDbs = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
-  pRsp->writeDbs = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+  pRsp->readDbs = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
+  pRsp->writeDbs = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
   if (pRsp->readDbs == NULL || pRsp->writeDbs == NULL) {
     return -1;
   }
 
-  SCoder decoder = {0};
+  if (tDecodeCStrTo(pDecoder, pRsp->user) < 0) return -1;
-  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+  if (tDecodeI8(pDecoder, &pRsp->superAuth) < 0) return -1;
-
+  if (tDecodeI32(pDecoder, &pRsp->version) < 0) return -1;
-  if (tStartDecode(&decoder) < 0) return -1;
-  if (tDecodeCStrTo(&decoder, pRsp->user) < 0) return -1;
-  if (tDecodeI8(&decoder, &pRsp->superAuth) < 0) return -1;
 
+  int32_t numOfCreatedDbs = 0;
   int32_t numOfReadDbs = 0;
   int32_t numOfWriteDbs = 0;
-  if (tDecodeI32(&decoder, &numOfReadDbs) < 0) return -1;
+  if (tDecodeI32(pDecoder, &numOfCreatedDbs) < 0) return -1;
-  if (tDecodeI32(&decoder, &numOfWriteDbs) < 0) return -1;
+  if (tDecodeI32(pDecoder, &numOfReadDbs) < 0) return -1;
+  if (tDecodeI32(pDecoder, &numOfWriteDbs) < 0) return -1;
+
+  for (int32_t i = 0; i < numOfCreatedDbs; ++i) {
+    char db[TSDB_DB_FNAME_LEN] = {0};
+    if (tDecodeCStrTo(pDecoder, db) < 0) return -1;
+    int32_t len = strlen(db) + 1;
+    taosHashPut(pRsp->createdDbs, db, len, db, len);
+  }
 
   for (int32_t i = 0; i < numOfReadDbs; ++i) {
     char db[TSDB_DB_FNAME_LEN] = {0};
-    if (tDecodeCStrTo(&decoder, db) < 0) return -1;
+    if (tDecodeCStrTo(pDecoder, db) < 0) return -1;
     int32_t len = strlen(db) + 1;
     taosHashPut(pRsp->readDbs, db, len, db, len);
   }
 
   for (int32_t i = 0; i < numOfWriteDbs; ++i) {
     char db[TSDB_DB_FNAME_LEN] = {0};
-    if (tDecodeCStrTo(&decoder, db) < 0) return -1;
+    if (tDecodeCStrTo(pDecoder, db) < 0) return -1;
     int32_t len = strlen(db) + 1;
     taosHashPut(pRsp->writeDbs, db, len, db, len);
   }
 
+  return 0;
+}
+
+
+int32_t tDeserializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *pRsp) {
+  SCoder decoder = {0};
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+
+  if (tDeserializeSGetUserAuthRspImpl(&decoder, pRsp) < 0) return -1;
+
   tEndDecode(&decoder);
 
   tCoderClear(&decoder);
@@ -1236,6 +1271,7 @@ int32_t tDeserializeSGetUserAuthRsp(void *buf, int32_t bufLen, SGetUserAuthRsp *
 }
 
 void tFreeSGetUserAuthRsp(SGetUserAuthRsp *pRsp) {
+  taosHashCleanup(pRsp->createdDbs);
   taosHashCleanup(pRsp->readDbs);
   taosHashCleanup(pRsp->writeDbs);
 }
@@ -2055,6 +2091,62 @@ void tFreeSUseDbBatchRsp(SUseDbBatchRsp *pRsp) {
   taosArrayDestroy(pRsp->pArray);
 }
 
+int32_t tSerializeSUserAuthBatchRsp(void* buf, int32_t bufLen, SUserAuthBatchRsp* pRsp){
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+
+  int32_t numOfBatch = taosArrayGetSize(pRsp->pArray);
+  if (tEncodeI32(&encoder, numOfBatch) < 0) return -1;
+  for (int32_t i = 0; i < numOfBatch; ++i) {
+    SGetUserAuthRsp *pUserAuthRsp = taosArrayGet(pRsp->pArray, i);
+    if (tSerializeSGetUserAuthRspImpl(&encoder, pUserAuthRsp) < 0) return -1;
+  }
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tCoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSUserAuthBatchRsp(void* buf, int32_t bufLen, SUserAuthBatchRsp* pRsp){
+  SCoder decoder = {0};
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+
+  int32_t numOfBatch = taosArrayGetSize(pRsp->pArray);
+  if (tDecodeI32(&decoder, &numOfBatch) < 0) return -1;
+
+  pRsp->pArray = taosArrayInit(numOfBatch, sizeof(SGetUserAuthRsp));
+  if (pRsp->pArray == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
+
+  for (int32_t i = 0; i < numOfBatch; ++i) {
+    SGetUserAuthRsp rsp = {0};
+    if (tDeserializeSGetUserAuthRspImpl(&decoder, &rsp) < 0) return -1;
+    taosArrayPush(pRsp->pArray, &rsp);
+  }
+  tEndDecode(&decoder);
+
+  tCoderClear(&decoder);
+  return 0;
+}
+
+void    tFreeSUserAuthBatchRsp(SUserAuthBatchRsp* pRsp){
+  int32_t numOfBatch = taosArrayGetSize(pRsp->pArray);
+  for (int32_t i = 0; i < numOfBatch; ++i) {
+    SGetUserAuthRsp *pUserAuthRsp = taosArrayGet(pRsp->pArray, i);
+    tFreeSGetUserAuthRsp(pUserAuthRsp);
+  }
+
+  taosArrayDestroy(pRsp->pArray);
+}
+
+
 int32_t tSerializeSDbCfgReq(void *buf, int32_t bufLen, SDbCfgReq *pReq) {
   SCoder encoder = {0};
   tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
@@ -3860,3 +3952,65 @@ int32_t tDecodeSVDropStbReq(SCoder *pCoder, SVDropStbReq *pReq) {
   tEndDecode(pCoder);
   return 0;
 }
+
+static int32_t tEncodeSVSubmitBlk(SCoder *pCoder, const SVSubmitBlk *pBlock, int32_t flags) {
+  if (tStartEncode(pCoder) < 0) return -1;
+
+  if (tEncodeI64(pCoder, pBlock->suid) < 0) return -1;
+  if (tEncodeI64(pCoder, pBlock->uid) < 0) return -1;
+  if (tEncodeI32v(pCoder, pBlock->sver) < 0) return -1;
+  if (tEncodeBinary(pCoder, pBlock->pData, pBlock->nData) < 0) return -1;
+
+  if (flags & TD_AUTO_CREATE_TABLE) {
+    if (tEncodeSVCreateTbReq(pCoder, &pBlock->cTbReq) < 0) return -1;
+  }
+
+  tEndEncode(pCoder);
+  return 0;
+}
+
+static int32_t tDecodeSVSubmitBlk(SCoder *pCoder, SVSubmitBlk *pBlock, int32_t flags) {
+  if (tStartDecode(pCoder) < 0) return -1;
+
+  if (tDecodeI64(pCoder, &pBlock->suid) < 0) return -1;
+  if (tDecodeI64(pCoder, &pBlock->uid) < 0) return -1;
+  if (tDecodeI32v(pCoder, &pBlock->sver) < 0) return -1;
+  if (tDecodeBinary(pCoder, &pBlock->pData, &pBlock->nData) < 0) return -1;
+
+  if (flags & TD_AUTO_CREATE_TABLE) {
+    if (tDecodeSVCreateTbReq(pCoder, &pBlock->cTbReq) < 0) return -1;
+  }
+
+  tEndDecode(pCoder);
+  return 0;
+}
+
+int32_t tEncodeSVSubmitReq(SCoder *pCoder, const SVSubmitReq *pReq) {
+  int32_t nBlocks = taosArrayGetSize(pReq->pArray);
+
+  if (tStartEncode(pCoder) < 0) return -1;
+
+  if (tEncodeI32v(pCoder, pReq->flags) < 0) return -1;
+  if (tEncodeI32v(pCoder, nBlocks) < 0) return -1;
+  for (int32_t iBlock = 0; iBlock < nBlocks; iBlock++) {
+    if (tEncodeSVSubmitBlk(pCoder, (SVSubmitBlk *)taosArrayGet(pReq->pArray, iBlock), pReq->flags) < 0) return -1;
+  }
+
+  tEndEncode(pCoder);
+  return 0;
+}
+
+int32_t tDecodeSVSubmitReq(SCoder *pCoder, SVSubmitReq *pReq) {
+  if (tStartDecode(pCoder) < 0) return -1;
+
+  if (tDecodeI32v(pCoder, &pReq->flags) < 0) return -1;
+  if (tDecodeI32v(pCoder, &pReq->nBlocks) < 0) return -1;
+  pReq->pBlocks = tCoderMalloc(pCoder, sizeof(SVSubmitBlk) * pReq->nBlocks);
+  if (pReq->pBlocks == NULL) return -1;
+  for (int32_t iBlock = 0; iBlock < pReq->nBlocks; iBlock++) {
+    if (tDecodeSVSubmitBlk(pCoder, pReq->pBlocks + iBlock, pReq->flags) < 0) return -1;
+  }
+
+  tEndDecode(pCoder);
+  return 0;
+}

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

@@ -130,10 +130,10 @@ _OVER:
 }
 
 static void dmProcessMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
-  SDnodeTrans  *pTrans = &pDnode->trans;
+  SDnodeTrans * pTrans = &pDnode->trans;
   tmsg_t        msgType = pMsg->msgType;
   bool          isReq = msgType & 1u;
-  SMsgHandle   *pHandle = &pTrans->msgHandles[TMSG_INDEX(msgType)];
+  SMsgHandle *  pHandle = &pTrans->msgHandles[TMSG_INDEX(msgType)];
   SMgmtWrapper *pWrapper = pHandle->pNdWrapper;
 
   if (msgType == TDMT_DND_SERVER_STATUS) {
@@ -517,7 +517,7 @@ static inline int32_t dmRetrieveUserAuthInfo(SDnode *pDnode, char *user, char *s
   SAuthReq authReq = {0};
   tstrncpy(authReq.user, user, TSDB_USER_LEN);
   int32_t contLen = tSerializeSAuthReq(NULL, 0, &authReq);
-  void   *pReq = rpcMallocCont(contLen);
+  void *  pReq = rpcMallocCont(contLen);
   tSerializeSAuthReq(pReq, contLen, &authReq);
 
   SRpcMsg rpcMsg = {.pCont = pReq, .contLen = contLen, .msgType = TDMT_MND_AUTH, .ahandle = (void *)9528};
@@ -547,6 +547,8 @@ static int32_t dmInitServer(SDnode *pDnode) {
   SDnodeTrans *pTrans = &pDnode->trans;
 
   SRpcInit rpcInit = {0};
+
+  strncpy(rpcInit.localFqdn, pDnode->data.localFqdn, strlen(pDnode->data.localFqdn));
   rpcInit.localPort = pDnode->data.serverPort;
   rpcInit.label = "DND";
   rpcInit.numOfThreads = tsNumOfRpcThreads;

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

@@ -255,8 +255,10 @@ typedef struct {
   int64_t   updateTime;
   int8_t    superUser;
   int32_t   acctId;
+  int32_t   authVersion;
   SHashObj* readDbs;
   SHashObj* writeDbs;
+  SRWLatch  lock;
 } SUserObj;
 
 typedef struct {

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

@@ -26,7 +26,6 @@ int32_t  mndInitSma(SMnode *pMnode);
 void     mndCleanupSma(SMnode *pMnode);
 SSmaObj *mndAcquireSma(SMnode *pMnode, char *smaName);
 void     mndReleaseSma(SMnode *pMnode, SSmaObj *pSma);
-int32_t mndProcessGetSmaReq(SMnode       *pMnode, SUserIndexReq *indexReq, SUserIndexRsp *rsp, bool *exist);
 
 #ifdef __cplusplus
 }

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

@@ -29,6 +29,7 @@ void      mndReleaseUser(SMnode *pMnode, SUserObj *pUser);
 
 // for trans test
 SSdbRaw *mndUserActionEncode(SUserObj *pUser);
+int32_t mndValidateUserAuthInfo(SMnode *pMnode, SUserAuthVersion *pUsers, int32_t numOfUses, void **ppRsp, int32_t *pRspLen);
 
 #ifdef __cplusplus
 }

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

@@ -33,6 +33,7 @@ int32_t  mndGetVnodesNum(SMnode *pMnode, int32_t dnodeId);
 
 void *mndBuildCreateVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen);
 void *mndBuildDropVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen);
+void *mndBuildAlterVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen);
 
 #ifdef __cplusplus
 }

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

@@ -44,16 +44,17 @@ static int32_t  mndProcessCompactDbReq(SNodeMsg *pReq);
 static int32_t  mndRetrieveDbs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity);
 static void     mndCancelGetNextDb(SMnode *pMnode, void *pIter);
 static int32_t  mndProcessGetDbCfgReq(SNodeMsg *pReq);
-static int32_t  mndProcessGetIndexReq(SNodeMsg *pReq);
 
 int32_t mndInitDb(SMnode *pMnode) {
-  SSdbTable table = {.sdbType = SDB_DB,
+  SSdbTable table = {
+      .sdbType = SDB_DB,
       .keyType = SDB_KEY_BINARY,
       .encodeFp = (SdbEncodeFp)mndDbActionEncode,
       .decodeFp = (SdbDecodeFp)mndDbActionDecode,
       .insertFp = (SdbInsertFp)mndDbActionInsert,
       .updateFp = (SdbUpdateFp)mndDbActionUpdate,
-                     .deleteFp = (SdbDeleteFp)mndDbActionDelete};
+      .deleteFp = (SdbDeleteFp)mndDbActionDelete,
+  };
 
   mndSetMsgHandle(pMnode, TDMT_MND_CREATE_DB, mndProcessCreateDbReq);
   mndSetMsgHandle(pMnode, TDMT_MND_ALTER_DB, mndProcessAlterDbReq);
@@ -61,7 +62,6 @@ int32_t mndInitDb(SMnode *pMnode) {
   mndSetMsgHandle(pMnode, TDMT_MND_USE_DB, mndProcessUseDbReq);
   mndSetMsgHandle(pMnode, TDMT_MND_COMPACT_DB, mndProcessCompactDbReq);
   mndSetMsgHandle(pMnode, TDMT_MND_GET_DB_CFG, mndProcessGetDbCfgReq);
-  mndSetMsgHandle(pMnode, TDMT_MND_GET_INDEX, mndProcessGetIndexReq);
 
   mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_DB, mndRetrieveDbs);
   mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_DB, mndCancelGetNextDb);
@@ -194,6 +194,7 @@ static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw) {
   }
 
   SDB_GET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER)
+  taosInitRWLatch(&pDb->lock);
 
   terrno = 0;
 
@@ -222,17 +223,29 @@ static int32_t mndDbActionDelete(SSdb *pSdb, SDbObj *pDb) {
 static int32_t mndDbActionUpdate(SSdb *pSdb, SDbObj *pOld, SDbObj *pNew) {
   mTrace("db:%s, perform update action, old row:%p new row:%p", pOld->name, pOld, pNew);
   taosWLockLatch(&pOld->lock);
-  SArray *pOldRetensions = pOld->cfg.pRetensions;
   pOld->updateTime = pNew->updateTime;
   pOld->cfgVersion = pNew->cfgVersion;
   pOld->vgVersion = pNew->vgVersion;
-  memcpy(&pOld->cfg, &pNew->cfg, sizeof(SDbCfg));
+  pOld->cfg.buffer = pNew->cfg.buffer;
-  pNew->cfg.pRetensions = pOldRetensions;
+  pOld->cfg.pages = pNew->cfg.pages;
+  pOld->cfg.pageSize = pNew->cfg.pageSize;
+  pOld->cfg.daysPerFile = pNew->cfg.daysPerFile;
+  pOld->cfg.daysToKeep0 = pNew->cfg.daysToKeep0;
+  pOld->cfg.daysToKeep1 = pNew->cfg.daysToKeep1;
+  pOld->cfg.daysToKeep2 = pNew->cfg.daysToKeep2;
+  pOld->cfg.fsyncPeriod = pNew->cfg.fsyncPeriod;
+  pOld->cfg.walLevel = pNew->cfg.walLevel;
+  pOld->cfg.strict = pNew->cfg.strict;
+  pOld->cfg.cacheLastRow = pNew->cfg.cacheLastRow;
+  pOld->cfg.replications = pNew->cfg.replications;
   taosWUnLockLatch(&pOld->lock);
   return 0;
 }
 
-static int32_t mndGetGlobalVgroupVersion(SMnode *pMnode) { return sdbGetTableVer(pMnode->pSdb, SDB_VGROUP); }
+static inline int32_t mndGetGlobalVgroupVersion(SMnode *pMnode) {
+  SSdb *pSdb = pMnode->pSdb;
+  return sdbGetTableVer(pSdb, SDB_VGROUP);
+}
 
 SDbObj *mndAcquireDb(SMnode *pMnode, const char *db) {
   SSdb   *pSdb = pMnode->pSdb;
@@ -638,69 +651,7 @@ static int32_t mndSetAlterDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *p
   return 0;
 }
 
-void *mndBuildAlterVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen) {
+static int32_t mndBuildAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup) {
-  SAlterVnodeReq alterReq = {0};
-  alterReq.vgVersion = pVgroup->version;
-  alterReq.buffer = pDb->cfg.buffer;
-  alterReq.pages = pDb->cfg.pages;
-  alterReq.pageSize = pDb->cfg.pageSize;
-  alterReq.daysPerFile = pDb->cfg.daysPerFile;
-  alterReq.daysToKeep0 = pDb->cfg.daysToKeep0;
-  alterReq.daysToKeep1 = pDb->cfg.daysToKeep1;
-  alterReq.daysToKeep2 = pDb->cfg.daysToKeep2;
-  alterReq.fsyncPeriod = pDb->cfg.fsyncPeriod;
-  alterReq.walLevel = pDb->cfg.walLevel;
-  alterReq.strict = pDb->cfg.strict;
-  alterReq.cacheLastRow = pDb->cfg.cacheLastRow;
-  alterReq.replica = pVgroup->replica;
-  alterReq.selfIndex = -1;
-
-  for (int32_t v = 0; v < pVgroup->replica; ++v) {
-    SReplica  *pReplica = &alterReq.replicas[v];
-    SVnodeGid *pVgid = &pVgroup->vnodeGid[v];
-    SDnodeObj *pVgidDnode = mndAcquireDnode(pMnode, pVgid->dnodeId);
-    if (pVgidDnode == NULL) {
-      return NULL;
-    }
-
-    pReplica->id = pVgidDnode->id;
-    pReplica->port = pVgidDnode->port;
-    memcpy(pReplica->fqdn, pVgidDnode->fqdn, TSDB_FQDN_LEN);
-    mndReleaseDnode(pMnode, pVgidDnode);
-
-    if (pDnode->id == pVgid->dnodeId) {
-      alterReq.selfIndex = v;
-    }
-  }
-
-  if (alterReq.selfIndex == -1) {
-    terrno = TSDB_CODE_MND_APP_ERROR;
-    return NULL;
-  }
-
-  int32_t contLen = tSerializeSAlterVnodeReq(NULL, 0, &alterReq);
-  if (contLen < 0) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
-  }
-  contLen += +sizeof(SMsgHead);
-
-  void *pReq = taosMemoryMalloc(contLen);
-  if (pReq == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
-  }
-
-  SMsgHead *pHead = pReq;
-  pHead->contLen = htonl(contLen);
-  pHead->vgId = htonl(pVgroup->vgId);
-
-  tSerializeSAlterVnodeReq((char *)pReq + sizeof(SMsgHead), contLen, &alterReq);
-  *pContLen = contLen;
-  return pReq;
-}
-
-static int32_t mndBuilAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup) {
   for (int32_t vn = 0; vn < pVgroup->replica; ++vn) {
     STransAction action = {0};
     SVnodeGid   *pVgid = pVgroup->vnodeGid + vn;
@@ -736,7 +687,7 @@ static int32_t mndSetAlterDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *
     if (pIter == NULL) break;
 
     if (pVgroup->dbUid == pNew->uid) {
-      if (mndBuilAlterVgroupAction(pMnode, pTrans, pNew, pVgroup) != 0) {
+      if (mndBuildAlterVgroupAction(pMnode, pTrans, pNew, pVgroup) != 0) {
         sdbCancelFetch(pSdb, pIter);
         sdbRelease(pSdb, pVgroup);
         return -1;
@@ -752,19 +703,19 @@ static int32_t mndSetAlterDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *
 static int32_t mndAlterDb(SMnode *pMnode, SNodeMsg *pReq, SDbObj *pOld, SDbObj *pNew) {
   int32_t code = -1;
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_ALTER_DB, &pReq->rpcMsg);
-  if (pTrans == NULL) goto UPDATE_DB_OVER;
+  if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to alter db:%s", pTrans->id, pOld->name);
 
   mndTransSetDbInfo(pTrans, pOld);
-  if (mndSetAlterDbRedoLogs(pMnode, pTrans, pOld, pNew) != 0) goto UPDATE_DB_OVER;
+  if (mndSetAlterDbRedoLogs(pMnode, pTrans, pOld, pNew) != 0) goto _OVER;
-  if (mndSetAlterDbCommitLogs(pMnode, pTrans, pOld, pNew) != 0) goto UPDATE_DB_OVER;
+  if (mndSetAlterDbCommitLogs(pMnode, pTrans, pOld, pNew) != 0) goto _OVER;
-  if (mndSetAlterDbRedoActions(pMnode, pTrans, pOld, pNew) != 0) goto UPDATE_DB_OVER;
+  if (mndSetAlterDbRedoActions(pMnode, pTrans, pOld, pNew) != 0) goto _OVER;
-  if (mndTransPrepare(pMnode, pTrans) != 0) goto UPDATE_DB_OVER;
+  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
 
   code = 0;
 
-UPDATE_DB_OVER:
+_OVER:
   mndTransDrop(pTrans);
   return code;
 }
@@ -778,7 +729,7 @@ static int32_t mndProcessAlterDbReq(SNodeMsg *pReq) {
 
   if (tDeserializeSAlterDbReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &alterReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
-    goto ALTER_DB_OVER;
+    goto _OVER;
   }
 
   mDebug("db:%s, start to alter", alterReq.db);
@@ -786,24 +737,26 @@ static int32_t mndProcessAlterDbReq(SNodeMsg *pReq) {
   pDb = mndAcquireDb(pMnode, alterReq.db);
   if (pDb == NULL) {
     terrno = TSDB_CODE_MND_DB_NOT_EXIST;
-    goto ALTER_DB_OVER;
+    goto _OVER;
   }
 
   pUser = mndAcquireUser(pMnode, pReq->user);
   if (pUser == NULL) {
-    goto ALTER_DB_OVER;
+    goto _OVER;
   }
 
   if (mndCheckAlterDropCompactDbAuth(pUser, pDb) != 0) {
-    goto ALTER_DB_OVER;
+    goto _OVER;
   }
 
   SDbObj dbObj = {0};
   memcpy(&dbObj, pDb, sizeof(SDbObj));
+  dbObj.cfg.numOfRetensions = 0;
+  dbObj.cfg.pRetensions = NULL;
 
   code = mndSetDbCfgFromAlterDbReq(&dbObj, &alterReq);
   if (code != 0) {
-    goto ALTER_DB_OVER;
+    goto _OVER;
   }
 
   dbObj.cfgVersion++;
@@ -811,7 +764,7 @@ static int32_t mndProcessAlterDbReq(SNodeMsg *pReq) {
   code = mndAlterDb(pMnode, pReq, pDb, &dbObj);
   if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS;
 
-ALTER_DB_OVER:
+_OVER:
   if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
     mError("db:%s, failed to alter since %s", alterReq.db, terrstr());
   }
@@ -831,13 +784,13 @@ static int32_t mndProcessGetDbCfgReq(SNodeMsg *pReq) {
 
   if (tDeserializeSDbCfgReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &cfgReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
-    goto GET_DB_CFG_OVER;
+    goto _OVER;
   }
 
   pDb = mndAcquireDb(pMnode, cfgReq.db);
   if (pDb == NULL) {
     terrno = TSDB_CODE_MND_DB_NOT_EXIST;
-    goto GET_DB_CFG_OVER;
+    goto _OVER;
   }
 
   cfgRsp.numOfVgroups = pDb->cfg.numOfVgroups;
@@ -866,7 +819,7 @@ static int32_t mndProcessGetDbCfgReq(SNodeMsg *pReq) {
   if (pRsp == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     code = -1;
-    goto GET_DB_CFG_OVER;
+    goto _OVER;
   }
 
   tSerializeSDbCfgRsp(pRsp, contLen, &cfgRsp);
@@ -876,9 +829,9 @@ static int32_t mndProcessGetDbCfgReq(SNodeMsg *pReq) {
 
   code = 0;
 
-GET_DB_CFG_OVER:
+_OVER:
 
-  if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
+  if (code != 0) {
     mError("db:%s, failed to get cfg since %s", cfgReq.db, terrstr());
   }
 
@@ -1097,7 +1050,8 @@ _OVER:
   return code;
 }
 
-void mndGetDBTableNum(SDbObj *pDb, SMnode *pMnode, int32_t *num) {
+static int32_t mndGetDBTableNum(SDbObj *pDb, SMnode *pMnode) {
+  int32_t numOfTables = 0;
   int32_t vindex = 0;
   SSdb   *pSdb = pMnode->pSdb;
 
@@ -1108,8 +1062,7 @@ void mndGetDBTableNum(SDbObj *pDb, SMnode *pMnode, int32_t *num) {
     if (pIter == NULL) break;
 
     if (pVgroup->dbUid == pDb->uid) {
-      *num += pVgroup->numOfTables / TSDB_TABLE_NUM_UNIT;
+      numOfTables += pVgroup->numOfTables / TSDB_TABLE_NUM_UNIT;
-
       vindex++;
     }
 
@@ -1117,6 +1070,7 @@ void mndGetDBTableNum(SDbObj *pDb, SMnode *pMnode, int32_t *num) {
   }
 
   sdbCancelFetch(pSdb, pIter);
+  return numOfTables;
 }
 
 static void mndBuildDBVgroupInfo(SDbObj *pDb, SMnode *pMnode, SArray *pVgList) {
@@ -1170,8 +1124,7 @@ int32_t mndExtractDbInfo(SMnode *pMnode, SDbObj *pDb, SUseDbRsp *pRsp, const SUs
     return -1;
   }
 
-  int32_t numOfTable = 0;
+  int32_t numOfTable = mndGetDBTableNum(pDb, pMnode);
-  mndGetDBTableNum(pDb, pMnode, &numOfTable);
 
   if (pReq == NULL || pReq->vgVersion < pDb->vgVersion || pReq->dbId != pDb->uid || numOfTable != pReq->numOfTable) {
     mndBuildDBVgroupInfo(pDb, pMnode, pRsp->pVgroupInfos);
@@ -1195,7 +1148,7 @@ static int32_t mndProcessUseDbReq(SNodeMsg *pReq) {
 
   if (tDeserializeSUseDbReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &usedbReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
-    goto USE_DB_OVER;
+    goto _OVER;
   }
 
   char *p = strchr(usedbReq.db, '.');
@@ -1206,12 +1159,11 @@ static int32_t mndProcessUseDbReq(SNodeMsg *pReq) {
       usedbRsp.pVgroupInfos = taosArrayInit(10, sizeof(SVgroupInfo));
       if (usedbRsp.pVgroupInfos == NULL) {
         terrno = TSDB_CODE_OUT_OF_MEMORY;
-        goto USE_DB_OVER;
+        goto _OVER;
       }
 
       mndBuildDBVgroupInfo(NULL, pMnode, usedbRsp.pVgroupInfos);
       usedbRsp.vgVersion = vgVersion++;
-
     } else {
       usedbRsp.vgVersion = usedbReq.vgVersion;
     }
@@ -1232,15 +1184,15 @@ static int32_t mndProcessUseDbReq(SNodeMsg *pReq) {
     } else {
       pUser = mndAcquireUser(pMnode, pReq->user);
       if (pUser == NULL) {
-        goto USE_DB_OVER;
+        goto _OVER;
       }
 
       if (mndCheckUseDbAuth(pUser, pDb) != 0) {
-        goto USE_DB_OVER;
+        goto _OVER;
       }
 
       if (mndExtractDbInfo(pMnode, pDb, &usedbRsp, &usedbReq) < 0) {
-        goto USE_DB_OVER;
+        goto _OVER;
       }
 
       code = 0;
@@ -1252,7 +1204,7 @@ static int32_t mndProcessUseDbReq(SNodeMsg *pReq) {
   if (pRsp == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     code = -1;
-    goto USE_DB_OVER;
+    goto _OVER;
   }
 
   tSerializeSUseDbRsp(pRsp, contLen, &usedbRsp);
@@ -1260,7 +1212,7 @@ static int32_t mndProcessUseDbReq(SNodeMsg *pReq) {
   pReq->pRsp = pRsp;
   pReq->rspLen = contLen;
 
-USE_DB_OVER:
+_OVER:
   if (code != 0) {
     mError("db:%s, failed to process use db req since %s", usedbReq.db, terrstr());
   }
@@ -1298,8 +1250,7 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbVgVersion *pDbs, int32_t numOfDbs,
       continue;
     }
 
-    int32_t numOfTable = 0;
+    int32_t numOfTable = mndGetDBTableNum(pDb, pMnode);
-    mndGetDBTableNum(pDb, pMnode, &numOfTable);
 
     if (pDbVgVersion->vgVersion >= pDb->vgVersion && numOfTable == pDbVgVersion->numOfTable) {
       mDebug("db:%s, version & numOfTable not changed", pDbVgVersion->dbFName);
@@ -1514,9 +1465,6 @@ static void dumpDbInfoData(SSDataBlock *pBlock, SDbObj *pDb, SShowObj *pShow, in
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols);
     colDataAppend(pColInfo, rows, (const char *)b, false);
   }
-
-  //  pWrite = getDataPosition(data, pShow, cols, rows, rowCapacity);
-  //  *(int8_t *)pWrite = pDb->cfg.update;
 }
 
 static void setInformationSchemaDbCfg(SDbObj *pDbObj) {
@@ -1544,7 +1492,6 @@ static void setPerfSchemaDbCfg(SDbObj *pDbObj) {
 static bool mndGetTablesOfDbFp(SMnode *pMnode, void *pObj, void *p1, void *p2, void *p3) {
   SVgObj  *pVgroup = pObj;
   int32_t *numOfTables = p1;
-
   *numOfTables += pVgroup->numOfTables;
   return true;
 }
@@ -1594,49 +1541,3 @@ static void mndCancelGetNextDb(SMnode *pMnode, void *pIter) {
   SSdb *pSdb = pMnode->pSdb;
   sdbCancelFetch(pSdb, pIter);
 }
-
-static int32_t mndProcessGetIndexReq(SNodeMsg *pReq) {
-  SUserIndexReq indexReq = {0};
-  SMnode       *pMnode = pReq->pNode;
-  int32_t       code = -1;
-  SUserIndexRsp rsp = {0};
-  bool          exist = false;
-
-  if (tDeserializeSUserIndexReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &indexReq) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
-    goto _OVER;
-  }
-
-  code = mndProcessGetSmaReq(pMnode, &indexReq, &rsp, &exist);
-  if (code) {
-    goto _OVER;
-  }
-
-  if (!exist) {
-    // TODO GET INDEX FROM FULLTEXT
-    code = -1;
-    terrno = TSDB_CODE_MND_DB_INDEX_NOT_EXIST;
-  } else {
-    int32_t contLen = tSerializeSUserIndexRsp(NULL, 0, &rsp);
-    void   *pRsp = rpcMallocCont(contLen);
-    if (pRsp == NULL) {
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      code = -1;
-      goto _OVER;
-    }
-
-    tSerializeSUserIndexRsp(pRsp, contLen, &rsp);
-
-    pReq->pRsp = pRsp;
-    pReq->rspLen = contLen;
-
-    code = 0;
-  }
-
-_OVER:
-  if (code != 0) {
-    mError("failed to get index %s since %s", indexReq.indexFName, terrstr());
-  }
-
-  return code;
-}

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

@@ -314,7 +314,7 @@ static int32_t mndProcessCreateFuncReq(SNodeMsg *pReq) {
    goto _OVER;
  }
 
-  if (createReq.bufSize <= 0 || createReq.bufSize > TSDB_FUNC_BUF_SIZE) {
+  if (createReq.bufSize < 0 || createReq.bufSize > TSDB_FUNC_BUF_SIZE) {
     terrno = TSDB_CODE_MND_INVALID_FUNC_BUFSIZE;
     goto _OVER;
   }

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

@@ -403,6 +403,16 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
     SKv *kv = pIter;
 
     switch (kv->key) {
+      case HEARTBEAT_KEY_USER_AUTHINFO: {
+        void *  rspMsg = NULL;
+        int32_t rspLen = 0;
+        mndValidateUserAuthInfo(pMnode, kv->value, kv->valueLen / sizeof(SUserAuthVersion), &rspMsg, &rspLen);
+        if (rspMsg && rspLen > 0) {
+          SKv kv1 = {.key = HEARTBEAT_KEY_USER_AUTHINFO, .valueLen = rspLen, .value = rspMsg};
+          taosArrayPush(hbRsp.info, &kv1);
+        }
+        break;
+      }
       case HEARTBEAT_KEY_DBINFO: {
         void *  rspMsg = NULL;
         int32_t rspLen = 0;

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

@@ -40,6 +40,7 @@ static int32_t  mndProcessMCreateSmaReq(SNodeMsg *pReq);
 static int32_t  mndProcessMDropSmaReq(SNodeMsg *pReq);
 static int32_t  mndProcessVCreateSmaRsp(SNodeMsg *pRsp);
 static int32_t  mndProcessVDropSmaRsp(SNodeMsg *pRsp);
+static int32_t  mndProcessGetSmaReq(SNodeMsg *pReq);
 static int32_t  mndRetrieveSma(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
 static void     mndCancelGetNextSma(SMnode *pMnode, void *pIter);
 
@@ -56,6 +57,7 @@ int32_t mndInitSma(SMnode *pMnode) {
   mndSetMsgHandle(pMnode, TDMT_MND_DROP_SMA, mndProcessMDropSmaReq);
   mndSetMsgHandle(pMnode, TDMT_VND_CREATE_SMA_RSP, mndProcessVCreateSmaRsp);
   mndSetMsgHandle(pMnode, TDMT_VND_DROP_SMA_RSP, mndProcessVDropSmaRsp);
+  mndSetMsgHandle(pMnode, TDMT_MND_GET_INDEX, mndProcessGetSmaReq);
 
   mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_INDEX, mndRetrieveSma);
   mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_INDEX, mndCancelGetNextSma);
@@ -686,7 +688,7 @@ _OVER:
   return code;
 }
 
-int32_t mndProcessGetSmaReq(SMnode *pMnode, SUserIndexReq *indexReq, SUserIndexRsp *rsp, bool *exist) {
+static int32_t mndGetSma(SMnode *pMnode, SUserIndexReq *indexReq, SUserIndexRsp *rsp, bool *exist) {
   int32_t  code = -1;
   SSmaObj *pSma = NULL;
 
@@ -715,6 +717,51 @@ int32_t mndProcessGetSmaReq(SMnode *pMnode, SUserIndexReq *indexReq, SUserIndexR
   }
 
   mndReleaseSma(pMnode, pSma);
+  return code;
+}
+
+static int32_t mndProcessGetSmaReq(SNodeMsg *pReq) {
+  SUserIndexReq indexReq = {0};
+  SMnode       *pMnode = pReq->pNode;
+  int32_t       code = -1;
+  SUserIndexRsp rsp = {0};
+  bool          exist = false;
+
+  if (tDeserializeSUserIndexReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &indexReq) != 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    goto _OVER;
+  }
+
+  code = mndGetSma(pMnode, &indexReq, &rsp, &exist);
+  if (code) {
+    goto _OVER;
+  }
+
+  if (!exist) {
+    // TODO GET INDEX FROM FULLTEXT
+    code = -1;
+    terrno = TSDB_CODE_MND_DB_INDEX_NOT_EXIST;
+  } else {
+    int32_t contLen = tSerializeSUserIndexRsp(NULL, 0, &rsp);
+    void   *pRsp = rpcMallocCont(contLen);
+    if (pRsp == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      code = -1;
+      goto _OVER;
+    }
+
+    tSerializeSUserIndexRsp(pRsp, contLen, &rsp);
+
+    pReq->pRsp = pRsp;
+    pReq->rspLen = contLen;
+
+    code = 0;
+  }
+
+_OVER:
+  if (code != 0) {
+    mError("failed to get index %s since %s", indexReq.indexFName, terrstr());
+  }
 
   return code;
 }

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

@@ -1050,7 +1050,7 @@ static int32_t mndTransExecuteActions(SMnode *pMnode, STrans *pTrans, SArray *pA
 
 static int32_t mndTransExecuteRedoActions(SMnode *pMnode, STrans *pTrans) {
   int32_t code = mndTransExecuteActions(pMnode, pTrans, pTrans->redoActions);
-  if (code != 0) {
+  if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
     mError("failed to execute redoActions since %s", terrstr());
   }
   return code;
@@ -1058,7 +1058,7 @@ static int32_t mndTransExecuteRedoActions(SMnode *pMnode, STrans *pTrans) {
 
 static int32_t mndTransExecuteUndoActions(SMnode *pMnode, STrans *pTrans) {
   int32_t code = mndTransExecuteActions(pMnode, pTrans, pTrans->undoActions);
-  if (code != 0) {
+  if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
     mError("failed to execute undoActions since %s", terrstr());
   }
   return code;

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

@@ -186,6 +186,7 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) {
   }
 
   SDB_GET_RESERVE(pRaw, dataPos, USER_RESERVE_SIZE, _OVER)
+  taosInitRWLatch(&pUser->lock);
 
   terrno = 0;
 
@@ -228,11 +229,12 @@ static int32_t mndUserActionDelete(SSdb *pSdb, SUserObj *pUser) {
 
 static int32_t mndUserActionUpdate(SSdb *pSdb, SUserObj *pOld, SUserObj *pNew) {
   mTrace("user:%s, perform update action, old row:%p new row:%p", pOld->user, pOld, pNew);
-  memcpy(pOld->pass, pNew->pass, TSDB_PASSWORD_LEN);
+  taosWLockLatch(&pOld->lock);
   pOld->updateTime = pNew->updateTime;
-
+  memcpy(pOld->pass, pNew->pass, TSDB_PASSWORD_LEN);
   TSWAP(pOld->readDbs, pNew->readDbs);
   TSWAP(pOld->writeDbs, pNew->writeDbs);
+  taosWUnLockLatch(&pOld->lock);
 
   return 0;
 }
@@ -426,8 +428,12 @@ static int32_t mndProcessAlterUserReq(SNodeMsg *pReq) {
   }
 
   memcpy(&newUser, pUser, sizeof(SUserObj));
+
+  taosRLockLatch(&pUser->lock);
   newUser.readDbs = mndDupDbHash(pUser->readDbs);
   newUser.writeDbs = mndDupDbHash(pUser->writeDbs);
+  taosRUnLockLatch(&pUser->lock);
+
   if (newUser.readDbs == NULL || newUser.writeDbs == NULL) {
     goto _OVER;
   }
@@ -451,13 +457,16 @@ static int32_t mndProcessAlterUserReq(SNodeMsg *pReq) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       goto _OVER;
     }
+    newUser.authVersion++;
   } else if (alterReq.alterType == TSDB_ALTER_USER_REMOVE_READ_DB) {
     if (taosHashRemove(newUser.readDbs, alterReq.dbname, len) != 0) {
       terrno = TSDB_CODE_MND_DB_NOT_EXIST;
       goto _OVER;
     }
+    newUser.authVersion++;
   } else if (alterReq.alterType == TSDB_ALTER_USER_CLEAR_READ_DB) {
     taosHashClear(newUser.readDbs);
+    newUser.authVersion++;
   } else if (alterReq.alterType == TSDB_ALTER_USER_ADD_WRITE_DB) {
     if (pDb == NULL) {
       terrno = TSDB_CODE_MND_DB_NOT_EXIST;
@@ -467,13 +476,16 @@ static int32_t mndProcessAlterUserReq(SNodeMsg *pReq) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       goto _OVER;
     }
+    newUser.authVersion++;
   } else if (alterReq.alterType == TSDB_ALTER_USER_REMOVE_WRITE_DB) {
     if (taosHashRemove(newUser.writeDbs, alterReq.dbname, len) != 0) {
       terrno = TSDB_CODE_MND_DB_NOT_EXIST;
       goto _OVER;
     }
+    newUser.authVersion++;
   } else if (alterReq.alterType == TSDB_ALTER_USER_CLEAR_WRITE_DB) {
     taosHashClear(newUser.writeDbs);
+    newUser.authVersion++;
   } else {
     terrno = TSDB_CODE_MND_INVALID_ALTER_OPER;
     goto _OVER;
@@ -576,6 +588,38 @@ _OVER:
   return code;
 }
 
+static int32_t mndSetUserAuthRsp(SMnode       *pMnode, SUserObj *pUser, SGetUserAuthRsp *pRsp) {
+  memcpy(pRsp->user, pUser->user, TSDB_USER_LEN);
+  pRsp->superAuth = pUser->superUser;
+  pRsp->version = pUser->authVersion;
+  taosRLockLatch(&pUser->lock);
+  pRsp->readDbs = mndDupDbHash(pUser->readDbs);
+  pRsp->writeDbs = mndDupDbHash(pUser->writeDbs);
+  taosRUnLockLatch(&pUser->lock);
+  pRsp->createdDbs = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
+  if (NULL == pRsp->createdDbs) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
+  
+  SSdb *pSdb = pMnode->pSdb;
+  void *pIter = NULL;
+  while (1) {
+    SDbObj *pDb = NULL;
+    pIter = sdbFetch(pSdb, SDB_DB, pIter, (void **)&pDb);
+    if (pIter == NULL) break;
+
+    if (strcmp(pDb->createUser, pUser->user) == 0) {
+      int32_t len = strlen(pDb->name) + 1;
+      taosHashPut(pRsp->createdDbs, pDb->name, len, pDb->name, len);
+    }
+
+    sdbRelease(pSdb, pDb);
+  }
+
+  return 0;
+}
+
 static int32_t mndProcessGetUserAuthReq(SNodeMsg *pReq) {
   SMnode         *pMnode = pReq->pNode;
   int32_t         code = -1;
@@ -596,25 +640,9 @@ static int32_t mndProcessGetUserAuthReq(SNodeMsg *pReq) {
     goto _OVER;
   }
 
-  memcpy(authRsp.user, pUser->user, TSDB_USER_LEN);
+  code = mndSetUserAuthRsp(pMnode, pUser, &authRsp);
-  authRsp.superAuth = pUser->superUser;
+  if (code) {
-  authRsp.readDbs = mndDupDbHash(pUser->readDbs);
+    goto _OVER;
-  authRsp.writeDbs = mndDupDbHash(pUser->writeDbs);
-
-  SSdb *pSdb = pMnode->pSdb;
-  void *pIter = NULL;
-  while (1) {
-    SDbObj *pDb = NULL;
-    pIter = sdbFetch(pSdb, SDB_DB, pIter, (void **)&pDb);
-    if (pIter == NULL) break;
-
-    if (strcmp(pDb->createUser, pUser->user) == 0) {
-      int32_t len = strlen(pDb->name) + 1;
-      taosHashPut(authRsp.readDbs, pDb->name, len, pDb->name, len);
-      taosHashPut(authRsp.writeDbs, pDb->name, len, pDb->name, len);
-    }
-
-    sdbRelease(pSdb, pDb);
   }
 
   int32_t contLen = tSerializeSGetUserAuthRsp(NULL, 0, &authRsp);
@@ -631,6 +659,7 @@ static int32_t mndProcessGetUserAuthReq(SNodeMsg *pReq) {
   code = 0;
 
 _OVER:
+  
   mndReleaseUser(pMnode, pUser);
   tFreeSGetUserAuthRsp(&authRsp);
 
@@ -681,3 +710,72 @@ static void mndCancelGetNextUser(SMnode *pMnode, void *pIter) {
   SSdb *pSdb = pMnode->pSdb;
   sdbCancelFetch(pSdb, pIter);
 }
+
+int32_t mndValidateUserAuthInfo(SMnode *pMnode, SUserAuthVersion *pUsers, int32_t numOfUses, void **ppRsp, int32_t *pRspLen) {
+  SUserAuthBatchRsp batchRsp = {0};
+  batchRsp.pArray = taosArrayInit(numOfUses, sizeof(SGetUserAuthRsp));
+  if (batchRsp.pArray == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
+
+  int32_t code = 0;
+  for (int32_t i = 0; i < numOfUses; ++i) {
+    SUserObj *pUser = mndAcquireUser(pMnode, pUsers[i].user);
+    if (pUser == NULL) {
+      mError("user:%s, failed to auth user since %s", pUsers[i].user, terrstr());
+      continue;
+    }
+
+    if (pUser->authVersion <= pUsers[i].version) {
+      mndReleaseUser(pMnode, pUser);
+      continue;
+    }
+    
+    SGetUserAuthRsp rsp = {0};
+    code = mndSetUserAuthRsp(pMnode, pUser, &rsp);
+    if (code) {
+      mndReleaseUser(pMnode, pUser);
+      tFreeSGetUserAuthRsp(&rsp);
+      goto _OVER;
+    }
+
+
+    taosArrayPush(batchRsp.pArray, &rsp);
+    mndReleaseUser(pMnode, pUser);
+  }
+
+  if (taosArrayGetSize(batchRsp.pArray) <= 0) {
+    *ppRsp = NULL;
+    *pRspLen = 0;
+    
+    tFreeSUserAuthBatchRsp(&batchRsp);
+    return 0;
+  }
+
+  int32_t rspLen = tSerializeSUserAuthBatchRsp(NULL, 0, &batchRsp);
+  void   *pRsp = taosMemoryMalloc(rspLen);
+  if (pRsp == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    tFreeSUserAuthBatchRsp(&batchRsp);
+    return -1;
+  }
+  tSerializeSUserAuthBatchRsp(pRsp, rspLen, &batchRsp);
+
+  *ppRsp = pRsp;
+  *pRspLen = rspLen;
+
+  tFreeSUserAuthBatchRsp(&batchRsp);
+  return 0;
+
+_OVER:
+
+  *ppRsp = NULL;
+  *pRspLen = 0;
+  
+  tFreeSUserAuthBatchRsp(&batchRsp);
+  return code;
+}
+
+
+

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

@@ -21,8 +21,8 @@
 #include "mndShow.h"
 #include "mndTrans.h"
 
-#define TSDB_VGROUP_VER_NUMBER   1
+#define VGROUP_VER_NUMBER   1
-#define TSDB_VGROUP_RESERVE_SIZE 64
+#define VGROUP_RESERVE_SIZE 64
 
 static SSdbRow *mndVgroupActionDecode(SSdbRaw *pRaw);
 static int32_t  mndVgroupActionInsert(SSdb *pSdb, SVgObj *pVgroup);
@@ -34,19 +34,21 @@ static int32_t mndProcessAlterVnodeRsp(SNodeMsg *pRsp);
 static int32_t mndProcessDropVnodeRsp(SNodeMsg *pRsp);
 static int32_t mndProcessCompactVnodeRsp(SNodeMsg *pRsp);
 
-static int32_t mndRetrieveVgroups(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows);
+static int32_t mndRetrieveVgroups(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
 static void    mndCancelGetNextVgroup(SMnode *pMnode, void *pIter);
-static int32_t mndRetrieveVnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows);
+static int32_t mndRetrieveVnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
 static void    mndCancelGetNextVnode(SMnode *pMnode, void *pIter);
 
 int32_t mndInitVgroup(SMnode *pMnode) {
-  SSdbTable table = {.sdbType = SDB_VGROUP,
+  SSdbTable table = {
+      .sdbType = SDB_VGROUP,
       .keyType = SDB_KEY_INT32,
       .encodeFp = (SdbEncodeFp)mndVgroupActionEncode,
       .decodeFp = (SdbDecodeFp)mndVgroupActionDecode,
       .insertFp = (SdbInsertFp)mndVgroupActionInsert,
       .updateFp = (SdbUpdateFp)mndVgroupActionUpdate,
-                     .deleteFp = (SdbDeleteFp)mndVgroupActionDelete};
+      .deleteFp = (SdbDeleteFp)mndVgroupActionDelete,
+  };
 
   mndSetMsgHandle(pMnode, TDMT_DND_CREATE_VNODE_RSP, mndProcessCreateVnodeRsp);
   mndSetMsgHandle(pMnode, TDMT_VND_ALTER_VNODE_RSP, mndProcessAlterVnodeRsp);
@@ -66,29 +68,29 @@ void mndCleanupVgroup(SMnode *pMnode) {}
 SSdbRaw *mndVgroupActionEncode(SVgObj *pVgroup) {
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
-  SSdbRaw *pRaw = sdbAllocRaw(SDB_VGROUP, TSDB_VGROUP_VER_NUMBER, sizeof(SVgObj) + TSDB_VGROUP_RESERVE_SIZE);
+  SSdbRaw *pRaw = sdbAllocRaw(SDB_VGROUP, VGROUP_VER_NUMBER, sizeof(SVgObj) + VGROUP_RESERVE_SIZE);
-  if (pRaw == NULL) goto VG_ENCODE_OVER;
+  if (pRaw == NULL) goto _OVER;
 
   int32_t dataPos = 0;
-  SDB_SET_INT32(pRaw, dataPos, pVgroup->vgId, VG_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pVgroup->vgId, _OVER)
-  SDB_SET_INT64(pRaw, dataPos, pVgroup->createdTime, VG_ENCODE_OVER)
+  SDB_SET_INT64(pRaw, dataPos, pVgroup->createdTime, _OVER)
-  SDB_SET_INT64(pRaw, dataPos, pVgroup->updateTime, VG_ENCODE_OVER)
+  SDB_SET_INT64(pRaw, dataPos, pVgroup->updateTime, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pVgroup->version, VG_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pVgroup->version, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pVgroup->hashBegin, VG_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pVgroup->hashBegin, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pVgroup->hashEnd, VG_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pVgroup->hashEnd, _OVER)
-  SDB_SET_BINARY(pRaw, dataPos, pVgroup->dbName, TSDB_DB_FNAME_LEN, VG_ENCODE_OVER)
+  SDB_SET_BINARY(pRaw, dataPos, pVgroup->dbName, TSDB_DB_FNAME_LEN, _OVER)
-  SDB_SET_INT64(pRaw, dataPos, pVgroup->dbUid, VG_ENCODE_OVER)
+  SDB_SET_INT64(pRaw, dataPos, pVgroup->dbUid, _OVER)
-  SDB_SET_INT8(pRaw, dataPos, pVgroup->replica, VG_ENCODE_OVER)
+  SDB_SET_INT8(pRaw, dataPos, pVgroup->replica, _OVER)
   for (int8_t i = 0; i < pVgroup->replica; ++i) {
     SVnodeGid *pVgid = &pVgroup->vnodeGid[i];
-    SDB_SET_INT32(pRaw, dataPos, pVgid->dnodeId, VG_ENCODE_OVER)
+    SDB_SET_INT32(pRaw, dataPos, pVgid->dnodeId, _OVER)
   }
-  SDB_SET_RESERVE(pRaw, dataPos, TSDB_VGROUP_RESERVE_SIZE, VG_ENCODE_OVER)
+  SDB_SET_RESERVE(pRaw, dataPos, VGROUP_RESERVE_SIZE, _OVER)
-  SDB_SET_DATALEN(pRaw, dataPos, VG_ENCODE_OVER)
+  SDB_SET_DATALEN(pRaw, dataPos, _OVER)
 
   terrno = 0;
 
-VG_ENCODE_OVER:
+_OVER:
   if (terrno != 0) {
     mError("vgId:%d, failed to encode to raw:%p since %s", pVgroup->vgId, pRaw, terrstr());
     sdbFreeRaw(pRaw);
@@ -103,41 +105,41 @@ SSdbRow *mndVgroupActionDecode(SSdbRaw *pRaw) {
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
   int8_t sver = 0;
-  if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto VG_DECODE_OVER;
+  if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto _OVER;
 
-  if (sver != TSDB_VGROUP_VER_NUMBER) {
+  if (sver != VGROUP_VER_NUMBER) {
     terrno = TSDB_CODE_SDB_INVALID_DATA_VER;
-    goto VG_DECODE_OVER;
+    goto _OVER;
   }
 
   SSdbRow *pRow = sdbAllocRow(sizeof(SVgObj));
-  if (pRow == NULL) goto VG_DECODE_OVER;
+  if (pRow == NULL) goto _OVER;
 
   SVgObj *pVgroup = sdbGetRowObj(pRow);
-  if (pVgroup == NULL) goto VG_DECODE_OVER;
+  if (pVgroup == NULL) goto _OVER;
 
   int32_t dataPos = 0;
-  SDB_GET_INT32(pRaw, dataPos, &pVgroup->vgId, VG_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pVgroup->vgId, _OVER)
-  SDB_GET_INT64(pRaw, dataPos, &pVgroup->createdTime, VG_DECODE_OVER)
+  SDB_GET_INT64(pRaw, dataPos, &pVgroup->createdTime, _OVER)
-  SDB_GET_INT64(pRaw, dataPos, &pVgroup->updateTime, VG_DECODE_OVER)
+  SDB_GET_INT64(pRaw, dataPos, &pVgroup->updateTime, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pVgroup->version, VG_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pVgroup->version, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pVgroup->hashBegin, VG_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pVgroup->hashBegin, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pVgroup->hashEnd, VG_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pVgroup->hashEnd, _OVER)
-  SDB_GET_BINARY(pRaw, dataPos, pVgroup->dbName, TSDB_DB_FNAME_LEN, VG_DECODE_OVER)
+  SDB_GET_BINARY(pRaw, dataPos, pVgroup->dbName, TSDB_DB_FNAME_LEN, _OVER)
-  SDB_GET_INT64(pRaw, dataPos, &pVgroup->dbUid, VG_DECODE_OVER)
+  SDB_GET_INT64(pRaw, dataPos, &pVgroup->dbUid, _OVER)
-  SDB_GET_INT8(pRaw, dataPos, &pVgroup->replica, VG_DECODE_OVER)
+  SDB_GET_INT8(pRaw, dataPos, &pVgroup->replica, _OVER)
   for (int8_t i = 0; i < pVgroup->replica; ++i) {
     SVnodeGid *pVgid = &pVgroup->vnodeGid[i];
-    SDB_GET_INT32(pRaw, dataPos, &pVgid->dnodeId, VG_DECODE_OVER)
+    SDB_GET_INT32(pRaw, dataPos, &pVgid->dnodeId, _OVER)
     if (pVgroup->replica == 1) {
       pVgid->role = TAOS_SYNC_STATE_LEADER;
     }
   }
-  SDB_GET_RESERVE(pRaw, dataPos, TSDB_VGROUP_RESERVE_SIZE, VG_DECODE_OVER)
+  SDB_GET_RESERVE(pRaw, dataPos, VGROUP_RESERVE_SIZE, _OVER)
 
   terrno = 0;
 
-VG_DECODE_OVER:
+_OVER:
   if (terrno != 0) {
     mError("vgId:%d, failed to decode from raw:%p since %s", pVgroup->vgId, pRaw, terrstr());
     taosMemoryFreeClear(pRow);
@@ -254,6 +256,68 @@ void *mndBuildCreateVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVg
   return pReq;
 }
 
+void *mndBuildAlterVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen) {
+  SAlterVnodeReq alterReq = {0};
+  alterReq.vgVersion = pVgroup->version;
+  alterReq.buffer = pDb->cfg.buffer;
+  alterReq.pages = pDb->cfg.pages;
+  alterReq.pageSize = pDb->cfg.pageSize;
+  alterReq.daysPerFile = pDb->cfg.daysPerFile;
+  alterReq.daysToKeep0 = pDb->cfg.daysToKeep0;
+  alterReq.daysToKeep1 = pDb->cfg.daysToKeep1;
+  alterReq.daysToKeep2 = pDb->cfg.daysToKeep2;
+  alterReq.fsyncPeriod = pDb->cfg.fsyncPeriod;
+  alterReq.walLevel = pDb->cfg.walLevel;
+  alterReq.strict = pDb->cfg.strict;
+  alterReq.cacheLastRow = pDb->cfg.cacheLastRow;
+  alterReq.replica = pVgroup->replica;
+  alterReq.selfIndex = -1;
+
+  for (int32_t v = 0; v < pVgroup->replica; ++v) {
+    SReplica  *pReplica = &alterReq.replicas[v];
+    SVnodeGid *pVgid = &pVgroup->vnodeGid[v];
+    SDnodeObj *pVgidDnode = mndAcquireDnode(pMnode, pVgid->dnodeId);
+    if (pVgidDnode == NULL) {
+      return NULL;
+    }
+
+    pReplica->id = pVgidDnode->id;
+    pReplica->port = pVgidDnode->port;
+    memcpy(pReplica->fqdn, pVgidDnode->fqdn, TSDB_FQDN_LEN);
+    mndReleaseDnode(pMnode, pVgidDnode);
+
+    if (pDnode->id == pVgid->dnodeId) {
+      alterReq.selfIndex = v;
+    }
+  }
+
+  if (alterReq.selfIndex == -1) {
+    terrno = TSDB_CODE_MND_APP_ERROR;
+    return NULL;
+  }
+
+  int32_t contLen = tSerializeSAlterVnodeReq(NULL, 0, &alterReq);
+  if (contLen < 0) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
+  contLen += +sizeof(SMsgHead);
+
+  void *pReq = taosMemoryMalloc(contLen);
+  if (pReq == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
+
+  SMsgHead *pHead = pReq;
+  pHead->contLen = htonl(contLen);
+  pHead->vgId = htonl(pVgroup->vgId);
+
+  tSerializeSAlterVnodeReq((char *)pReq + sizeof(SMsgHead), contLen, &alterReq);
+  *pContLen = contLen;
+  return pReq;
+}
+
 void *mndBuildDropVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen) {
   SDropVnodeReq dropReq = {0};
   dropReq.dnodeId = pDnode->id;
@@ -372,12 +436,12 @@ int32_t mndAllocVgroup(SMnode *pMnode, SDbObj *pDb, SVgObj **ppVgroups) {
   pVgroups = taosMemoryCalloc(pDb->cfg.numOfVgroups, sizeof(SVgObj));
   if (pVgroups == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
-    goto ALLOC_VGROUP_OVER;
+    goto _OVER;
   }
 
   pArray = mndBuildDnodesArray(pMnode);
   if (pArray == NULL) {
-    goto ALLOC_VGROUP_OVER;
+    goto _OVER;
   }
 
   mDebug("db:%s, total %d dnodes used to create %d vgroups (%d vnodes)", pDb->name, (int32_t)taosArrayGetSize(pArray),
@@ -410,7 +474,7 @@ int32_t mndAllocVgroup(SMnode *pMnode, SDbObj *pDb, SVgObj **ppVgroups) {
 
     if (mndGetAvailableDnode(pMnode, pVgroup, pArray) != 0) {
       terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;
-      goto ALLOC_VGROUP_OVER;
+      goto _OVER;
     }
 
     allocedVgroups++;
@@ -421,7 +485,7 @@ int32_t mndAllocVgroup(SMnode *pMnode, SDbObj *pDb, SVgObj **ppVgroups) {
 
   mDebug("db:%s, %d vgroups is alloced, replica:%d", pDb->name, pDb->cfg.numOfVgroups, pDb->cfg.replications);
 
-ALLOC_VGROUP_OVER:
+_OVER:
   if (code != 0) taosMemoryFree(pVgroups);
   taosArrayDestroy(pArray);
   return code;
@@ -492,7 +556,7 @@ static int32_t mndGetVgroupMaxReplica(SMnode *pMnode, char *dbName, int8_t *pRep
   return 0;
 }
 
-static int32_t mndRetrieveVgroups(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows) {
+static int32_t mndRetrieveVgroups(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
   SMnode *pMnode = pReq->pNode;
   SSdb   *pSdb = pMnode->pSdb;
   int32_t numOfRows = 0;
@@ -533,7 +597,6 @@ static int32_t mndRetrieveVgroups(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock*
 
     // default 3 replica
     for (int32_t i = 0; i < 3; ++i) {
-
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
       if (i < pVgroup->replica) {
         colDataAppend(pColInfo, numOfRows, (const char *)&pVgroup->vnodeGid[i].dnodeId, false);
@@ -597,13 +660,12 @@ int32_t mndGetVnodesNum(SMnode *pMnode, int32_t dnodeId) {
   return numOfVnodes;
 }
 
-static int32_t mndRetrieveVnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows) {
+static int32_t mndRetrieveVnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
   SMnode *pMnode = pReq->pNode;
   SSdb   *pSdb = pMnode->pSdb;
   int32_t numOfRows = 0;
   SVgObj *pVgroup = NULL;
   int32_t cols = 0;
-//  int32_t dnodeId = pShow->replica;
 
   while (numOfRows < rows) {
     pShow->pIter = sdbFetch(pSdb, SDB_VGROUP, pShow->pIter, (void **)&pVgroup);

source/dnode/mnode/impl/test/func/func.cpp

@@ -24,6 +24,7 @@ class MndTestFunc : public ::testing::Test {
 
   void SetCode(SCreateFuncReq* pReq, const char* pCode, int32_t size);
   void SetComment(SCreateFuncReq* pReq, const char* pComment);
+  void SetBufSize(SCreateFuncReq* pReq, int32_t size);
 };
 
 Testbase MndTestFunc::test;
@@ -40,6 +41,10 @@ void MndTestFunc::SetComment(SCreateFuncReq* pReq, const char* pComment) {
   strcpy(pReq->pComment, pComment);
 }
 
+void MndTestFunc::SetBufSize(SCreateFuncReq* pReq, int32_t size) {
+  pReq->bufSize = size;
+}
+
 TEST_F(MndTestFunc, 01_Show_Func) {
   test.SendShowReq(TSDB_MGMT_TABLE_FUNC, "user_functions", "");
   EXPECT_EQ(test.GetShowRows(), 0);
@@ -96,6 +101,7 @@ TEST_F(MndTestFunc, 02_Create_Func) {
     strcpy(createReq.name, "f1");
     SetCode(&createReq, "code1", 6);
     SetComment(&createReq, "comment1");
+    SetBufSize(&createReq, -1);
 
     int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq);
     void*   pReq = rpcMallocCont(contLen);

source/dnode/vnode/CMakeLists.txt

@@ -30,6 +30,7 @@ target_sources(
     "src/tsdb/tsdbFS.c"
     "src/tsdb/tsdbOpen.c"
     "src/tsdb/tsdbMemTable.c"
+    "src/tsdb/tsdbMemTable2.c"
     "src/tsdb/tsdbRead.c"
     "src/tsdb/tsdbReadImpl.c"
     "src/tsdb/tsdbSma.c"

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

@@ -40,7 +40,6 @@ typedef struct STable        STable;
 
 int  tsdbMemTableCreate(STsdb *pTsdb, STsdbMemTable **ppMemTable);
 void tsdbMemTableDestroy(STsdb *pTsdb, STsdbMemTable *pMemTable);
-int  tsdbInsertTableData(STsdb *pTsdb, SSubmitMsgIter *pMsgIter, SSubmitBlk *pBlock, int32_t *pAffectedRows);
 int  tsdbLoadDataFromCache(STable *pTable, SSkipListIterator *pIter, TSKEY maxKey, int maxRowsToRead, SDataCols *pCols,
                            TKEY *filterKeys, int nFilterKeys, bool keepDup, SMergeInfo *pMergeInfo);
 

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

@@ -100,6 +100,7 @@ int32_t      tsdbUpdateSmaWindow(STsdb* pTsdb, SSubmitReq* pMsg, int64_t version
 int32_t      tsdbCreateTSma(STsdb* pTsdb, char* pMsg);
 int32_t      tsdbInsertTSmaData(STsdb* pTsdb, int64_t indexUid, const char* msg);
 int          tsdbInsertData(STsdb* pTsdb, int64_t version, SSubmitReq* pMsg, SSubmitRsp* pRsp);
+int          tsdbInsertTableData(STsdb* pTsdb, SSubmitMsgIter* pMsgIter, SSubmitBlk* pBlock, int32_t* pAffectedRows);
 tsdbReaderT* tsdbQueryTables(SVnode* pVnode, SQueryTableDataCond* pCond, STableGroupInfo* groupList, uint64_t qId,
                              uint64_t taskId);
 tsdbReaderT  tsdbQueryCacheLastT(STsdb* tsdb, SQueryTableDataCond* pCond, STableGroupInfo* groupList, uint64_t qId,
@@ -125,7 +126,6 @@ int32_t tsdbUpdateTbUidList(STsdb* pTsdb, STbUidStore* pUidStore);
 void    tsdbUidStoreDestory(STbUidStore* pStore);
 void*   tsdbUidStoreFree(STbUidStore* pStore);
 int32_t tsdbTriggerRSma(STsdb* pTsdb, void* pMsg, int32_t inputType);
-int32_t tsdbProcessSubmitReq(STsdb* pTsdb, int64_t version, void* pReq);
 
 typedef struct {
   int8_t  streamType;  // sma or other

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

@@ -69,10 +69,6 @@ static void tsdbDestroyCommitIters(SCommitH *pCommith);
 static int  tsdbCommitToFile(SCommitH *pCommith, SDFileSet *pSet, int fid);
 static void tsdbResetCommitFile(SCommitH *pCommith);
 static int  tsdbSetAndOpenCommitFile(SCommitH *pCommith, SDFileSet *pSet, int fid);
-// static int  tsdbCommitMeta(STsdbRepo *pRepo);
-// static int  tsdbUpdateMetaRecord(STsdbFS *pfs, SMFile *pMFile, uint64_t uid, void *cont, int contLen, bool compact);
-// static int  tsdbDropMetaRecord(STsdbFS *pfs, SMFile *pMFile, uint64_t uid);
-// static int  tsdbCompactMetaFile(STsdbRepo *pRepo, STsdbFS *pfs, SMFile *pMFile);
 static int  tsdbCommitToTable(SCommitH *pCommith, int tid);
 static int  tsdbSetCommitTable(SCommitH *pCommith, STable *pTable);
 static int  tsdbComparKeyBlock(const void *arg1, const void *arg2);

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

@@ -191,9 +191,6 @@ int tsdbLoadDataFromCache(STable *pTable, SSkipListIterator *pIter, TSKEY maxKey
 }
 
 int tsdbInsertTableData(STsdb *pTsdb, SSubmitMsgIter *pMsgIter, SSubmitBlk *pBlock, int32_t *pAffectedRows) {
-  // STsdbMeta       *pMeta = pRepo->tsdbMeta;
-  // int32_t          points = 0;
-  // STable          *pTable = NULL;
   SSubmitBlkIter blkIter = {0};
   STsdbMemTable *pMemTable = pTsdb->mem;
   void          *tptr;
@@ -221,8 +218,9 @@ int tsdbInsertTableData(STsdb *pTsdb, SSubmitMsgIter *pMsgIter, SSubmitBlk *pBlo
   }
 
   // copy data to buffer pool
-  pBlkCopy = (SSubmitBlk *)vnodeBufPoolMalloc(pTsdb->mem->pPool, pMsgIter->dataLen + sizeof(*pBlock));
+  int32_t tlen = pMsgIter->dataLen + pMsgIter->schemaLen + sizeof(*pBlock);
-  memcpy(pBlkCopy, pBlock, pMsgIter->dataLen + sizeof(*pBlock));
+  pBlkCopy = (SSubmitBlk *)vnodeBufPoolMalloc(pTsdb->mem->pPool, tlen);
+  memcpy(pBlkCopy, pBlock, tlen);
 
   tInitSubmitBlkIter(pMsgIter, pBlkCopy, &blkIter);
   if (blkIter.row == NULL) return 0;
@@ -241,7 +239,7 @@ int tsdbInsertTableData(STsdb *pTsdb, SSubmitMsgIter *pMsgIter, SSubmitBlk *pBlo
   if (pMemTable->keyMin > keyMin) pMemTable->keyMin = keyMin;
   if (pMemTable->keyMax < keyMax) pMemTable->keyMax = keyMax;
 
-  (*pAffectedRows) += pMsgIter->numOfRows;
+  (*pAffectedRows) = pMsgIter->numOfRows;
 
   return 0;
 }

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

@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "tsdb.h"
+
+typedef struct SMemTable       SMemTable;
+typedef struct SMemData        SMemData;
+typedef struct SMemSkipList    SMemSkipList;
+typedef struct SMemSkipListCfg SMemSkipListCfg;
+
+struct SMemTable {
+  STsdb     *pTsdb;
+  TSKEY      minKey;
+  TSKEY      maxKey;
+  int64_t    minVer;
+  int64_t    maxVer;
+  int64_t    nRows;
+  int32_t    nHash;
+  int32_t    nBucket;
+  SMemData **pBuckets;
+};
+
+struct SMemSkipListCfg {
+  int8_t  maxLevel;
+  int32_t nKey;
+  int32_t nData;
+};
+
+struct SMemSkipList {
+  int8_t   level;
+  uint32_t seed;
+};
+
+struct SMemData {
+  SMemData    *pHashNext;
+  tb_uid_t     suid;
+  tb_uid_t     uid;
+  TSKEY        minKey;
+  TSKEY        maxKey;
+  int64_t      minVer;
+  int64_t      maxVer;
+  int64_t      nRows;
+  SMemSkipList sl;
+};
+
+// SMemTable
+int32_t tsdbMemTableCreate2(STsdb *pTsdb, SMemTable **ppMemTb) {
+  SMemTable *pMemTb = NULL;
+
+  pMemTb = taosMemoryCalloc(1, sizeof(*pMemTb));
+  if (pMemTb == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
+
+  pMemTb->pTsdb = pTsdb;
+  pMemTb->minKey = TSKEY_MAX;
+  pMemTb->maxKey = TSKEY_MIN;
+  pMemTb->minVer = -1;
+  pMemTb->maxVer = -1;
+  pMemTb->nRows = 0;
+  pMemTb->nHash = 0;
+  pMemTb->nBucket = 1024;
+  pMemTb->pBuckets = taosMemoryCalloc(pMemTb->nBucket, sizeof(*pMemTb->pBuckets));
+  if (pMemTb->pBuckets == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
+
+  *ppMemTb = pMemTb;
+  return 0;
+}
+
+int32_t tsdbMemTableDestroy2(STsdb *pTsdb, SMemTable *pMT) {
+  // TODO
+  return 0;
+}
+
+// SMemData
+
+// SMemSkipList

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

@@ -1962,6 +1962,21 @@ int32_t tsdbUpdateTbUidList(STsdb *pTsdb, STbUidStore *pStore) {
   return TSDB_CODE_SUCCESS;
 }
 
+static int32_t tsdbProcessSubmitReq(STsdb *pTsdb, int64_t version, void *pReq) {
+  if (!pReq) {
+    terrno = TSDB_CODE_INVALID_PTR;
+    return TSDB_CODE_FAILED;
+  }
+
+  SSubmitReq *pSubmitReq = (SSubmitReq *)pReq;
+
+  if (tsdbInsertData(pTsdb, version, pSubmitReq, NULL) < 0) {
+    return TSDB_CODE_FAILED;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
 static int32_t tsdbFetchSubmitReqSuids(SSubmitReq *pMsg, STbUidStore *pStore) {
   ASSERT(pMsg != NULL);
   SSubmitMsgIter msgIter = {0};

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

@@ -339,7 +339,7 @@ static int vnodeProcessCreateTbReq(SVnode *pVnode, int64_t version, void *pReq,
     goto _exit;
   }
 
-  rsp.pArray = taosArrayInit(sizeof(cRsp), req.nReqs);
+  rsp.pArray = taosArrayInit(req.nReqs, sizeof(cRsp));
   if (rsp.pArray == NULL) {
     rcode = -1;
     terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -450,7 +450,7 @@ static int vnodeProcessDropTbReq(SVnode *pVnode, int64_t version, void *pReq, in
   SCoder           coder = {0};
   int              ret;
 
-  pRsp->msgType = TDMT_VND_CREATE_STB_RSP;
+  pRsp->msgType = TDMT_VND_DROP_TABLE_RSP;
   pRsp->pCont = NULL;
   pRsp->contLen = 0;
   pRsp->code = TSDB_CODE_SUCCESS;
@@ -473,10 +473,14 @@ static int vnodeProcessDropTbReq(SVnode *pVnode, int64_t version, void *pReq, in
     /* code */
     ret = metaDropTable(pVnode->pMeta, version, pDropTbReq);
     if (ret < 0) {
+      if (pDropTbReq->igNotExists && terrno == TSDB_CODE_VND_TABLE_NOT_EXIST) {
         dropTbRsp.code = TSDB_CODE_SUCCESS;
       } else {
         dropTbRsp.code = terrno;
       }
+    } else {
+      dropTbRsp.code = TSDB_CODE_SUCCESS;
+    }
 
     taosArrayPush(rsp.pArray, &dropTbRsp);
   }
@@ -489,19 +493,54 @@ _exit:
 
 static int vnodeProcessSubmitReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp) {
   SSubmitReq    *pSubmitReq = (SSubmitReq *)pReq;
+  SSubmitMsgIter msgIter = {0};
+  SSubmitBlk    *pBlock;
   SSubmitRsp     rsp = {0};
+  SVCreateTbReq  createTbReq = {0};
+  SCoder         coder = {0};
+  int32_t        nRows;
 
   pRsp->code = 0;
 
   // handle the request
-  if (tsdbInsertData(pVnode->pTsdb, version, pSubmitReq, &rsp) < 0) {
+  if (tInitSubmitMsgIter(pSubmitReq, &msgIter) < 0) {
-    pRsp->code = terrno;
+    pRsp->code = TSDB_CODE_INVALID_MSG;
-    return -1;
+    goto _exit;
   }
 
-  // pRsp->msgType = TDMT_VND_SUBMIT_RSP;
+  for (;;) {
-  // vnodeProcessSubmitReq(pVnode, ptr, pRsp);
+    tGetSubmitMsgNext(&msgIter, &pBlock);
+    if (pBlock == NULL) break;
 
+    // create table for auto create table mode
+    if (msgIter.schemaLen > 0) {
+      tCoderInit(&coder, TD_LITTLE_ENDIAN, pBlock->data, msgIter.schemaLen, TD_DECODER);
+      if (tDecodeSVCreateTbReq(&coder, &createTbReq) < 0) {
+        pRsp->code = TSDB_CODE_INVALID_MSG;
+        tCoderClear(&coder);
+        goto _exit;
+      }
+
+      if (metaCreateTable(pVnode->pMeta, version, &createTbReq) < 0) {
+        if (terrno != TSDB_CODE_TDB_TABLE_ALREADY_EXIST) {
+          pRsp->code = terrno;
+          tCoderClear(&coder);
+          goto _exit;
+        }
+      }
+
+      tCoderClear(&coder);
+    }
+
+    if (tsdbInsertTableData(pVnode->pTsdb, &msgIter, pBlock, &nRows) < 0) {
+      pRsp->code = terrno;
+      goto _exit;
+    }
+
+    rsp.numOfRows += nRows;
+  }
+
+_exit:
   // encode the response (TODO)
   pRsp->pCont = rpcMallocCont(sizeof(SSubmitRsp));
   memcpy(pRsp->pCont, &rsp, sizeof(rsp));
@@ -511,18 +550,3 @@ static int vnodeProcessSubmitReq(SVnode *pVnode, int64_t version, void *pReq, in
 
   return 0;
 }
-
-int32_t tsdbProcessSubmitReq(STsdb *pTsdb, int64_t version, void *pReq) {
-  if (!pReq) {
-    terrno = TSDB_CODE_INVALID_PTR;
-    return TSDB_CODE_FAILED;
-  }
-
-  SSubmitReq *pSubmitReq = (SSubmitReq *)pReq;
-
-  if (tsdbInsertData(pTsdb, version, pSubmitReq, NULL) < 0) {
-    return TSDB_CODE_FAILED;
-  }
-
-  return TSDB_CODE_SUCCESS;
-}

source/libs/catalog/inc/catalogInt.h

@@ -54,6 +54,7 @@ enum {
   CTG_ACT_REMOVE_DB,
   CTG_ACT_REMOVE_STB,
   CTG_ACT_REMOVE_TBL,
+  CTG_ACT_UPDATE_USER,
   CTG_ACT_MAX
 };
 
@@ -95,8 +96,18 @@ typedef struct SCtgRentMgmt {
   SCtgRentSlot  *slots;
 } SCtgRentMgmt;
 
+typedef struct SCtgUserAuth {
+  int32_t   version;
+  SRWLatch  lock;
+  bool      superUser;
+  SHashObj *createdDbs;
+  SHashObj *readDbs;
+  SHashObj *writeDbs;
+} SCtgUserAuth;
+
 typedef struct SCatalog {
   uint64_t         clusterId;  
+  SHashObj        *userCache;    //key:user, value:SCtgUserAuth
   SHashObj        *dbCache;      //key:dbname, value:SCtgDBCache
   SCtgRentMgmt     dbRent;
   SCtgRentMgmt     stbRent;
@@ -124,6 +135,8 @@ typedef struct SCtgCacheStat {
   uint64_t vgMissNum;
   uint64_t tblHitNum;
   uint64_t tblMissNum;
+  uint64_t userHitNum;
+  uint64_t userMissNum;
 } SCtgCacheStat;
 
 typedef struct SCatalogStat {
@@ -169,6 +182,11 @@ typedef struct SCtgRemoveTblMsg {
   uint64_t dbId;
 } SCtgRemoveTblMsg;
 
+typedef struct SCtgUpdateUserMsg {
+  SCatalog* pCtg;
+  SGetUserAuthRsp userAuth;
+} SCtgUpdateUserMsg;
+
 
 typedef struct SCtgMetaAction {
   int32_t  act;
@@ -234,6 +252,8 @@ typedef struct SCtgAction {
 #define CTG_FLAG_SYS_DB       0x8
 #define CTG_FLAG_FORCE_UPDATE 0x10
 
+#define CTG_FLAG_SET(_flag, _v) ((_flag) |= (_v))
+
 #define CTG_FLAG_IS_STB(_flag) ((_flag) & CTG_FLAG_STB)
 #define CTG_FLAG_IS_NOT_STB(_flag) ((_flag) & CTG_FLAG_NOT_STB)
 #define CTG_FLAG_IS_UNKNOWN_STB(_flag) ((_flag) & CTG_FLAG_UNKNOWN_STB)

source/libs/catalog/src/catalog.c

@@ -24,6 +24,7 @@ int32_t ctgActUpdateTbl(SCtgMetaAction *action);
 int32_t ctgActRemoveDB(SCtgMetaAction *action);
 int32_t ctgActRemoveStb(SCtgMetaAction *action);
 int32_t ctgActRemoveTbl(SCtgMetaAction *action);
+int32_t ctgActUpdateUser(SCtgMetaAction *action);
 
 extern SCtgDebug gCTGDebug;
 SCatalogMgmt gCtgMgmt = {0};
@@ -51,6 +52,11 @@ SCtgAction gCtgAction[CTG_ACT_MAX] = {{
                             CTG_ACT_REMOVE_TBL,
                             "remove tbMeta",
                             ctgActRemoveTbl
+                          },
+                          {
+                            CTG_ACT_UPDATE_USER,
+                            "update user",
+                            ctgActUpdateUser
                           }
 };
 
@@ -357,6 +363,31 @@ _return:
   CTG_RET(code);
 }
 
+int32_t ctgPushUpdateUserMsgInQueue(SCatalog* pCtg, SGetUserAuthRsp *pAuth, bool syncReq) {
+  int32_t code = 0;
+  SCtgMetaAction action= {.act = CTG_ACT_UPDATE_USER, .syncReq = syncReq};
+  SCtgUpdateUserMsg *msg = taosMemoryMalloc(sizeof(SCtgUpdateUserMsg));
+  if (NULL == msg) {
+    ctgError("malloc %d failed", (int32_t)sizeof(SCtgUpdateUserMsg));
+    CTG_ERR_RET(TSDB_CODE_CTG_MEM_ERROR);
+  }
+
+  msg->pCtg = pCtg;
+  msg->userAuth = *pAuth;
+
+  action.data = msg;
+
+  CTG_ERR_JRET(ctgPushAction(pCtg, &action));
+
+  return TSDB_CODE_SUCCESS;
+  
+_return:
+
+  tFreeSGetUserAuthRsp(pAuth);
+  taosMemoryFreeClear(msg);
+  
+  CTG_RET(code);
+}
 
 int32_t ctgAcquireVgInfo(SCatalog *pCtg, SCtgDBCache *dbCache, bool *inCache) {
   CTG_LOCK(CTG_READ, &dbCache->vgLock);
@@ -687,6 +718,43 @@ int32_t ctgGetUdfInfoFromMnode(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEp
   return TSDB_CODE_SUCCESS;
 }
 
+int32_t ctgGetUserDbAuthFromMnode(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const char *user, SGetUserAuthRsp *authRsp) {
+  char *msg = NULL;
+  int32_t msgLen = 0;
+
+  ctgDebug("try to get user auth from mnode, user:%s", user);
+
+  int32_t code = queryBuildMsg[TMSG_INDEX(TDMT_MND_GET_USER_AUTH)]((void *)user, &msg, 0, &msgLen);
+  if (code) {
+    ctgError("Build get user auth msg failed, code:%x, db:%s", code, user);
+    CTG_ERR_RET(code);
+  }
+  
+  SRpcMsg rpcMsg = {
+      .msgType = TDMT_MND_GET_USER_AUTH,
+      .pCont   = msg,
+      .contLen = msgLen,
+  };
+
+  SRpcMsg rpcRsp = {0};
+
+  rpcSendRecv(pRpc, (SEpSet*)pMgmtEps, &rpcMsg, &rpcRsp);
+  if (TSDB_CODE_SUCCESS != rpcRsp.code) {
+    ctgError("error rsp for get user auth, error:%s, user:%s", tstrerror(rpcRsp.code), user);
+    CTG_ERR_RET(rpcRsp.code);
+  }
+
+  code = queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_GET_USER_AUTH)](authRsp, rpcRsp.pCont, rpcRsp.contLen);
+  if (code) {
+    ctgError("Process get user auth rsp failed, code:%x, user:%s", code, user);
+    CTG_ERR_RET(code);
+  }
+
+  ctgDebug("Got user auth from mnode, user:%s", user);
+
+  return TSDB_CODE_SUCCESS;
+}
+
 
 int32_t ctgIsTableMetaExistInCache(SCatalog* pCtg, char *dbFName, char* tbName, int32_t *exist) {
   if (NULL == pCtg->dbCache) {
@@ -859,6 +927,55 @@ int32_t ctgGetTableTypeFromCache(SCatalog* pCtg, const char* dbFName, const char
   return TSDB_CODE_SUCCESS;
 }
 
+int32_t ctgChkAuthFromCache(SCatalog* pCtg, const char* user, const char* dbFName, AUTH_TYPE type, bool *inCache, bool *pass) {
+  if (NULL == pCtg->userCache) {
+    ctgDebug("empty user auth cache, user:%s", user);
+    goto _return;
+  }
+  
+  SCtgUserAuth *pUser = (SCtgUserAuth *)taosHashGet(pCtg->userCache, user, strlen(user));
+  if (NULL == pUser) {
+    ctgDebug("user not in cache, user:%s", user);
+    goto _return;
+  }
+
+  *inCache = true;
+
+  ctgDebug("Got user from cache, user:%s", user);
+  CTG_CACHE_STAT_ADD(userHitNum, 1);
+  
+  if (pUser->superUser) {
+    *pass = true;
+    return TSDB_CODE_SUCCESS;
+  }
+
+  CTG_LOCK(CTG_READ, &pUser->lock);
+  if (pUser->createdDbs && taosHashGet(pUser->createdDbs, dbFName, strlen(dbFName))) {
+    *pass = true;
+    CTG_UNLOCK(CTG_READ, &pUser->lock);
+    return TSDB_CODE_SUCCESS;
+  }
+  
+  if (pUser->readDbs && taosHashGet(pUser->readDbs, dbFName, strlen(dbFName)) && type == AUTH_TYPE_READ) {
+    *pass = true;
+  }
+  
+  if (pUser->writeDbs && taosHashGet(pUser->writeDbs, dbFName, strlen(dbFName)) && type == AUTH_TYPE_WRITE) {
+    *pass = true;
+  }
+
+  CTG_UNLOCK(CTG_READ, &pUser->lock);
+  
+  return TSDB_CODE_SUCCESS;
+
+_return:
+
+  *inCache = false;
+  CTG_CACHE_STAT_ADD(userMissNum, 1);
+  
+  return TSDB_CODE_SUCCESS;
+}
+
 int32_t ctgGetTableMetaFromMnodeImpl(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps, char *dbFName, char* tbName, STableMetaOutput* output) {
   SBuildTableMetaInput bInput = {.vgId = 0, .dbFName = dbFName, .tbName = tbName};
   char *msg = NULL;
@@ -1952,6 +2069,45 @@ _return:
   CTG_RET(code);
 }
 
+int32_t ctgChkAuth(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const char* user, const char* dbFName, AUTH_TYPE type, bool *pass) {
+  bool inCache = false;
+  int32_t code = 0;
+  
+  *pass = false;
+  
+  CTG_ERR_RET(ctgChkAuthFromCache(pCtg, user, dbFName, type, &inCache, pass));
+
+  if (inCache) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  SGetUserAuthRsp authRsp = {0};
+  CTG_ERR_RET(ctgGetUserDbAuthFromMnode(pCtg, pRpc, pMgmtEps, user, &authRsp));
+  
+  if (authRsp.superAuth) {
+    *pass = true;
+    goto _return;
+  }
+
+  if (authRsp.createdDbs && taosHashGet(authRsp.createdDbs, dbFName, strlen(dbFName))) {
+    *pass = true;
+    goto _return;
+  }
+
+  if (authRsp.readDbs && taosHashGet(authRsp.readDbs, dbFName, strlen(dbFName)) && type == AUTH_TYPE_READ) {
+    *pass = true;
+  }
+
+  if (authRsp.writeDbs && taosHashGet(authRsp.writeDbs, dbFName, strlen(dbFName)) && type == AUTH_TYPE_WRITE) {
+    *pass = true;
+  }
+
+_return:
+
+  ctgPushUpdateUserMsgInQueue(pCtg, &authRsp, false);
+
+  return TSDB_CODE_SUCCESS;
+}
 
 
 int32_t ctgActUpdateVg(SCtgMetaAction *action) {
@@ -2121,6 +2277,67 @@ _return:
   CTG_RET(code);
 }
 
+int32_t ctgActUpdateUser(SCtgMetaAction *action) {
+  int32_t code = 0;
+  SCtgUpdateUserMsg *msg = action->data;
+  SCatalog* pCtg = msg->pCtg;
+
+  if (NULL == pCtg->userCache) {
+    pCtg->userCache = taosHashInit(gCtgMgmt.cfg.maxUserCacheNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_ENTRY_LOCK);
+    if (NULL == pCtg->userCache) {
+      ctgError("taosHashInit %d user cache failed", gCtgMgmt.cfg.maxUserCacheNum);
+      CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY);
+    }
+  }
+  
+  SCtgUserAuth *pUser = (SCtgUserAuth *)taosHashGet(pCtg->userCache, msg->userAuth.user, strlen(msg->userAuth.user));
+  if (NULL == pUser) {
+    SCtgUserAuth userAuth = {0};
+
+    userAuth.version = msg->userAuth.version;
+    userAuth.superUser = msg->userAuth.superAuth;
+    userAuth.createdDbs = msg->userAuth.createdDbs;
+    userAuth.readDbs = msg->userAuth.readDbs;
+    userAuth.writeDbs = msg->userAuth.writeDbs;
+
+    if (taosHashPut(pCtg->userCache, msg->userAuth.user, strlen(msg->userAuth.user), &userAuth, sizeof(userAuth))) {
+      ctgError("taosHashPut user %s to cache failed", msg->userAuth.user);
+      CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY);
+    }
+
+    return TSDB_CODE_SUCCESS;
+  }
+
+  pUser->version = msg->userAuth.version;
+
+  CTG_LOCK(CTG_WRITE, &pUser->lock);
+
+  taosHashCleanup(pUser->createdDbs);
+  pUser->createdDbs = msg->userAuth.createdDbs;
+  msg->userAuth.createdDbs = NULL;
+
+  taosHashCleanup(pUser->readDbs);
+  pUser->readDbs = msg->userAuth.readDbs;
+  msg->userAuth.readDbs = NULL;
+
+  taosHashCleanup(pUser->writeDbs);
+  pUser->writeDbs = msg->userAuth.writeDbs;
+  msg->userAuth.writeDbs = NULL;
+
+  CTG_UNLOCK(CTG_WRITE, &pUser->lock);
+
+_return:
+
+
+  taosHashCleanup(msg->userAuth.createdDbs);
+  taosHashCleanup(msg->userAuth.readDbs);
+  taosHashCleanup(msg->userAuth.writeDbs);
+ 
+  taosMemoryFreeClear(msg);
+  
+  CTG_RET(code);
+}
+
 
 void* ctgUpdateThreadFunc(void* param) {
   setThreadName("catalog");
@@ -2836,6 +3053,35 @@ int32_t catalogGetExpiredDBs(SCatalog* pCtg, SDbVgVersion **dbs, uint32_t *num)
   CTG_API_LEAVE(ctgMetaRentGet(&pCtg->dbRent, (void **)dbs, num, sizeof(SDbVgVersion)));
 }
 
+int32_t catalogGetExpiredUsers(SCatalog* pCtg, SUserAuthVersion **users, uint32_t *num) {
+  CTG_API_ENTER();
+  
+  if (NULL == pCtg || NULL == users || NULL == num) {
+    CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
+  }
+
+  *num = taosHashGetSize(pCtg->userCache);
+  if (*num > 0) {
+    *users = taosMemoryCalloc(*num, sizeof(SUserAuthVersion));
+    if (NULL == *users) {
+      ctgError("calloc %d userAuthVersion failed", *num);
+      CTG_API_LEAVE(TSDB_CODE_OUT_OF_MEMORY);
+    }
+  }
+
+  uint32_t i = 0;
+  SCtgUserAuth *pAuth = taosHashIterate(pCtg->userCache, NULL);
+  while (pAuth != NULL) {
+    void *key = taosHashGetKey(pAuth, NULL);
+    strncpy((*users)[i].user, key, sizeof((*users)[i].user));
+    (*users)[i].version = pAuth->version;
+    pAuth = taosHashIterate(pCtg->userCache, pAuth);
+  }
+
+  CTG_API_LEAVE(TSDB_CODE_SUCCESS);
+}
+
+
 int32_t catalogGetDBCfg(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const char* dbFName, SDbCfgInfo* pDbCfg) {
   CTG_API_ENTER();
   
@@ -2880,6 +3126,31 @@ _return:
   CTG_API_LEAVE(code);
 }
 
+int32_t catalogChkAuth(SCatalog* pCtg, void *pRpc, const SEpSet* pMgmtEps, const char* user, const char* dbFName, AUTH_TYPE type, bool *pass) {
+  CTG_API_ENTER();
+  
+  if (NULL == pCtg || NULL == pRpc || NULL == pMgmtEps || NULL == user || NULL == dbFName || NULL == pass) {
+    CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
+  }
+
+  int32_t code = 0;
+  CTG_ERR_JRET(ctgChkAuth(pCtg, pRpc, pMgmtEps, user, dbFName, type, pass));
+  
+_return:
+
+  CTG_API_LEAVE(code);
+}
+
+int32_t catalogUpdateUserAuthInfo(SCatalog* pCtg, SGetUserAuthRsp* pAuth) {
+  CTG_API_ENTER();
+
+  if (NULL == pCtg || NULL == pAuth) {
+    CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
+  }
+
+  CTG_API_LEAVE(ctgPushUpdateUserMsgInQueue(pCtg, pAuth, false));
+}
+
 
 void catalogDestroy(void) {
   qInfo("start to destroy catalog");

source/libs/executor/inc/executorimpl.h

@@ -87,9 +87,7 @@ typedef struct SResultInfo {  // TODO refactor
 typedef struct STableQueryInfo {
   TSKEY              lastKey;     // last check ts, todo remove it later
   SResultRowPosition pos;       // current active time window
-//  int32_t        groupIndex;  // group id in table list
 //  SVariant       tag;
-//  SResultRowInfo resInfo;     // result info
 } STableQueryInfo;
 
 typedef enum {
@@ -365,9 +363,10 @@ typedef struct STableScanInfo {
 typedef struct STagScanInfo {
   SColumnInfo     *pCols;
   SSDataBlock     *pRes;
-  int32_t      totalTables;
+  SArray          *pColMatchInfo;
   int32_t          curPos;
-  void        *pReader;
+  SReadHandle      readHandle;
+  STableGroupInfo *pTableGroups;
 } STagScanInfo;
 
 typedef struct SStreamBlockScanInfo {
@@ -579,9 +578,8 @@ typedef struct SSortOperatorInfo {
   uint32_t     sortBufSize;  // max buffer size for in-memory sort
   SArray*      pSortInfo;
   SSortHandle* pSortHandle;
-  SArray*      inputSlotMap;  // for index map from table scan output
+  SArray*      pColMatchInfo;  // for index map from table scan output
   int32_t      bufPageSize;
-//  int32_t      numOfRowsInRes;
 
   // TODO extact struct
   int64_t  startTs;       // sort start time
@@ -646,7 +644,7 @@ void    cleanupAggSup(SAggSupporter* pAggSup);
 void    destroyBasicOperatorInfo(void* param, int32_t numOfOutput);
 void    appendOneRowToDataBlock(SSDataBlock* pBlock, STupleHandle* pTupleHandle);
 
-SSDataBlock* getSortedBlockData(SSortHandle* pHandle, SSDataBlock* pDataBlock, int32_t capacity);
+SSDataBlock* getSortedBlockData(SSortHandle* pHandle, SSDataBlock* pDataBlock, int32_t capacity, SArray* pColMatchInfo);
 SSDataBlock* loadNextDataBlock(void* param);
 
 void setResultRowInitCtx(SResultRow* pResult, SqlFunctionCtx* pCtx, int32_t numOfOutput, int32_t* rowCellInfoOffset);
@@ -704,7 +702,7 @@ SOperatorInfo* createTimeSliceOperatorInfo(SOperatorInfo* downstream, SExprInfo*
                                            SSDataBlock* pResultBlock, SExecTaskInfo* pTaskInfo);
 
 SOperatorInfo* createJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, SExprInfo* pExprInfo, int32_t numOfCols, SSDataBlock* pResBlock, SNode* pOnCondition, SExecTaskInfo* pTaskInfo);
-SOperatorInfo* createTagScanOperatorInfo(void* pReaderHandle, SExprInfo* pExpr, int32_t numOfOutput, SExecTaskInfo* pTaskInfo);
+SOperatorInfo* createTagScanOperatorInfo(SReadHandle* pReadHandle, SExprInfo* pExpr, int32_t numOfOutput, SSDataBlock* pResBlock, SArray* pColMatchInfo, STableGroupInfo* pTableGroupInfo, SExecTaskInfo* pTaskInfo);
 
 #if 0
 SOperatorInfo* createTableSeqScanOperatorInfo(void* pTsdbReadHandle, STaskRuntimeEnv* pRuntimeEnv);
@@ -717,7 +715,6 @@ int32_t projectApplyFunctions(SExprInfo* pExpr, SSDataBlock* pResult, SSDataBloc
 
 void setInputDataBlock(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx, SSDataBlock* pBlock, int32_t order, bool createDummyCol);
 
-void finalizeQueryResult(SqlFunctionCtx* pCtx, int32_t numOfOutput);
 void copyTsColoum(SSDataBlock* pRes, SqlFunctionCtx* pCtx, int32_t numOfOutput);
 
 STableQueryInfo* createTableQueryInfo(void* buf, STimeWindow win);

source/libs/executor/inc/tsort.h

@@ -117,18 +117,25 @@ STupleHandle* tsortNextTuple(SSortHandle* pHandle);
 /**
  *
  * @param pHandle
- * @param colIndex
+ * @param colId
  * @return
  */
-bool tsortIsNullVal(STupleHandle* pVHandle, int32_t colIndex);
+bool tsortIsNullVal(STupleHandle* pVHandle, int32_t colId);
 
 /**
  *
  * @param pHandle
- * @param colIndex
+ * @param colId
  * @return
  */
-void* tsortGetValue(STupleHandle* pVHandle, int32_t colIndex);
+void* tsortGetValue(STupleHandle* pVHandle, int32_t colId);
+
+/**
+ *
+ * @param pSortHandle
+ * @return
+ */
+SSDataBlock* tsortGetSortedDataBlock(const SSortHandle* pSortHandle);
 
 #ifdef __cplusplus
 }

source/libs/executor/src/executorimpl.c

@@ -3520,7 +3520,7 @@ static SSDataBlock* doSortedMerge(SOperatorInfo* pOperator) {
   SExecTaskInfo*            pTaskInfo = pOperator->pTaskInfo;
   SSortedMergeOperatorInfo* pInfo = pOperator->info;
   if (pOperator->status == OP_RES_TO_RETURN) {
-    return getSortedBlockData(pInfo->pSortHandle, pInfo->binfo.pRes, pOperator->resultInfo.capacity);
+    return getSortedBlockData(pInfo->pSortHandle, pInfo->binfo.pRes, pOperator->resultInfo.capacity, NULL);
   }
 
   int32_t numOfBufPage = pInfo->sortBufSize / pInfo->bufPageSize;
@@ -4701,7 +4701,7 @@ static SArray* extractTableIdList(const STableGroupInfo* pTableGroupInfo);
 static SArray* extractColumnInfo(SNodeList* pNodeList);
 static SArray* extractColMatchInfo(SNodeList* pNodeList, SDataBlockDescNode* pOutputNodeList, int32_t* numOfOutputCols);
 
-static SArray* createSortInfo(SNodeList* pNodeList, SNodeList* pNodeListTarget);
+static SArray* createSortInfo(SNodeList* pNodeList);
 static SArray* createIndexMap(SNodeList* pNodeList);
 static SArray* extractPartitionColInfo(SNodeList* pNodeList);
 static int32_t initQueryTableDataCond(SQueryTableDataCond* pCond, const STableScanPhysiNode* pTableScanNode);
@@ -4739,7 +4739,6 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
       SSDataBlock* pResBlock = createResDataBlock(pScanPhyNode->node.pOutputDataBlockDesc);
 
       SQueryTableDataCond cond = {0};
-
       int32_t code = initQueryTableDataCond(&cond, pTableScanNode);
       if (code != TSDB_CODE_SUCCESS) {
         return NULL;
@@ -4783,6 +4782,25 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
           pHandle, pResBlock, &pScanNode->tableName, pScanNode->node.pConditions, pSysScanPhyNode->mgmtEpSet, colList,
           pTaskInfo, pSysScanPhyNode->showRewrite, pSysScanPhyNode->accountId);
       return pOperator;
+    } else if (QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN == type) {
+      STagScanPhysiNode* pScanPhyNode = (STagScanPhysiNode*) pPhyNode;
+      SSDataBlock* pResBlock = createResDataBlock(pScanPhyNode->node.pOutputDataBlockDesc);
+
+      int32_t  code =
+          doCreateTableGroup(pHandle->meta, pScanPhyNode->tableType, pScanPhyNode->uid, pTableGroupInfo, queryId, taskId);
+      if (code != TSDB_CODE_SUCCESS) {
+        return NULL;
+      }
+
+      int32_t num = 0;
+      SExprInfo* pExprInfo = createExprInfo(pScanPhyNode->pScanPseudoCols, NULL, &num);
+
+      int32_t numOfOutputCols = 0;
+      SArray* colList =
+          extractColMatchInfo(pScanPhyNode->pScanPseudoCols, pScanPhyNode->node.pOutputDataBlockDesc, &numOfOutputCols);
+
+      SOperatorInfo* pOperator = createTagScanOperatorInfo(pHandle, pExprInfo, num, pResBlock, colList, pTableGroupInfo, pTaskInfo);
+      return pOperator;
     } else {
       ASSERT(0);
     }
@@ -4852,16 +4870,16 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
     SSortPhysiNode* pSortPhyNode = (SSortPhysiNode*)pPhyNode;
 
     SSDataBlock* pResBlock = createResDataBlock(pPhyNode->pOutputDataBlockDesc);
-    SArray*      info = createSortInfo(pSortPhyNode->pSortKeys, pSortPhyNode->pTargets);
+    SArray*      info = createSortInfo(pSortPhyNode->pSortKeys);
-    SArray*      slotMap = createIndexMap(pSortPhyNode->pTargets);
 
     int32_t    numOfCols = 0;
-    SExprInfo* pExprInfo = NULL;
+    SExprInfo* pExprInfo = createExprInfo(pSortPhyNode->pExprs, NULL, &numOfCols);
-    if (pSortPhyNode->pExprs != NULL) {
-      pExprInfo = createExprInfo(pSortPhyNode->pExprs, NULL, &numOfCols);
-    }
 
-    pOptr = createSortOperatorInfo(ops[0], pResBlock, info, pExprInfo, numOfCols, slotMap, pTaskInfo);
+    int32_t numOfOutputCols = 0;
+    SArray* pColList =
+        extractColMatchInfo(pSortPhyNode->pTargets, pSortPhyNode->node.pOutputDataBlockDesc, &numOfOutputCols);
+
+    pOptr = createSortOperatorInfo(ops[0], pResBlock, info, pExprInfo, numOfCols, pColList, pTaskInfo);
   } else if (QUERY_NODE_PHYSICAL_PLAN_SESSION_WINDOW == type) {
     SSessionWinodwPhysiNode* pSessionNode = (SSessionWinodwPhysiNode*)pPhyNode;
 
@@ -5019,7 +5037,7 @@ SArray* extractPartitionColInfo(SNodeList* pNodeList) {
   return pList;
 }
 
-SArray* createSortInfo(SNodeList* pNodeList, SNodeList* pNodeListTarget) {
+SArray* createSortInfo(SNodeList* pNodeList) {
   size_t  numOfCols = LIST_LENGTH(pNodeList);
   SArray* pList = taosArrayInit(numOfCols, sizeof(SBlockOrderInfo));
   if (pList == NULL) {
@@ -5034,22 +5052,7 @@ SArray* createSortInfo(SNodeList* pNodeList, SNodeList* pNodeListTarget) {
     bi.nullFirst = (pSortKey->nullOrder == NULL_ORDER_FIRST);
 
     SColumnNode* pColNode = (SColumnNode*)pSortKey->pExpr;
-
+    bi.slotId = pColNode->slotId;
-    bool found = false;
-    for (int32_t j = 0; j < LIST_LENGTH(pNodeListTarget); ++j) {
-      STargetNode* pTarget = (STargetNode*)nodesListGetNode(pNodeListTarget, j);
-
-      SColumnNode* pColNodeT = (SColumnNode*)pTarget->pExpr;
-      if (pColNode->slotId == pColNodeT->slotId) {  // to find slotId in PhysiSort OutputDataBlockDesc
-        bi.slotId = pTarget->slotId;
-        found = true;
-        break;
-      }
-    }
-
-    if (!found) {
-      qError("sort slot id does not found");
-    }
     taosArrayPush(pList, &bi);
   }
 
@@ -5166,9 +5169,7 @@ tsdbReaderT doCreateDataReader(STableScanPhysiNode* pTableScanNode, SReadHandle*
   if (code != TSDB_CODE_SUCCESS) {
     goto _error;
   }
-#if 0
+
-  return tsdbQueryTables(pHandle->reader, &cond, pTableGroupInfo, queryId, taskId);
-#endif
   return tsdbQueryTables(pHandle->vnode, &cond, pTableGroupInfo, queryId, taskId);
 
 _error:

source/libs/executor/src/scanoperator.c

@@ -13,15 +13,16 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "ttime.h"
+#include <libs/function/function.h>
 #include "filter.h"
 #include "function.h"
 #include "functionMgt.h"
 #include "os.h"
 #include "querynodes.h"
+#include "systable.h"
 #include "tglobal.h"
 #include "tname.h"
-#include "systable.h"
+#include "ttime.h"
 
 #include "tdatablock.h"
 #include "tmsg.h"
@@ -1159,16 +1160,17 @@ SOperatorInfo* createSysTableScanOperatorInfo(void* readHandle, SSDataBlock* pRe
 }
 
 static SSDataBlock* doTagScan(SOperatorInfo* pOperator) {
-#if 0
   if (pOperator->status == OP_EXEC_DONE) {
     return NULL;
   }
 
+  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
+
+#if 0
   int32_t maxNumOfTables = (int32_t)pResultInfo->capacity;
 
   STagScanInfo *pInfo = pOperator->info;
   SSDataBlock  *pRes = pInfo->pRes;
-  *newgroup = false;
 
   int32_t count = 0;
   SArray* pa = GET_TABLEGROUP(pRuntimeEnv, 0);
@@ -1237,55 +1239,54 @@ static SSDataBlock* doTagScan(SOperatorInfo* pOperator) {
     pOperator->status = OP_EXEC_DONE;
     //qDebug("QInfo:0x%"PRIx64" create count(tbname) query, res:%d rows:1", GET_TASKID(pRuntimeEnv), count);
   } else {  // return only the tags|table name etc.
-    SExprInfo* pExprInfo = &pOperator->pExpr[0];  // todo use the column list instead of exprinfo
+#endif
 
-    count = 0;
+  STagScanInfo* pInfo = pOperator->info;
-    while(pInfo->curPos < pInfo->totalTables && count < maxNumOfTables) {
+  SExprInfo*    pExprInfo = &pOperator->pExpr[0];
-      int32_t i = pInfo->curPos++;
+  SSDataBlock*  pRes = pInfo->pRes;
 
-      STableQueryInfo* item = taosArrayGetP(pa, i);
+  SArray* pa = taosArrayGetP(pInfo->pTableGroups->pGroupList, 0);
 
-      char *data = NULL, *dst = NULL;
+  char        str[512] = {0};
-      int16_t type = 0, bytes = 0;
+  int32_t     count = 0;
-      for(int32_t j = 0; j < pOperator->numOfExprs; ++j) {
+  SMetaReader mr = {0};
-        // not assign value in case of user defined constant output column
-        if (TSDB_COL_IS_UD_COL(pExprInfo[j].base.pColumns->flag)) {
-          continue;
-        }
 
-        SColumnInfoData* pColInfo = taosArrayGet(pRes->pDataBlock, j);
+  while (pInfo->curPos < pInfo->pTableGroups->numOfTables && count < pOperator->resultInfo.capacity) {
-        type  = pExprInfo[j].base.resSchema.type;
+    STableKeyInfo* item = taosArrayGet(pa, pInfo->curPos);
-        bytes = pExprInfo[j].base.resSchema.bytes;
 
-        if (pExprInfo[j].base.pColumns->info.colId == TSDB_TBNAME_COLUMN_INDEX) {
+    for (int32_t j = 0; j < pOperator->numOfExprs; ++j) {
-          data = tsdbGetTableName(item->pTable);
+      SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId);
-        } else {
-          data = tsdbGetTableTagVal(item->pTable, pExprInfo[j].base.pColumns->info.colId, type, bytes);
-        }
 
-        dst  = pColInfo->pData + count * pExprInfo[j].base.resSchema.bytes;
+      // refactor later
-        doSetTagValueToResultBuf(dst, data, type, bytes);
+      if (fmIsScanPseudoColumnFunc(pExprInfo[j].pExpr->_function.functionId)) {
+        metaReaderInit(&mr, pInfo->readHandle.meta, 0);
+        metaGetTableEntryByUid(&mr, item->uid);
+
+        STR_TO_VARSTR(str, mr.me.name);
+        metaReaderClear(&mr);
+
+        colDataAppend(pDst, count, str, false);
+
+        //        data = tsdbGetTableTagVal(item->pTable, pExprInfo[j].base.pColumns->info.colId, type, bytes);
+        //        dst  = pColInfo->pData + count * pExprInfo[j].base.resSchema.bytes;
+        //        doSetTagValueToResultBuf(dst, data, type, bytes);
       }
 
       count += 1;
     }
 
-    if (pInfo->curPos >= pInfo->totalTables) {
+    if (++pInfo->curPos >= pInfo->pTableGroups->numOfTables) {
       pOperator->status = OP_EXEC_DONE;
     }
-
-    //qDebug("QInfo:0x%"PRIx64" create tag values results completed, rows:%d", GET_TASKID(pRuntimeEnv), count);
   }
 
+  // qDebug("QInfo:0x%"PRIx64" create tag values results completed, rows:%d", GET_TASKID(pRuntimeEnv), count);
   if (pOperator->status == OP_EXEC_DONE) {
-    setTaskStatus(pOperator->pRuntimeEnv, TASK_COMPLETED);
+    setTaskStatus(pTaskInfo, TASK_COMPLETED);
   }
 
   pRes->info.rows = count;
-  return (pRes->info.rows == 0)? NULL:pInfo->pRes;
+  return (pRes->info.rows == 0) ? NULL : pInfo->pRes;
-
-#endif
-  return TSDB_CODE_SUCCESS;
 }
 
 static void destroyTagScanOperatorInfo(void* param, int32_t numOfOutput) {
@@ -1293,14 +1294,18 @@ static void destroyTagScanOperatorInfo(void* param, int32_t numOfOutput) {
   pInfo->pRes = blockDataDestroy(pInfo->pRes);
 }
 
-SOperatorInfo* createTagScanOperatorInfo(void* readHandle, SExprInfo* pExpr, int32_t numOfOutput, SExecTaskInfo* pTaskInfo) {
+SOperatorInfo* createTagScanOperatorInfo(SReadHandle* pReadHandle, SExprInfo* pExpr, int32_t numOfOutput,
+                                         SSDataBlock* pResBlock, SArray* pColMatchInfo, STableGroupInfo* pTableGroupInfo, SExecTaskInfo* pTaskInfo) {
   STagScanInfo*  pInfo = taosMemoryCalloc(1, sizeof(STagScanInfo));
   SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
   if (pInfo == NULL || pOperator == NULL) {
     goto _error;
   }
 
-  pInfo->pReader          = readHandle;
+  pInfo->pTableGroups     = pTableGroupInfo;
+  pInfo->pColMatchInfo    = pColMatchInfo;
+  pInfo->pRes             = pResBlock;
+  pInfo->readHandle       = *pReadHandle;
   pInfo->curPos           = 0;
   pOperator->name         = "TagScanOperator";
   pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN;
@@ -1311,6 +1316,9 @@ SOperatorInfo* createTagScanOperatorInfo(void* readHandle, SExprInfo* pExpr, int
   pOperator->numOfExprs   = numOfOutput;
   pOperator->pTaskInfo    = pTaskInfo;
 
+  initResultSizeInfo(pOperator, 4096);
+  blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
+
   pOperator->fpSet =
       createOperatorFpSet(operatorDummyOpenFn, doTagScan, NULL, NULL, destroyTagScanOperatorInfo, NULL, NULL, NULL);
 

source/libs/executor/src/sortoperator.c

@@ -5,7 +5,7 @@ static SSDataBlock* doSort(SOperatorInfo* pOperator);
 static void destroyOrderOperatorInfo(void* param, int32_t numOfOutput);
 
 SOperatorInfo* createSortOperatorInfo(SOperatorInfo* downstream, SSDataBlock* pResBlock, SArray* pSortInfo, SExprInfo* pExprInfo, int32_t numOfCols,
-                                      SArray* pIndexMap, SExecTaskInfo* pTaskInfo) {
+                                      SArray* pColMatchColInfo, SExecTaskInfo* pTaskInfo) {
   SSortOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SSortOperatorInfo));
   SOperatorInfo*     pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
   int32_t            rowSize = pResBlock->info.rowSize;
@@ -20,17 +20,19 @@ SOperatorInfo* createSortOperatorInfo(SOperatorInfo* downstream, SSDataBlock* pR
   pInfo->binfo.pRes   = pResBlock;
 
   initResultSizeInfo(pOperator, 1024);
-  pInfo->bufPageSize  = rowSize < 1024 ? 1024 * 2 : rowSize * 2;  // there are headers, so pageSize = rowSize + header
 
-  pInfo->sortBufSize  = pInfo->bufPageSize * 16;  // TODO dynamic set the available sort buffer
   pInfo->pSortInfo    = pSortInfo;
-  pInfo->inputSlotMap = pIndexMap;
+  pInfo->pColMatchInfo= pColMatchColInfo;
   pOperator->name     = "SortOperator";
   pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_SORT;
   pOperator->blocking = true;
   pOperator->status   = OP_NOT_OPENED;
   pOperator->info     = pInfo;
 
+  // lazy evaluation for the following parameter since the input datablock is not known till now.
+//  pInfo->bufPageSize  = rowSize < 1024 ? 1024 * 2 : rowSize * 2;  // there are headers, so pageSize = rowSize + header
+//  pInfo->sortBufSize  = pInfo->bufPageSize * 16;  // TODO dynamic set the available sort buffer
+
   pOperator->pTaskInfo = pTaskInfo;
   pOperator->fpSet =
       createOperatorFpSet(operatorDummyOpenFn, doSort, NULL, NULL, destroyOrderOperatorInfo, NULL, NULL, NULL);
@@ -45,14 +47,12 @@ SOperatorInfo* createSortOperatorInfo(SOperatorInfo* downstream, SSDataBlock* pR
   return NULL;
 }
 
-// TODO merge aggregate super table
 void appendOneRowToDataBlock(SSDataBlock* pBlock, STupleHandle* pTupleHandle) {
   for (int32_t i = 0; i < pBlock->info.numOfCols; ++i) {
     SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, i);
-
     bool isNull = tsortIsNullVal(pTupleHandle, i);
     if (isNull) {
-      colDataAppend(pColInfo, pBlock->info.rows, NULL, true);
+      colDataAppendNULL(pColInfo, pBlock->info.rows);
     } else {
       char* pData = tsortGetValue(pTupleHandle, i);
       colDataAppend(pColInfo, pBlock->info.rows, pData, false);
@@ -62,11 +62,12 @@ void appendOneRowToDataBlock(SSDataBlock* pBlock, STupleHandle* pTupleHandle) {
   pBlock->info.rows += 1;
 }
 
-SSDataBlock* getSortedBlockData(SSortHandle* pHandle, SSDataBlock* pDataBlock, int32_t capacity) {
+SSDataBlock* getSortedBlockData(SSortHandle* pHandle, SSDataBlock* pDataBlock, int32_t capacity, SArray* pColMatchInfo) {
   blockDataCleanup(pDataBlock);
-  blockDataEnsureCapacity(pDataBlock, capacity);
+  ASSERT(taosArrayGetSize(pColMatchInfo) == pDataBlock->info.numOfCols);
 
-  blockDataEnsureCapacity(pDataBlock, capacity);
+  SSDataBlock* p = tsortGetSortedDataBlock(pHandle);
+  blockDataEnsureCapacity(p, capacity);
 
   while (1) {
     STupleHandle* pTupleHandle = tsortNextTuple(pHandle);
@@ -74,12 +75,32 @@ SSDataBlock* getSortedBlockData(SSortHandle* pHandle, SSDataBlock* pDataBlock, i
       break;
     }
 
-    appendOneRowToDataBlock(pDataBlock, pTupleHandle);
+    appendOneRowToDataBlock(p, pTupleHandle);
-    if (pDataBlock->info.rows >= capacity) {
+    if (p->info.rows >= capacity) {
       return pDataBlock;
     }
   }
 
+  if (p->info.rows > 0) {
+    int32_t numOfCols = taosArrayGetSize(pColMatchInfo);
+    for(int32_t i = 0; i < numOfCols; ++i) {
+      SColMatchInfo* pmInfo = taosArrayGet(pColMatchInfo, i);
+
+      for(int32_t j = 0; j < p->info.numOfCols; ++j) {
+        SColumnInfoData* pSrc = taosArrayGet(p->pDataBlock, j);
+        if (pSrc->info.colId == pmInfo->colId) {
+          SColumnInfoData* pDst = taosArrayGet(pDataBlock->pDataBlock, pmInfo->targetSlotId);
+          colDataAssign(pDst, pSrc, p->info.rows);
+          break;
+        }
+      }
+    }
+
+    pDataBlock->info.rows = p->info.rows;
+    pDataBlock->info.capacity = p->info.rows;
+  }
+
+  blockDataDestroy(p);
   return (pDataBlock->info.rows > 0) ? pDataBlock : NULL;
 }
 
@@ -106,16 +127,16 @@ SSDataBlock* doSort(SOperatorInfo* pOperator) {
   SSortOperatorInfo* pInfo = pOperator->info;
 
   if (pOperator->status == OP_RES_TO_RETURN) {
-    return getSortedBlockData(pInfo->pSortHandle, pInfo->binfo.pRes, pOperator->resultInfo.capacity);
+    return getSortedBlockData(pInfo->pSortHandle, pInfo->binfo.pRes, pOperator->resultInfo.capacity, pInfo->pColMatchInfo);
   }
 
-  int32_t numOfBufPage = pInfo->sortBufSize / pInfo->bufPageSize;
+//  pInfo->binfo.pRes is not equalled to the input datablock.
-  pInfo->pSortHandle = tsortCreateSortHandle(pInfo->pSortInfo, pInfo->inputSlotMap, SORT_SINGLESOURCE_SORT,
+//  int32_t numOfBufPage = pInfo->sortBufSize / pInfo->bufPageSize;
-                                             pInfo->bufPageSize, numOfBufPage, pInfo->binfo.pRes, pTaskInfo->id.str);
+  pInfo->pSortHandle = tsortCreateSortHandle(pInfo->pSortInfo, pInfo->pColMatchInfo, SORT_SINGLESOURCE_SORT,
+                                             -1, -1, NULL, pTaskInfo->id.str);
 
   tsortSetFetchRawDataFp(pInfo->pSortHandle, loadNextDataBlock, applyScalarFunction, pOperator);
 
-
   SSortSource* ps = taosMemoryCalloc(1, sizeof(SSortSource));
   ps->param = pOperator->pDownstream[0];
   tsortAddSource(pInfo->pSortHandle, ps);
@@ -127,7 +148,7 @@ SSDataBlock* doSort(SOperatorInfo* pOperator) {
   }
 
   pOperator->status = OP_RES_TO_RETURN;
-  return getSortedBlockData(pInfo->pSortHandle, pInfo->binfo.pRes, pOperator->resultInfo.capacity);
+  return getSortedBlockData(pInfo->pSortHandle, pInfo->binfo.pRes, pOperator->resultInfo.capacity, pInfo->pColMatchInfo);
 }
 
 void destroyOrderOperatorInfo(void* param, int32_t numOfOutput) {
@@ -135,5 +156,5 @@ void destroyOrderOperatorInfo(void* param, int32_t numOfOutput) {
   pInfo->binfo.pRes = blockDataDestroy(pInfo->binfo.pRes);
 
   taosArrayDestroy(pInfo->pSortInfo);
-  taosArrayDestroy(pInfo->inputSlotMap);
+  taosArrayDestroy(pInfo->pColMatchInfo);
 }

source/libs/executor/src/tsort.c

@@ -64,25 +64,8 @@ struct SSortHandle {
 
 static int32_t msortComparFn(const void *pLeft, const void *pRight, void *param);
 
-static SSDataBlock* createDataBlock_rv(SSchema* pSchema, int32_t numOfCols) {
+SSDataBlock* tsortGetSortedDataBlock(const SSortHandle* pSortHandle) {
-  SSDataBlock* pBlock = taosMemoryCalloc(1, sizeof(SSDataBlock));
+  return createOneDataBlock(pSortHandle->pDataBlock, false);
-  pBlock->pDataBlock = taosArrayInit(numOfCols, sizeof(SColumnInfoData));
-  pBlock->info.numOfCols = numOfCols;
-
-  for(int32_t i = 0; i < numOfCols; ++i) {
-    SColumnInfoData  colInfo = {0};
-
-    colInfo.info.type  = pSchema[i].type;
-    colInfo.info.bytes = pSchema[i].bytes;
-    colInfo.info.colId = pSchema[i].colId;
-    taosArrayPush(pBlock->pDataBlock, &colInfo);
-
-    if (IS_VAR_DATA_TYPE(colInfo.info.type)) {
-      pBlock->info.hasVarCol = true;
-    }
-  }
-
-  return pBlock;
 }
 
 /**
@@ -98,7 +81,10 @@ SSortHandle* tsortCreateSortHandle(SArray* pSortInfo, SArray* pIndexMap, int32_t
   pSortHandle->numOfPages = numOfPages;
   pSortHandle->pSortInfo  = pSortInfo;
   pSortHandle->pIndexMap  = pIndexMap;
+
+  if (pBlock != NULL) {
     pSortHandle->pDataBlock = createOneDataBlock(pBlock, false);
+  }
 
   pSortHandle->pOrderedSource     = taosArrayInit(4, POINTER_BYTES);
   pSortHandle->cmpParam.orderInfo = pSortInfo;
@@ -530,6 +516,17 @@ static int32_t createInitialSortedMultiSources(SSortHandle* pHandle) {
 
       if (pHandle->pDataBlock == NULL) {
         pHandle->pDataBlock = createOneDataBlock(pBlock, false);
+
+        // calculate the buffer pages according to the total available buffers.
+        int32_t rowSize = blockDataGetRowSize(pBlock);
+        if (rowSize * 4 > 4096) {
+          pHandle->pageSize = rowSize * 4;
+        } else {
+          pHandle->pageSize = 4096;
+        }
+        // todo!!
+        pHandle->numOfPages = 1024;
+        sortBufSize = pHandle->numOfPages * pHandle->pageSize;
       }
 
       // perform the scalar function calculation before apply the sort
@@ -538,7 +535,6 @@ static int32_t createInitialSortedMultiSources(SSortHandle* pHandle) {
       }
 
       // todo relocate the columns
-
       int32_t code = blockDataMerge(pHandle->pDataBlock, pBlock, pHandle->pIndexMap);
       if (code != 0) {
         return code;
@@ -689,7 +685,7 @@ STupleHandle* tsortNextTuple(SSortHandle* pHandle) {
 
 bool tsortIsNullVal(STupleHandle* pVHandle, int32_t colIndex) {
   SColumnInfoData* pColInfoSrc = taosArrayGet(pVHandle->pBlock->pDataBlock, colIndex);
-  return colDataIsNull(pColInfoSrc, 0, pVHandle->rowIndex, NULL);
+  return colDataIsNull_s(pColInfoSrc, pVHandle->rowIndex);
 }
 
 void* tsortGetValue(STupleHandle* pVHandle, int32_t colIndex) {

source/libs/function/src/builtins.c

@@ -242,8 +242,7 @@ static int32_t translateFirstLast(SFunctionNode* pFunc, char* pErrBuf, int32_t l
                            "The parameters of first/last can only be columns");
   }
 
-  uint8_t paraType = ((SExprNode*)pPara)->resType.type;
+  pFunc->node.resType = ((SExprNode*)pPara)->resType;
-  pFunc->node.resType = (SDataType){.bytes = tDataTypes[paraType].bytes, .type = paraType};
   return TSDB_CODE_SUCCESS;
 }
 
@@ -917,7 +916,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .translateFunc = translateTbnameColumn,
     .getEnvFunc   = NULL,
     .initFunc     = NULL,
-    .sprocessFunc = NULL,
+    .sprocessFunc = qTbnameFunction,
     .finalizeFunc = NULL
   },
   {

source/libs/function/src/tudf.c

@@ -594,7 +594,9 @@ int32_t convertScalarParamToDataBlock(SScalarParam *input, int32_t numOfCols, SS
 
   //TODO: free the array output->pDataBlock
   output->pDataBlock = taosArrayInit(numOfCols, sizeof(SColumnInfoData));
-  taosArrayPush(output->pDataBlock, input->columnData);
+  for (int32_t i = 0; i < numOfCols; ++i) {
+    taosArrayPush(output->pDataBlock, (input + i)->columnData);
+  }
   return 0;
 }
 

source/libs/function/src/udfd.c

@@ -81,6 +81,9 @@ typedef struct SUdf {
   TUdfAggStartFunc      aggStartFunc;
   TUdfAggProcessFunc    aggProcFunc;
   TUdfAggFinishFunc     aggFinishFunc;
+
+  TUdfInitFunc          initFunc;
+  TUdfDestroyFunc       destroyFunc;
 } SUdf;
 
 // TODO: low priority: change name onxxx to xxxCb, and udfc or udfd as prefix
@@ -101,7 +104,19 @@ int32_t udfdLoadUdf(char *udfName, SUdf *udf) {
     fnError("can not load library %s. error: %s", udf->path, uv_strerror(err));
     return UDFC_CODE_LOAD_UDF_FAILURE;
   }
-  //TODO: init and destroy function
+
+  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));
+
+  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));
+
   if (udf->funcType == TSDB_FUNC_TYPE_SCALAR) {
     char processFuncName[TSDB_FUNC_NAME_LEN] = {0};
     strcpy(processFuncName, udfName);
@@ -159,6 +174,9 @@ void udfdProcessRequest(uv_work_t *req) {
       if (udf->state == UDF_STATE_INIT) {
         udf->state = UDF_STATE_LOADING;
         udfdLoadUdf(setup->udfName, udf);
+        if (udf->initFunc) {
+          udf->initFunc();
+        }
         udf->state = UDF_STATE_READY;
         uv_cond_broadcast(&udf->condReady);
         uv_mutex_unlock(&udf->lock);
@@ -170,7 +188,6 @@ void udfdProcessRequest(uv_work_t *req) {
       }
       SUdfcFuncHandle *handle = taosMemoryMalloc(sizeof(SUdfcFuncHandle));
       handle->udf = udf;
-      // TODO: allocate private structure and call init function and set it to handle
       SUdfResponse rsp;
       rsp.seqNum = request.seqNum;
       rsp.type = request.type;
@@ -275,10 +292,12 @@ void udfdProcessRequest(uv_work_t *req) {
       if (unloadUdf) {
         uv_cond_destroy(&udf->condReady);
         uv_mutex_destroy(&udf->lock);
+        if (udf->destroyFunc) {
+          (udf->destroyFunc)();
+        }
         uv_dlclose(&udf->lib);
         taosMemoryFree(udf);
       }
-      // TODO: call destroy and free udf private
       taosMemoryFree(handle);
 
       SUdfResponse  response;

source/libs/parser/src/parInsert.c

@@ -22,7 +22,6 @@
 #include "ttime.h"
 #include "ttypes.h"
 
-// clang-format off
 #define NEXT_TOKEN(pSql, sToken)                \
   do {                                          \
     int32_t index = 0;                          \
@@ -248,12 +247,11 @@ static int32_t getTableMetaImpl(SInsertParseContext* pCxt, SToken* pTname, bool
   } else {
     CHECK_CODE(catalogGetTableMeta(pBasicCtx->pCatalog, pBasicCtx->pTransporter, &pBasicCtx->mgmtEpSet, &name,
                                    &pCxt->pTableMeta));
-  }
     SVgroupInfo vg;
     CHECK_CODE(
         catalogGetTableHashVgroup(pBasicCtx->pCatalog, pBasicCtx->pTransporter, &pBasicCtx->mgmtEpSet, &name, &vg));
     CHECK_CODE(taosHashPut(pCxt->pVgroupsHashObj, (const char*)&vg.vgId, sizeof(vg.vgId), (char*)&vg, sizeof(vg)));
-
+  }
   return TSDB_CODE_SUCCESS;
 }
 
@@ -828,12 +826,21 @@ static int32_t cloneTableMeta(STableMeta* pSrc, STableMeta** pDst) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t storeTableMeta(SHashObj* pHash, const char* pName, int32_t len, STableMeta* pMeta) {
+static int32_t storeTableMeta(SInsertParseContext* pCxt, SHashObj* pHash, SName* pTableName, const char* pName,
+                              int32_t len, STableMeta* pMeta) {
+  SVgroupInfo    vg;
+  SParseContext* pBasicCtx = pCxt->pComCxt;
+  CHECK_CODE(
+      catalogGetTableHashVgroup(pBasicCtx->pCatalog, pBasicCtx->pTransporter, &pBasicCtx->mgmtEpSet, pTableName, &vg));
+  CHECK_CODE(taosHashPut(pCxt->pVgroupsHashObj, (const char*)&vg.vgId, sizeof(vg.vgId), (char*)&vg, sizeof(vg)));
+
+  pMeta->uid = tGenIdPI64();
+  pMeta->vgId = vg.vgId;
+
   STableMeta* pBackup = NULL;
   if (TSDB_CODE_SUCCESS != cloneTableMeta(pMeta, &pBackup)) {
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
-  pBackup->uid = tGenIdPI64();
   return taosHashPut(pHash, pName, len, &pBackup, POINTER_BYTES);
 }
 
@@ -856,7 +863,7 @@ static int32_t parseUsingClause(SInsertParseContext* pCxt, SToken* pTbnameToken)
   if (TSDB_SUPER_TABLE != pCxt->pTableMeta->tableType) {
     return buildInvalidOperationMsg(&pCxt->msg, "create table only from super table is allowed");
   }
-  CHECK_CODE(storeTableMeta(pCxt->pSubTableHashObj, tbFName, len, pCxt->pTableMeta));
+  CHECK_CODE(storeTableMeta(pCxt, pCxt->pSubTableHashObj, &name, tbFName, len, pCxt->pTableMeta));
 
   SSchema* pTagsSchema = getTableTagSchema(pCxt->pTableMeta);
   setBoundColumnInfo(&pCxt->tags, pTagsSchema, getNumOfTags(pCxt->pTableMeta));
@@ -1262,8 +1269,9 @@ int32_t qBuildStmtOutput(SQuery* pQuery, SHashObj* pVgHash, SHashObj* pBlockHash
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t qBindStmtTagsValue(void *pBlock, void *boundTags, int64_t suid, SName *pName, TAOS_MULTI_BIND *bind, char *msgBuf, int32_t msgBufLen){
+int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, SName* pName, TAOS_MULTI_BIND* bind,
-  STableDataBlocks *pDataBlock = (STableDataBlocks *)pBlock;
+                           char* msgBuf, int32_t msgBufLen) {
+  STableDataBlocks*   pDataBlock = (STableDataBlocks*)pBlock;
   SMsgBuf             pBuf = {.buf = msgBuf, .len = msgBufLen};
   SParsedDataColInfo* tags = (SParsedDataColInfo*)boundTags;
   if (NULL == tags) {
@@ -1312,9 +1320,8 @@ int32_t qBindStmtTagsValue(void *pBlock, void *boundTags, int64_t suid, SName *p
   return TSDB_CODE_SUCCESS;
 }
 
-
+int32_t qBindStmtColsValue(void* pBlock, TAOS_MULTI_BIND* bind, char* msgBuf, int32_t msgBufLen) {
-int32_t qBindStmtColsValue(void *pBlock, TAOS_MULTI_BIND *bind, char *msgBuf, int32_t msgBufLen) {
+  STableDataBlocks*   pDataBlock = (STableDataBlocks*)pBlock;
-  STableDataBlocks *pDataBlock = (STableDataBlocks *)pBlock;
   SSchema*            pSchema = getTableColumnSchema(pDataBlock->pTableMeta);
   int32_t             extendedRowSize = getExtendedRowSize(pDataBlock);
   SParsedDataColInfo* spd = &pDataBlock->boundColumnInfo;
@@ -1391,8 +1398,9 @@ int32_t qBindStmtColsValue(void *pBlock, TAOS_MULTI_BIND *bind, char *msgBuf, in
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t qBindStmtSingleColValue(void *pBlock, TAOS_MULTI_BIND *bind, char *msgBuf, int32_t msgBufLen, int32_t colIdx, int32_t rowNum) {
+int32_t qBindStmtSingleColValue(void* pBlock, TAOS_MULTI_BIND* bind, char* msgBuf, int32_t msgBufLen, int32_t colIdx,
-  STableDataBlocks *pDataBlock = (STableDataBlocks *)pBlock;
+                                int32_t rowNum) {
+  STableDataBlocks*   pDataBlock = (STableDataBlocks*)pBlock;
   SSchema*            pSchema = getTableColumnSchema(pDataBlock->pTableMeta);
   int32_t             extendedRowSize = getExtendedRowSize(pDataBlock);
   SParsedDataColInfo* spd = &pDataBlock->boundColumnInfo;
@@ -1459,7 +1467,7 @@ int32_t qBindStmtSingleColValue(void *pBlock, TAOS_MULTI_BIND *bind, char *msgBu
     }
 
 #ifdef TD_DEBUG_PRINT_ROW
-    if(rowEnd) {
+    if (rowEnd) {
       STSchema* pSTSchema = tdGetSTSChemaFromSSChema(&pSchema, spd->numOfCols);
       tdSRowPrint(row, pSTSchema, __func__);
       taosMemoryFree(pSTSchema);

source/libs/parser/src/parInsertData.c

@@ -498,14 +498,9 @@ int32_t mergeTableDataBlocks(SHashObj* pHashObj, uint8_t payloadType, SArray** p
         ASSERT(blkKeyInfo.pKeyTuple != NULL && pBlocks->numOfRows > 0);
       }
 
-      int32_t len = pBlocks->numOfRows *
-                        (isRawPayload ? (pOneTableBlock->rowSize + expandSize) : getExtendedRowSize(pOneTableBlock)) +
-                    sizeof(STColumn) * getNumOfColumns(pOneTableBlock->pTableMeta);
-
       // erase the empty space reserved for binary data
       int32_t finalLen =
           trimDataBlock(dataBuf->pData + dataBuf->size, pOneTableBlock, blkKeyInfo.pKeyTuple, isRawPayload);
-      assert(finalLen <= len);
 
       dataBuf->size += (finalLen + sizeof(SSubmitBlk));
       assert(dataBuf->size <= dataBuf->nAllocSize);

source/libs/parser/src/parTranslater.c

@@ -2174,17 +2174,6 @@ static int32_t checkTableSmaOption(STranslateContext* pCxt, SCreateTableStmt* pS
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t checkTableTags(STranslateContext* pCxt, SCreateTableStmt* pStmt) {
-  SNode* pNode;
-  FOREACH(pNode, pStmt->pTags) {
-    SColumnDefNode* pCol = (SColumnDefNode*)pNode;
-    if (pCol->dataType.type == TSDB_DATA_TYPE_JSON && LIST_LENGTH(pStmt->pTags) > 1) {
-      return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_ONLY_ONE_JSON_TAG);
-    }
-  }
-  return TSDB_CODE_SUCCESS;
-}
-
 static int32_t checkTableRollupOption(STranslateContext* pCxt, SNodeList* pFuncs) {
   if (NULL == pFuncs) {
     return TSDB_CODE_SUCCESS;
@@ -2196,6 +2185,113 @@ static int32_t checkTableRollupOption(STranslateContext* pCxt, SNodeList* pFuncs
   return TSDB_CODE_SUCCESS;
 }
 
+static int32_t checkTableTagsSchema(STranslateContext* pCxt, SHashObj* pHash, SNodeList* pTags) {
+  int32_t ntags = LIST_LENGTH(pTags);
+  if (0 == ntags) {
+    return TSDB_CODE_SUCCESS;
+  } else if (ntags > TSDB_MAX_TAGS) {
+    return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_TAGS_NUM);
+  }
+
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t tagsSize = 0;
+  SNode*  pNode = NULL;
+  FOREACH(pNode, pTags) {
+    SColumnDefNode* pTag = (SColumnDefNode*)pNode;
+    int32_t         len = strlen(pTag->colName);
+    if (NULL != taosHashGet(pHash, pTag->colName, len)) {
+      code = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_DUPLICATED_COLUMN);
+    }
+    if (TSDB_CODE_SUCCESS == code && pTag->dataType.type == TSDB_DATA_TYPE_JSON && ntags > 1) {
+      code = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_ONLY_ONE_JSON_TAG);
+    }
+    if (TSDB_CODE_SUCCESS == code) {
+      if ((TSDB_DATA_TYPE_VARCHAR == pTag->dataType.type && pTag->dataType.bytes > TSDB_MAX_BINARY_LEN) ||
+          (TSDB_DATA_TYPE_NCHAR == pTag->dataType.type && pTag->dataType.bytes > TSDB_MAX_NCHAR_LEN)) {
+        code = code = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_VAR_COLUMN_LEN);
+      }
+    }
+    if (TSDB_CODE_SUCCESS == code) {
+      code = taosHashPut(pHash, pTag->colName, len, &pTag, POINTER_BYTES);
+    }
+    if (TSDB_CODE_SUCCESS == code) {
+      tagsSize += pTag->dataType.bytes;
+    } else {
+      break;
+    }
+  }
+
+  if (TSDB_CODE_SUCCESS == code && tagsSize > TSDB_MAX_TAGS_LEN) {
+    code = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_TAGS_LENGTH, TSDB_MAX_TAGS_LEN);
+  }
+
+  return code;
+}
+
+static int32_t checkTableColsSchema(STranslateContext* pCxt, SHashObj* pHash, SNodeList* pCols) {
+  int32_t ncols = LIST_LENGTH(pCols);
+  if (ncols < TSDB_MIN_COLUMNS) {
+    return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_COLUMNS_NUM);
+  } else if (ncols > TSDB_MAX_COLUMNS) {
+    return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_TOO_MANY_COLUMNS);
+  }
+
+  int32_t code = TSDB_CODE_SUCCESS;
+
+  bool    first = true;
+  int32_t rowSize = 0;
+  SNode*  pNode = NULL;
+  FOREACH(pNode, pCols) {
+    SColumnDefNode* pCol = (SColumnDefNode*)pNode;
+    if (first) {
+      first = false;
+      if (TSDB_DATA_TYPE_TIMESTAMP != pCol->dataType.type) {
+        code = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_FIRST_COLUMN);
+      }
+    }
+    int32_t len = strlen(pCol->colName);
+    if (TSDB_CODE_SUCCESS == code && NULL != taosHashGet(pHash, pCol->colName, len)) {
+      code = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_DUPLICATED_COLUMN);
+    }
+    if (TSDB_CODE_SUCCESS == code) {
+      if ((TSDB_DATA_TYPE_VARCHAR == pCol->dataType.type && pCol->dataType.bytes > TSDB_MAX_BINARY_LEN) ||
+          (TSDB_DATA_TYPE_NCHAR == pCol->dataType.type && pCol->dataType.bytes > TSDB_MAX_NCHAR_LEN)) {
+        code = code = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_VAR_COLUMN_LEN);
+      }
+    }
+    if (TSDB_CODE_SUCCESS == code) {
+      code = taosHashPut(pHash, pCol->colName, len, &pCol, POINTER_BYTES);
+    }
+    if (TSDB_CODE_SUCCESS == code) {
+      rowSize += pCol->dataType.bytes;
+    } else {
+      break;
+    }
+  }
+
+  if (TSDB_CODE_SUCCESS == code && rowSize > TSDB_MAX_BYTES_PER_ROW) {
+    code = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_ROW_LENGTH, TSDB_MAX_BYTES_PER_ROW);
+  }
+
+  return code;
+}
+
+static int32_t checkTableSchema(STranslateContext* pCxt, SCreateTableStmt* pStmt) {
+  SHashObj* pHash = taosHashInit(LIST_LENGTH(pStmt->pTags) + LIST_LENGTH(pStmt->pCols),
+                                 taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
+  if (NULL == pHash) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  int32_t code = checkTableTagsSchema(pCxt, pHash, pStmt->pTags);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = checkTableColsSchema(pCxt, pHash, pStmt->pCols);
+  }
+
+  taosHashCleanup(pHash);
+  return code;
+}
+
 static int32_t checkCreateTable(STranslateContext* pCxt, SCreateTableStmt* pStmt) {
   int32_t code = checkRangeOption(pCxt, "delay", pStmt->pOptions->delay, TSDB_MIN_ROLLUP_DELAY, TSDB_MAX_ROLLUP_DELAY);
   if (TSDB_CODE_SUCCESS == code) {
@@ -2211,7 +2307,7 @@ static int32_t checkCreateTable(STranslateContext* pCxt, SCreateTableStmt* pStmt
     code = checkTableSmaOption(pCxt, pStmt);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = checkTableTags(pCxt, pStmt);
+    code = checkTableSchema(pCxt, pStmt);
   }
   return code;
 }
@@ -3838,6 +3934,10 @@ static int32_t buildDropTableVgroupHashmap(STranslateContext* pCxt, SDropTableCl
     goto over;
   }
 
+  if (TSDB_CODE_PAR_TABLE_NOT_EXIST == code && pClause->ignoreNotExists) {
+    code = TSDB_CODE_SUCCESS;
+  }
+
   *pIsSuperTable = false;
 
   SVgroupInfo info = {0};

source/libs/parser/src/parUtil.c

@@ -129,7 +129,23 @@ static char* getSyntaxErrFormat(int32_t errCode) {
     case TSDB_CODE_PAR_INVALID_DROP_STABLE:
       return "Cannot drop super table in batch";
     case TSDB_CODE_PAR_INVALID_FILL_TIME_RANGE:
-      return "start(end) time of query range required or time range too large";
+      return "Start(end) time of query range required or time range too large";
+    case TSDB_CODE_PAR_DUPLICATED_COLUMN:
+      return "Duplicated column names";
+    case TSDB_CODE_PAR_INVALID_TAGS_LENGTH:
+      return "Tags length exceeds max length %d";
+    case TSDB_CODE_PAR_INVALID_ROW_LENGTH:
+      return "Row length exceeds max length %d";
+    case TSDB_CODE_PAR_INVALID_COLUMNS_NUM:
+      return "Illegal number of columns";
+    case TSDB_CODE_PAR_TOO_MANY_COLUMNS:
+      return "Too many columns";
+    case TSDB_CODE_PAR_INVALID_FIRST_COLUMN:
+      return "First column must be timestamp";
+    case TSDB_CODE_PAR_INVALID_VAR_COLUMN_LEN:
+      return "Invalid binary/nchar column length";
+    case TSDB_CODE_PAR_INVALID_TAGS_NUM:
+      return "Invalid number of tag columns";
     case TSDB_CODE_OUT_OF_MEMORY:
       return "Out of memory";
     default:

source/libs/planner/src/planLogicCreater.c

@@ -277,6 +277,11 @@ static int32_t createScanLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
     code = nodesCollectFuncs(pSelect, SQL_CLAUSE_FROM, fmIsScanPseudoColumnFunc, &pScan->pScanPseudoCols);
   }
 
+  // rewrite the expression in subsequent clauses
+  if (TSDB_CODE_SUCCESS == code) {
+    code = rewriteExprForSelect(pScan->pScanPseudoCols, pSelect, SQL_CLAUSE_FROM);
+  }
+
   pScan->scanType = getScanType(pCxt, pScan->pScanPseudoCols, pScan->pScanCols, pScan->pMeta);
 
   if (TSDB_CODE_SUCCESS == code) {

source/libs/planner/src/planOptimizer.c

@@ -123,14 +123,40 @@ static SNodeList* osdGetAllFuncs(SLogicNode* pNode) {
   return NULL;
 }
 
+static bool needOptimizeDataRequire(const SFunctionNode* pFunc) {
+  if (!fmIsSpecialDataRequiredFunc(pFunc->funcId)) {
+    return false;
+  }
+  SNode* pPara = NULL;
+  FOREACH(pPara, pFunc->pParameterList) {
+    if (QUERY_NODE_COLUMN != nodeType(pPara) && QUERY_NODE_VALUE != nodeType(pPara)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+static bool needOptimizeDynamicScan(const SFunctionNode* pFunc) {
+  if (!fmIsDynamicScanOptimizedFunc(pFunc->funcId)) {
+    return false;
+  }
+  SNode* pPara = NULL;
+  FOREACH(pPara, pFunc->pParameterList) {
+    if (QUERY_NODE_COLUMN != nodeType(pPara) && QUERY_NODE_VALUE != nodeType(pPara)) {
+      return false;
+    }
+  }
+  return true;
+}
+
 static int32_t osdGetRelatedFuncs(SScanLogicNode* pScan, SNodeList** pSdrFuncs, SNodeList** pDsoFuncs) {
   SNodeList* pAllFuncs = osdGetAllFuncs(pScan->node.pParent);
   SNode*     pFunc = NULL;
   FOREACH(pFunc, pAllFuncs) {
     int32_t code = TSDB_CODE_SUCCESS;
-    if (fmIsSpecialDataRequiredFunc(((SFunctionNode*)pFunc)->funcId)) {
+    if (needOptimizeDataRequire((SFunctionNode*)pFunc)) {
       code = nodesListMakeStrictAppend(pSdrFuncs, nodesCloneNode(pFunc));
-    } else if (fmIsDynamicScanOptimizedFunc(((SFunctionNode*)pFunc)->funcId)) {
+    } else if (needOptimizeDynamicScan((SFunctionNode*)pFunc)) {
       code = nodesListMakeStrictAppend(pDsoFuncs, nodesCloneNode(pFunc));
     }
     if (TSDB_CODE_SUCCESS != code) {
@@ -541,9 +567,14 @@ static bool cpdIsPrimaryKeyEqualCond(SJoinLogicNode* pJoin, SNode* pCond) {
   if (QUERY_NODE_OPERATOR != nodeType(pCond)) {
     return false;
   }
+
+  SOperatorNode* pOper = (SOperatorNode*)pJoin->pOnConditions;
+  if (OP_TYPE_EQUAL != pOper->opType) {
+    return false;
+  }
+
   SNodeList* pLeftCols = ((SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 0))->pTargets;
   SNodeList* pRightCols = ((SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 1))->pTargets;
-  SOperatorNode* pOper = (SOperatorNode*)pJoin->pOnConditions;
   if (cpdIsPrimaryKey(pOper->pLeft, pLeftCols)) {
     return cpdIsPrimaryKey(pOper->pRight, pRightCols);
   } else if (cpdIsPrimaryKey(pOper->pLeft, pRightCols)) {

source/libs/planner/test/planOptimizeTest.cpp

@@ -20,11 +20,21 @@ using namespace std;
 
 class PlanOptimizeTest : public PlannerTestBase {};
 
+TEST_F(PlanOptimizeTest, optimizeScanData) {
+  useDb("root", "test");
+
+  run("SELECT COUNT(*) FROM t1");
+
+  run("SELECT COUNT(c1) FROM t1");
+
+  run("SELECT COUNT(CAST(c1 AS BIGINT)) FROM t1");
+}
+
 TEST_F(PlanOptimizeTest, orderByPrimaryKey) {
   useDb("root", "test");
 
-  run("select * from t1 order by ts");
+  run("SELECT * FROM t1 ORDER BY ts");
-  run("select * from t1 order by ts desc");
+  run("SELECT * FROM t1 ORDER BY ts DESC");
-  run("select c1 from t1 order by ts");
+  run("SELECT c1 FROM t1 ORDER BY ts");
-  run("select c1 from t1 order by ts desc");
+  run("SELECT c1 FROM t1 ORDER BY ts DESC");
 }

source/libs/qcom/src/querymsg.c

@@ -181,6 +181,25 @@ int32_t queryBuildRetrieveFuncMsg(void *input, char **msg, int32_t msgSize, int3
   return TSDB_CODE_SUCCESS;
 }
 
+int32_t queryBuildGetUserAuthMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen) {
+  if (NULL == msg || NULL == msgLen) {
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
+
+  SGetUserAuthReq req = {0};
+  strncpy(req.user, input, sizeof(req.user));
+
+  int32_t bufLen = tSerializeSGetUserAuthReq(NULL, 0, &req);
+  void   *pBuf = rpcMallocCont(bufLen);
+  tSerializeSGetUserAuthReq(pBuf, bufLen, &req);
+
+  *msg = pBuf;
+  *msgLen = bufLen;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
 int32_t queryProcessUseDBRsp(void *output, char *msg, int32_t msgSize) {
   SUseDbOutput *pOut = output;
   SUseDbRsp     usedbRsp = {0};
@@ -419,6 +438,20 @@ int32_t queryProcessRetrieveFuncRsp(void *output, char *msg, int32_t msgSize) {
   return TSDB_CODE_SUCCESS;
 }
 
+int32_t queryProcessGetUserAuthRsp(void *output, char *msg, int32_t msgSize) {
+  if (NULL == output || NULL == msg || msgSize <= 0) {
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
+
+  if (tDeserializeSGetUserAuthRsp(msg, msgSize, (SGetUserAuthRsp *)output) != 0) {
+    qError("tDeserializeSGetUserAuthRsp failed, msgSize:%d", msgSize);
+    return TSDB_CODE_INVALID_MSG;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
 void initQueryModuleMsgHandle() {
   queryBuildMsg[TMSG_INDEX(TDMT_VND_TABLE_META)] = queryBuildTableMetaReqMsg;
   queryBuildMsg[TMSG_INDEX(TDMT_MND_TABLE_META)] = queryBuildTableMetaReqMsg;
@@ -427,6 +460,8 @@ void initQueryModuleMsgHandle() {
   queryBuildMsg[TMSG_INDEX(TDMT_MND_GET_DB_CFG)] = queryBuildGetDBCfgMsg;
   queryBuildMsg[TMSG_INDEX(TDMT_MND_GET_INDEX)]  = queryBuildGetIndexMsg;
   queryBuildMsg[TMSG_INDEX(TDMT_MND_RETRIEVE_FUNC)]  = queryBuildRetrieveFuncMsg;
+  queryBuildMsg[TMSG_INDEX(TDMT_MND_GET_USER_AUTH)]  = queryBuildGetUserAuthMsg;
+  
 
   queryProcessMsgRsp[TMSG_INDEX(TDMT_VND_TABLE_META)] = queryProcessTableMetaRsp;
   queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_TABLE_META)] = queryProcessTableMetaRsp;
@@ -435,6 +470,7 @@ void initQueryModuleMsgHandle() {
   queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_GET_DB_CFG)] = queryProcessGetDbCfgRsp;
   queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_GET_INDEX)]  = queryProcessGetIndexRsp;
   queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_RETRIEVE_FUNC)]  = queryProcessRetrieveFuncRsp;
+  queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_GET_USER_AUTH)]  = queryProcessGetUserAuthRsp;
 }
 
 #pragma GCC diagnostic pop

source/libs/scalar/src/sclfunc.c

@@ -1513,3 +1513,9 @@ int32_t winEndTsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *p
   colDataAppendInt64(pOutput->columnData, pOutput->numOfRows, (int64_t*) colDataGetData(pInput->columnData, 4));
   return TSDB_CODE_SUCCESS;
 }
+
+int32_t qTbnameFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
+  ASSERT(inputNum == 1);
+  colDataAppend(pOutput->columnData, pOutput->numOfRows, colDataGetData(pInput->columnData, 0), false);
+  return TSDB_CODE_SUCCESS;
+}

source/libs/scalar/src/sclvector.c

@@ -1023,8 +1023,7 @@ static void vectorMathMultiplyHelper(SColumnInfoData* pLeftCol, SColumnInfoData*
         colDataAppendNULL(pOutputCol, i);
         continue;  // TODO set null or ignore
       }
-      *output = getVectorDoubleValueFnLeft(LEFT_COL, i)
+      *output = getVectorDoubleValueFnLeft(LEFT_COL, i) * getVectorDoubleValueFnRight(RIGHT_COL, 0);
-                * getVectorDoubleValueFnRight(RIGHT_COL, 0);
     }
   }
 }
@@ -1050,8 +1049,7 @@ void vectorMathMultiply(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam
         colDataAppendNULL(pOutputCol, i);
         continue;  // TODO set null or ignore
       }
-      *output = getVectorDoubleValueFnLeft(LEFT_COL, i)
+      *output = getVectorDoubleValueFnLeft(LEFT_COL, i) * getVectorDoubleValueFnRight(RIGHT_COL, i);
-                * getVectorDoubleValueFnRight(RIGHT_COL, i);
     }
   } else if (pLeft->numOfRows == 1) {
     vectorMathMultiplyHelper(pRightCol, pLeftCol, pOutputCol, pRight->numOfRows, step, i);

source/libs/scheduler/src/scheduler.c

@@ -1085,19 +1085,22 @@ int32_t schHandleResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t msgType, ch
     case TDMT_VND_CREATE_TABLE_RSP: {
       SVCreateTbBatchRsp batchRsp = {0};
       if (msg) {
-        SCH_ERR_JRET(tDeserializeSVCreateTbBatchRsp(msg, msgSize, &batchRsp));
+        SCoder coder = {0};
-        if (batchRsp.pArray) {
+        tCoderInit(&coder, TD_LITTLE_ENDIAN, msg, msgSize, TD_DECODER);
-          int32_t num = taosArrayGetSize(batchRsp.pArray);
+        code = tDecodeSVCreateTbBatchRsp(&coder, &batchRsp);
-          for (int32_t i = 0; i < num; ++i) {
+        if (TSDB_CODE_SUCCESS == code && batchRsp.nRsps > 0) {
-            SVCreateTbRsp *rsp = taosArrayGet(batchRsp.pArray, i);
+          for (int32_t i = 0; i < batchRsp.nRsps; ++i) {
+            SVCreateTbRsp *rsp = batchRsp.pRsps + i;
             if (NEED_CLIENT_HANDLE_ERROR(rsp->code)) {
-              taosArrayDestroy(batchRsp.pArray);
+              tCoderClear(&coder);
               SCH_ERR_JRET(rsp->code);
+            } else if (TSDB_CODE_SUCCESS != rsp->code) {
+              code = rsp->code;
             }
           }
-
-          taosArrayDestroy(batchRsp.pArray);
         }
+        tCoderClear(&coder);
+        SCH_ERR_JRET(code);
       }
 
       SCH_ERR_JRET(rspCode);
@@ -1110,13 +1113,14 @@ int32_t schHandleResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t msgType, ch
         SCoder coder = {0};
         tCoderInit(&coder, TD_LITTLE_ENDIAN, msg, msgSize, TD_DECODER);
         code = tDecodeSVDropTbBatchRsp(&coder, &batchRsp);
-        if (TSDB_CODE_SUCCESS == code && batchRsp.pArray) {
+        if (TSDB_CODE_SUCCESS == code && batchRsp.nRsps > 0) {
-          int32_t num = taosArrayGetSize(batchRsp.pArray);
+          for (int32_t i = 0; i < batchRsp.nRsps; ++i) {
-          for (int32_t i = 0; i < num; ++i) {
+            SVDropTbRsp *rsp = batchRsp.pRsps + i;
-            SVDropTbRsp *rsp = taosArrayGet(batchRsp.pArray, i);
             if (NEED_CLIENT_HANDLE_ERROR(rsp->code)) {
               tCoderClear(&coder);
               SCH_ERR_JRET(rsp->code);
+            } else if (TSDB_CODE_SUCCESS != rsp->code) {
+              code = rsp->code;
             }
           }
         }
@@ -2282,7 +2286,7 @@ int32_t schCancelJob(SSchJob *pJob) {
 }
 
 void schCloseJobRef(void) {
-  if (!atomic_load_8((int8_t*)&schMgmt.exit)) {
+  if (!atomic_load_8((int8_t *)&schMgmt.exit)) {
     return;
   }
 
@@ -2791,7 +2795,7 @@ void schedulerFreeTaskList(SArray *taskList) {
 }
 
 void schedulerDestroy(void) {
-  atomic_store_8((int8_t*)&schMgmt.exit, 1);
+  atomic_store_8((int8_t *)&schMgmt.exit, 1);
 
   if (schMgmt.jobRef >= 0) {
     SSchJob *pJob = taosIterateRef(schMgmt.jobRef, 0);

source/libs/transport/src/trans.c

@@ -46,9 +46,21 @@ void* rpcOpen(const SRpcInit* pInit) {
     pRpc->numOfThreads = pInit->numOfThreads > TSDB_MAX_RPC_THREADS ? TSDB_MAX_RPC_THREADS : pInit->numOfThreads;
   }
 
+  uint32_t ip = 0;
+  if (pInit->connType == TAOS_CONN_SERVER) {
+    ip = taosGetIpv4FromFqdn(pInit->localFqdn);
+    if (ip == 0xFFFFFFFF) {
+      tError("invalid fqdn: %s", pInit->localFqdn);
+      terrno = TSDB_CODE_RPC_FQDN_ERROR;
+      taosMemoryFree(pRpc);
+      return NULL;
+    }
+  }
+
   pRpc->connType = pInit->connType;
   pRpc->idleTime = pInit->idleTime;
-  pRpc->tcphandle = (*taosInitHandle[pRpc->connType])(0, pInit->localPort, pRpc->label, pRpc->numOfThreads, NULL, pRpc);
+  pRpc->tcphandle =
+      (*taosInitHandle[pRpc->connType])(ip, pInit->localPort, pRpc->label, pRpc->numOfThreads, NULL, pRpc);
   if (pRpc->tcphandle == NULL) {
     taosMemoryFree(pRpc);
     return NULL;

source/libs/transport/src/transSrv.c

@@ -817,7 +817,6 @@ void* transInitServer(uint32_t ip, uint32_t port, char* label, int numOfThreads,
 
     srv->pipe[i] = (uv_pipe_t*)taosMemoryCalloc(2, sizeof(uv_pipe_t));
 
-
     uv_os_sock_t fds[2];
     if (uv_socketpair(SOCK_STREAM, 0, fds, UV_NONBLOCK_PIPE, UV_NONBLOCK_PIPE) != 0) {
       goto End;
@@ -841,6 +840,10 @@ void* transInitServer(uint32_t ip, uint32_t port, char* label, int numOfThreads,
       goto End;
     }
   }
+  if (false == taosValidIpAndPort(srv->ip, srv->port)) {
+    tError("failed to bind, reason: %s", terrstr());
+    goto End;
+  }
   if (false == addHandleToAcceptloop(srv)) {
     goto End;
   }

source/os/src/osSocket.c

@@ -638,6 +638,48 @@ int32_t taosKeepTcpAlive(TdSocketPtr pSocket) {
   return 0;
 }
 
+bool taosValidIpAndPort(uint32_t ip, uint16_t port) {
+  struct sockaddr_in serverAdd;
+  SocketFd           fd;
+  int32_t            reuse;
+
+  // printf("open tcp server socket:0x%x:%hu", ip, port);
+
+  bzero((char *)&serverAdd, sizeof(serverAdd));
+  serverAdd.sin_family = AF_INET;
+  serverAdd.sin_addr.s_addr = ip;
+  serverAdd.sin_port = (uint16_t)htons(port);
+
+  if ((fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) <= 2) {
+    // printf("failed to open TCP socket: %d (%s)", errno, strerror(errno));
+    taosCloseSocketNoCheck1(fd);
+    return false;
+  }
+
+  TdSocketPtr pSocket = (TdSocketPtr)taosMemoryMalloc(sizeof(TdSocket));
+  if (pSocket == NULL) {
+    taosCloseSocketNoCheck1(fd);
+    return false;
+  }
+  pSocket->refId = 0;
+  pSocket->fd = fd;
+
+  /* set REUSEADDR option, so the portnumber can be re-used */
+  reuse = 1;
+  if (taosSetSockOpt(pSocket, SOL_SOCKET, SO_REUSEADDR, (void *)&reuse, sizeof(reuse)) < 0) {
+    // printf("setsockopt SO_REUSEADDR failed: %d (%s)", errno, strerror(errno));
+    taosCloseSocket(&pSocket);
+    return NULL;
+  }
+  /* bind socket to server address */
+  if (bind(pSocket->fd, (struct sockaddr *)&serverAdd, sizeof(serverAdd)) < 0) {
+    // printf("bind tcp server socket failed, 0x%x:%hu(%s)", ip, port, strerror(errno));
+    taosCloseSocket(&pSocket);
+    return false;
+  }
+  taosCloseSocket(&pSocket);
+  return true;
+}
 TdSocketServerPtr taosOpenTcpServerSocket(uint32_t ip, uint16_t port) {
   struct sockaddr_in serverAdd;
   SocketFd           fd;

source/util/src/terror.c

@@ -443,6 +443,9 @@ TAOS_DEFINE_ERROR(TSDB_CODE_SCH_STATUS_ERROR,             "scheduler status erro
 TAOS_DEFINE_ERROR(TSDB_CODE_SCH_INTERNAL_ERROR,           "scheduler internal error")
 TAOS_DEFINE_ERROR(TSDB_CODE_QW_MSG_ERROR,                 "Invalid msg order")
 
+// parser
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_TABLE_NOT_EXIST,          "Table does not exist")
+
 //planner
 TAOS_DEFINE_ERROR(TSDB_CODE_PLAN_INTERNAL_ERROR,          "planner internal error")
 

tests/requirements.txt

@@ -0,0 +1,5 @@
+taospy
+numpy
+fabric2
+psutil
+pandas

tests/script/tsim/query/explain.sim

@@ -25,15 +25,15 @@ sql insert into tb3 values (now, 3, "Hash  (cost=229.20..229.20 rows=101 width=2
 sql create table tb4 using st1 tags(4);
 sql insert into tb4 values (now, 4, "Bitmap Heap Scan on tenk1 t1  (cost=5.07..229.20 rows=101 width=244) (actual time=0.080..0.526 rows=100 loops=1)");
 
-sql create table tb1 using st2 tags(1);
+#sql create table tb1 using st2 tags(1);
-sql insert into tb1 values (now, 1, "Hash Join  (cost=230.47..713.98 rows=101 width=488) (actual time=0.711..7.427 rows=100 loops=1)");
+#sql insert into tb1 values (now, 1, "Hash Join  (cost=230.47..713.98 rows=101 width=488) (actual time=0.711..7.427 rows=100 loops=1)");
 
-sql create table tb2 using st2 tags(2);
+#sql create table tb2 using st2 tags(2);
-sql insert into tb2 values (now, 2, "Seq Scan on tenk2 t2  (cost=0.00..445.00 rows=10000 width=244) (actual time=0.007..2.583 rows=10000 loops=1)");
+#sql insert into tb2 values (now, 2, "Seq Scan on tenk2 t2  (cost=0.00..445.00 rows=10000 width=244) (actual time=0.007..2.583 rows=10000 loops=1)");
-sql create table tb3 using st2 tags(3);
+#sql create table tb3 using st2 tags(3);
-sql insert into tb3 values (now, 3, "Hash  (cost=229.20..229.20 rows=101 width=244) (actual time=0.659..0.659 rows=100 loops=1)");
+#sql insert into tb3 values (now, 3, "Hash  (cost=229.20..229.20 rows=101 width=244) (actual time=0.659..0.659 rows=100 loops=1)");
-sql create table tb4 using st2 tags(4);
+#sql create table tb4 using st2 tags(4);
-sql insert into tb4 values (now, 4, "Bitmap Heap Scan on tenk1 t1  (cost=5.07..229.20 rows=101 width=244) (actual time=0.080..0.526 rows=100 loops=1)");
+#sql insert into tb4 values (now, 4, "Bitmap Heap Scan on tenk1 t1  (cost=5.07..229.20 rows=101 width=244) (actual time=0.080..0.526 rows=100 loops=1)");
 
 
 print ======== step2 

tests/script/tsim/query/session.sim

@@ -65,6 +65,15 @@ sql INSERT INTO dev_002 VALUES('2020-05-13 10:00:00.031', 5)
 sql INSERT INTO dev_002 VALUES('2020-05-13 10:00:00.036', 6)
 sql INSERT INTO dev_002 VALUES('2020-05-13 10:00:00.51', 7)
 
+# vnode does not return the precision of the table
+print ====> create database d1 precision 'us' 
+sql create database d1 precision 'us'
+sql use d1
+sql create table dev_001 (ts timestamp ,i timestamp ,j int)
+sql insert into dev_001 values(1623046993681000,now,1)(1623046993681001,now+1s,2)(1623046993681002,now+2s,3)(1623046993681004,now+5s,4)
+sql create table secondts(ts timestamp,t2 timestamp,i int)
+sql insert into secondts values(1623046993681000,now,1)(1623046993681001,now+1s,2)(1623046993681002,now+2s,3)(1623046993681004,now+5s,4)
+
 $loop_test = 0  
 loop_test_pos:
 
@@ -288,15 +297,6 @@ sql_error sql select count(*) from dev_001 session(ts,0s)
 sql_error select count(*) from dev_001 session(i,1y)
 sql_error select count(*) from dev_001 session(ts,1d) where ts <'2020-05-20 0:0:0'
 
-# vnode does not return the precision of the table
-print ====> create database d1 precision 'us' 
-sql create database d1 precision 'us'
-sql use d1
-sql create table dev_001 (ts timestamp ,i timestamp ,j int)
-sql insert into dev_001 values(1623046993681000,now,1)(1623046993681001,now+1s,2)(1623046993681002,now+2s,3)(1623046993681004,now+5s,4)
-sql create table secondts(ts timestamp,t2 timestamp,i int)
-sql insert into secondts values(1623046993681000,now,1)(1623046993681001,now+1s,2)(1623046993681002,now+2s,3)(1623046993681004,now+5s,4)
-
 #print ====> select count(*) from dev_001 session(ts,1u)
 #sql select _wstartts, count(*) from dev_001 session(ts,1u)
 #print rows: $rows

tests/script/tsim/query/udf.sim

@@ -43,6 +43,27 @@ if $data00 != 2.236067977 then
   return -1
 endi
 
+sql create table t2 (ts timestamp, f1 int, f2 int);
+sql insert into t2 values(now, 0, 0)(now+1s, 1, 1);
+sql select udf1(f1, f2) from t2;
+if $rows != 2 then
+  return -1
+endi
+if $data00 != 88 then
+  return -1
+endi
+if $data10 != 88 then
+  return -1
+endi
+
+sql select udf2(f1, f2) from t2;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 1.414213562 then
+  return -1
+endi
+
 #sql drop function udf1;
 #sql drop function udf2;
 system sh/exec.sh -n dnode1 -s stop -x SIGKILL

tests/script/tsim/table/basic1.sim

@@ -91,9 +91,9 @@ print =============== create normal table
 sql create database ndb
 sql use ndb
 sql create table nt0 (ts timestamp, i int)
-sql create table if not exists nt0 (ts timestamp, i int)
+# sql create table if not exists nt0 (ts timestamp, i int)
 sql create table nt1 (ts timestamp, i int)
-sql create table if not exists nt1 (ts timestamp, i int)
+# sql create table if not exists nt1 (ts timestamp, i int)
 sql create table if not exists nt3 (ts timestamp, i int)
 
 sql show tables

tests/system-test/1-insert/insertWithMoreVgroup.py

@@ -0,0 +1,291 @@
+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import threading
+import multiprocessing as mp
+from numpy.lib.function_base import insert
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+import numpy as np
+import datetime as dt
+import time
+# constant define
+WAITS = 5 # wait seconds
+
+class TDTestCase:
+    #
+    # --------------- main frame -------------------
+    #
+    
+    def caseDescription(self):
+        '''
+        limit and offset keyword function test cases;
+        case1: limit offset base function test
+        case2: offset return valid
+        '''
+        return 
+
+    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
+
+    # init
+    def init(self, conn, logSql):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+        # tdSql.prepare()
+        # self.create_tables();
+        self.ts = 1500000000000
+
+
+    # run case   
+    def run(self):
+
+        #  test base case
+        self.test_case1()
+        tdLog.debug(" LIMIT test_case1 ............ [OK]")
+
+        # test advance case
+        # self.test_case2()
+        # tdLog.debug(" LIMIT test_case2 ............ [OK]")
+
+    # stop 
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+    # --------------- case  -------------------
+
+    # create tables
+    def create_tables(self,dbname,stbname,count):
+        tdSql.execute("use %s" %dbname)
+        tdSql.execute("create stable %s(ts timestamp, c1 int, c2 binary(10)) tags(t1 int)"%stbname)
+        pre_create = "create table"
+        sql = pre_create
+        tdLog.debug("doing create one  stable %s and %d  child table in %s  ..." %(stbname, count ,dbname))
+        # print(time.time())
+        exeStartTime=time.time()
+        for i in range(count):
+            sql += " %s_%d using %s tags(%d)"%(stbname,i,stbname,i+1)
+            if i >0 and i%3000 == 0:
+                tdSql.execute(sql)
+                sql = pre_create
+        # print(time.time())
+        # end sql        
+        if sql != pre_create:
+            tdSql.execute(sql)
+        exeEndTime=time.time()
+        spendTime=exeEndTime-exeStartTime
+        speedCreate=count/spendTime
+        tdLog.debug("spent %.2fs to create 1 stable and %d table, create speed is %.2f table/s... [OK]"% (spendTime,count,speedCreate))
+        return
+
+    def newcur(self,host,cfg):
+        user = "root"
+        password = "taosdata"
+        port =6030 
+        con=taos.connect(host=host, user=user, password=password, config=cfg ,port=port)
+        cur=con.cursor()
+        print(cur)
+        return cur
+
+    def new_create_tables(self,dbname,vgroups,stbname,tcountStart,tcountStop):
+        host = "chenhaoran02"
+        buildPath = self.getBuildPath()
+        config = buildPath+ "../sim/dnode1/cfg/"
+        
+        tsql=self.newcur(host,config)
+        tsql.execute("create database %s vgroups %d"%(dbname,vgroups))
+        tsql.execute("use %s" %dbname)
+        tsql.execute("create stable %s(ts timestamp, c1 int, c2 binary(10)) tags(t1 int)"%stbname)
+
+        pre_create = "create table"
+        sql = pre_create
+        tcountStop=int(tcountStop)
+        tcountStart=int(tcountStart)
+        count=tcountStop-tcountStart
+
+        tdLog.debug("doing create one  stable %s and %d  child table in %s  ..." %(stbname, count ,dbname))
+        # print(time.time())
+        exeStartTime=time.time()
+        # print(type(tcountStop),type(tcountStart))
+        for i in range(tcountStart,tcountStop):
+            sql += " %s_%d using %s tags(%d)"%(stbname,i,stbname,i+1)
+            if i >0 and i%20000 == 0:
+                # print(sql)
+                tsql.execute(sql)
+                sql = pre_create
+        # print(time.time())
+        # end sql        
+        if sql != pre_create:
+            # print(sql)
+            tsql.execute(sql)
+        exeEndTime=time.time()
+        spendTime=exeEndTime-exeStartTime
+        speedCreate=count/spendTime
+        # tdLog.debug("spent %.2fs to create 1 stable and %d table, create speed is %.2f table/s... [OK]"% (spendTime,count,speedCreate))
+        return
+
+
+
+    # insert data
+    def insert_data(self, dbname, stbname, ts_start, tcountStart,tcountStop,rowCount):
+        tdSql.execute("use %s" %dbname)
+        pre_insert = "insert into "
+        sql = pre_insert
+        tcount=tcountStop-tcountStart
+        allRows=tcount*rowCount
+        tdLog.debug("doing insert data into stable:%s rows:%d ..."%(stbname, allRows))
+        exeStartTime=time.time()
+        for i in range(tcountStart,tcountStop):
+            sql += " %s_%d values "%(stbname,i)
+            for j in range(rowCount):
+                sql += "(%d, %d, 'taos_%d') "%(ts_start + j*1000, j, j)
+                if j >0 and j%5000 == 0:
+                    # print(sql)
+                    tdSql.execute(sql)
+                    sql = "insert into %s_%d values " %(stbname,i)
+        # end sql        
+        if sql != pre_insert:
+            # print(sql)
+            tdSql.execute(sql)
+        exeEndTime=time.time()
+        spendTime=exeEndTime-exeStartTime
+        speedInsert=allRows/spendTime
+        # tdLog.debug("spent %.2fs to INSERT  %d rows , insert rate is  %.2f rows/s... [OK]"% (spendTime,allRows,speedInsert))
+
+        tdLog.debug("INSERT TABLE DATA ............ [OK]")
+        return
+
+
+    # test case1 base 
+    def test_case1(self):
+        tdLog.debug("-----create database and tables test------- ")
+        tdSql.execute("drop database if exists db1")
+        tdSql.execute("drop database if exists db4")
+        tdSql.execute("drop database if exists db6")
+        tdSql.execute("drop database if exists db8")
+        tdSql.execute("drop database if exists db12")
+        tdSql.execute("drop database if exists db16")
+
+        #create database and tables;
+
+        # tdSql.execute("create database db11 vgroups 1")
+        # # self.create_tables("db1", "stb1", 30*10000)
+        # tdSql.execute("use db1")
+        # tdSql.execute("create stable stb1(ts timestamp, c1 int, c2 binary(10)) tags(t1 int)")
+
+        # tdSql.execute("create database db12 vgroups 1")
+        # # self.create_tables("db1", "stb1", 30*10000)
+        # tdSql.execute("use db1")
+
+        # t1 = threading.Thread(target=self.new_create_tables("db1", "stb1", 15*10000), args=(1,))
+        # t2 = threading.Thread(target=self.new_create_tables("db1", "stb1", 15*10000), args=(2,))
+        # t1 = mp.Process(target=self.new_create_tables, args=("db1", "stb1", 0,count/2,))
+        # t2 = mp.Process(target=self.new_create_tables, args=("db1", "stb1", count/2,count,))
+
+        count=50000
+        vgroups=1
+        threads = []
+        threadNumbers=2
+        for i in range(threadNumbers):
+            threads.append(mp.Process(target=self.new_create_tables, args=("db1%d"%i, vgroups, "stb1", 0,count,))) 
+        start_time = time.time()
+        for tr in threads:
+            tr.start()
+        for tr in threads:
+            tr.join()
+        end_time = time.time()
+        spendTime=end_time-start_time
+        speedCreate=count/spendTime
+        tdLog.debug("spent %.2fs to create 1 stable and %d table, create speed is %.2f table/s... [OK]"% (spendTime,count,speedCreate))
+        # self.new_create_tables("db1", "stb1", 15*10000)
+        # self.new_create_tables("db1", "stb1", 15*10000)
+
+        # tdSql.execute("create database db4 vgroups 4")
+        # self.create_tables("db4", "stb4", 30*10000)
+
+        # tdSql.execute("create database db6 vgroups 6")
+        # self.create_tables("db6", "stb6", 30*10000)
+
+        # tdSql.execute("create database db8 vgroups 8")
+        # self.create_tables("db8", "stb8", 30*10000)
+
+        # tdSql.execute("create database db12 vgroups 12")
+        # self.create_tables("db12", "stb12", 30*10000)
+
+        # tdSql.execute("create database db16 vgroups 16")
+        # self.create_tables("db16", "stb16", 30*10000)
+        return 
+
+    # test case2 base:insert data
+    def test_case2(self):
+
+        tdLog.debug("-----insert data test------- ")
+        # drop database
+        tdSql.execute("drop database if exists db1")
+        tdSql.execute("drop database if exists db4")
+        tdSql.execute("drop database if exists db6")
+        tdSql.execute("drop database if exists db8")
+        tdSql.execute("drop database if exists db12")
+        tdSql.execute("drop database if exists db16")
+
+        #create database and tables;
+
+        tdSql.execute("create database db1 vgroups 1")
+        self.create_tables("db1", "stb1", 1*100)
+        self.insert_data("db1", "stb1", self.ts, 1*50,1*10000)
+        
+
+        tdSql.execute("create database db4 vgroups 4")
+        self.create_tables("db4", "stb4", 1*100)
+        self.insert_data("db4", "stb4", self.ts, 1*100,1*10000)
+
+        tdSql.execute("create database db6 vgroups 6")
+        self.create_tables("db6", "stb6", 1*100)
+        self.insert_data("db6", "stb6", self.ts, 1*100,1*10000)
+
+        tdSql.execute("create database db8 vgroups 8")
+        self.create_tables("db8", "stb8", 1*100)
+        self.insert_data("db8", "stb8", self.ts, 1*100,1*10000)
+
+        tdSql.execute("create database db12 vgroups 12")
+        self.create_tables("db12", "stb12", 1*100)
+        self.insert_data("db12", "stb12", self.ts, 1*100,1*10000)
+
+        tdSql.execute("create database db16 vgroups 16")
+        self.create_tables("db16", "stb16", 1*100)
+        self.insert_data("db16", "stb16", self.ts, 1*100,1*10000)
+                
+        return
+
+#
+# add case with filename
+#
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

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

@@ -5,6 +5,7 @@ from util.sql import *
 from util.cases import *
 from util.dnodes import *
 
+PRIMARY_COL = "ts"
 
 INT_COL     = "c1"
 BINT_COL    = "c2"
@@ -18,9 +19,10 @@ BINARY_COL  = "c8"
 NCHAR_COL   = "c9"
 TS_COL      = "c10"
 
-UN_CHAR_COL = [INT_COL, BINT_COL, SINT_COL, TINT_COL, FLOAT_COL, DOUBLE_COL, BOOL_COL, ]
+NUM_COL     = [ INT_COL, BINT_COL, SINT_COL, TINT_COL, FLOAT_COL, DOUBLE_COL, ]
 CHAR_COL    = [ BINARY_COL, NCHAR_COL, ]
-TS_TYPE_COL = [TS_COL]
+BOOLEAN_COL = [ BOOL_COL, ]
+TS_TYPE_COL = [ TS_COL, ]
 
 class TDTestCase:
 
@@ -28,88 +30,171 @@ class TDTestCase:
         tdLog.debug(f"start to excute {__file__}")
         tdSql.init(conn.cursor())
 
-    def __length_condition(self):
+    def __query_condition(self,tbname):
-        length_condition = []
+        query_condition = []
         for char_col in CHAR_COL:
-            length_condition.extend(
+            query_condition.extend(
                 (
-                    char_col,
+                    f"{tbname}.{char_col}",
-                    f"upper( {char_col} )",
+                    f"upper( {tbname}.{char_col} )",
                 )
             )
-            length_condition.extend( f"cast( {un_char_col} as binary(16) ) " for un_char_col in UN_CHAR_COL)
+            query_condition.extend( f"cast( {tbname}.{un_char_col} as binary(16) ) " for un_char_col in NUM_COL)
-            length_condition.extend( f"cast( {char_col} + {char_col_2} as binary(32) ) " for char_col_2 in CHAR_COL )
+            query_condition.extend( f"cast( {tbname}.{char_col} + {tbname}.{char_col_2} as binary(32) ) " for char_col_2 in CHAR_COL )
-            length_condition.extend( f"cast( {char_col} + {un_char_col} as binary(32) ) " for un_char_col in UN_CHAR_COL )
+            query_condition.extend( f"cast( {tbname}.{char_col} + {tbname}.{un_char_col} as binary(32) ) " for un_char_col in NUM_COL )
+        for num_col in NUM_COL:
+            query_condition.extend(
+                (
+                    f"{tbname}.{num_col}",
+                    f"sin( {tbname}.{num_col} )"
+                )
+            )
+            query_condition.extend( f"{tbname}.{num_col} + {tbname}.{num_col_1} " for num_col_1 in NUM_COL )
 
-        length_condition.append('''"test1234!@#$%^&*():'><?/.,][}{"''')
+        query_condition.append(''' "test1234!@#$%^&*():'><?/.,][}{" ''')
 
-        return length_condition
+        return query_condition
 
-    def __where_condition(self, col):
+    def __join_condition(self, tb_list, filter=PRIMARY_COL):
-        # return f" where count({col}) > 0 "
+        # sourcery skip: flip-comparison
+        if 1 == len(tb_list):
+            join_filter = f"{tb_list[0]}.{filter} = {tb_list[0]}.{filter} "
+        elif 2 == len(tb_list):
+            join_filter = f"{tb_list[0]}.{filter} = {tb_list[1]}.{filter} "
+        else:
+            join_filter = f"{tb_list[0]}.{filter} = {tb_list[1]}.{filter} "
+            for i in range(1, len(tb_list)-1 ):
+                join_filter += f"and {tb_list[i]}.{filter} = {tb_list[i+1]}.{filter}"
+
+        return join_filter
+
+    def __where_condition(self, col, tbname):
+        if col in NUM_COL:
+            return f" abs( {tbname}.{col} ) >= 0"
+        elif col in CHAR_COL:
+            return f" lower( {tbname}.{col} ) like 'bina%' or lower( {tbname}.{col} ) like '_cha%' "
+        elif col in BOOLEAN_COL:
+            return f" {tbname}.{col} in (false, true)  "
+        elif col in TS_TYPE_COL or col in PRIMARY_COL:
+            return f" cast( {tbname}.{col} as binary(16) ) is not null "
+        else:
             return ""
 
-    def __group_condition(self, col, having = ""):
+    def __group_condition(self, tbname, col, having = ""):
         return f" group by {col} having {having}" if having else f" group by {col} "
 
-    def __length_current_check(self, tbname):
+    def __join_check(self, tblist, checkrows, join_flag=True):
-        length_condition = self.__length_condition()
+        query_conditions = self.__query_condition(tblist[0])
-        for condition in length_condition:
+        join_condition = self.__join_condition(tb_list=tblist) if join_flag else " "
-            where_condition = self.__where_condition(condition)
+        for condition in query_conditions:
-            group_having = self.__group_condition(condition, having=f"{condition} is not null " )
+            where_condition =  self.__where_condition(col=condition, tbname=tblist[0])
-            group_no_having= self.__group_condition(condition )
+            group_having = self.__group_condition(tbname=tblist[0], col=condition, having=f"{condition} is not null " )
+            group_no_having= self.__group_condition(tbname=tblist[0], col=condition )
             groups = ["", group_having, group_no_having]
-
             for group_condition in groups:
-                tdSql.query(f"select {condition} from {tbname} {where_condition}  {group_condition} ")
+                if where_condition:
-                datas = [tdSql.getData(i,0) for i in range(tdSql.queryRows)]
+                    sql = f" select {condition} from {tblist[0]},{tblist[1]} where {join_condition} and {where_condition} {group_condition} "
-                length_data = [ len(str(data))  if data else None for data in datas ]
+                else:
-                tdSql.query(f"select length( {condition} ) from {tbname} {where_condition}  {group_condition}")
+                    sql = f" select {condition} from {tblist[0]},{tblist[1]} where {join_condition}  {group_condition} "
-                for i in range(len(length_data)):
-                    tdSql.checkData(i, 0, length_data[i] ) if length_data[i] else tdSql.checkData(i, 0, None)
 
-    def __length_err_check(self,tbname):
+                if not join_flag :
-        sqls = []
+                    tdSql.error(sql=sql)
+                if len(tblist) == 2:
+                    if "ct1" in tblist or "t1" in tblist:
+                        self.__join_current(sql, checkrows)
+                    elif where_condition or "not null" in group_condition:
+                        self.__join_current(sql, checkrows + 2 )
+                    elif group_condition:
+                        self.__join_current(sql, checkrows + 3 )
+                    else:
+                        self.__join_current(sql, checkrows + 5 )
+                if len(tblist) > 2 or len(tblist) < 1:
+                    tdSql.error(sql=sql)
 
-        for un_char_col in UN_CHAR_COL:
+    # def __join_err_check(self,tbname):
-            sqls.extend(
+    #     sqls = []
-                (
-                    f"select length( {un_char_col} ) from {tbname} ",
-                    f"select length(ceil( {un_char_col} )) from {tbname} ",
-                    f"select {un_char_col} from {tbname} group by length( {un_char_col} ) ",
-                )
-            )
 
-            sqls.extend( f"select length( {un_char_col} + {un_char_col_2} ) from {tbname} " for un_char_col_2 in UN_CHAR_COL )
+    #     for un_char_col in NUM_COL:
-            sqls.extend( f"select length( {un_char_col} + {ts_col} ) from {tbname} " for ts_col in TS_TYPE_COL )
+    #         sqls.extend(
+    #             (
+    #                 f"select length( {un_char_col} ) from {tbname} ",
+    #                 f"select length(ceil( {un_char_col} )) from {tbname} ",
+    #                 f"select {un_char_col} from {tbname} group by length( {un_char_col} ) ",
+    #             )
+    #         )
 
-        sqls.extend( f"select {char_col} from {tbname} group by length( {char_col} ) " for char_col in CHAR_COL)
+    #         sqls.extend( f"select length( {un_char_col} + {un_char_col_2} ) from {tbname} " for un_char_col_2 in NUM_COL )
-        sqls.extend( f"select length( {ts_col} ) from {tbname} " for ts_col in TS_TYPE_COL )
+    #         sqls.extend( f"select length( {un_char_col} + {ts_col} ) from {tbname} " for ts_col in TS_TYPE_COL )
-        sqls.extend( f"select length( {char_col} + {ts_col} ) from {tbname} " for char_col in UN_CHAR_COL for ts_col in TS_TYPE_COL)
+
-        sqls.extend( f"select length( {char_col} + {char_col_2} ) from {tbname} " for char_col in CHAR_COL for char_col_2 in CHAR_COL )
+    #     sqls.extend( f"select {char_col} from {tbname} group by length( {char_col} ) " for char_col in CHAR_COL)
-        sqls.extend( f"select upper({char_col}, 11) from {tbname} " for char_col in CHAR_COL )
+    #     sqls.extend( f"select length( {ts_col} ) from {tbname} " for ts_col in TS_TYPE_COL )
-        sqls.extend( f"select upper({char_col}) from {tbname} interval(2d) sliding(1d)" for char_col in CHAR_COL )
+    #     sqls.extend( f"select length( {char_col} + {ts_col} ) from {tbname} " for char_col in NUM_COL for ts_col in TS_TYPE_COL)
-        sqls.extend(
+    #     sqls.extend( f"select length( {char_col} + {char_col_2} ) from {tbname} " for char_col in CHAR_COL for char_col_2 in CHAR_COL )
-            (
+    #     sqls.extend( f"select upper({char_col}, 11) from {tbname} " for char_col in CHAR_COL )
-                f"select length() from {tbname} ",
+    #     sqls.extend( f"select upper({char_col}) from {tbname} interval(2d) sliding(1d)" for char_col in CHAR_COL )
-                f"select length(*) from {tbname} ",
+    #     sqls.extend(
-                f"select length(ccccccc) from {tbname} ",
+    #         (
-                f"select length(111) from {tbname} ",
+    #             f"select length() from {tbname} ",
-                f"select length(c8, 11) from {tbname} ",
+    #             f"select length(*) from {tbname} ",
-            )
+    #             f"select length(ccccccc) from {tbname} ",
-        )
+    #             f"select length(111) from {tbname} ",
+    #             f"select length(c8, 11) from {tbname} ",
+    #         )
+    #     )
+
+    #     return sqls
+
+    def __join_current(self, sql, checkrows):
+        tdSql.query(sql=sql)
+        tdSql.checkRows(checkrows)
 
-        return sqls
 
     def __test_current(self):
+        # sourcery skip: extract-duplicate-method, inline-immediately-returned-variable
         tdLog.printNoPrefix("==========current sql condition check , must return query ok==========")
-        tbname = ["ct1", "ct2", "ct4", "t1"]
+        tblist_1 = ["ct1", "ct2"]
-        for tb in tbname:
+        self.__join_check(tblist_1, 1)
-            self.__length_current_check(tb)
+        tdLog.printNoPrefix(f"==========current sql condition check in {tblist_1} over==========")
-            tdLog.printNoPrefix(f"==========current sql condition check in {tb} over==========")
+        tblist_2 = ["ct2", "ct4"]
+        self.__join_check(tblist_2, self.rows)
+        tdLog.printNoPrefix(f"==========current sql condition check in {tblist_2} over==========")
+        tblist_3 = ["t1", "ct4"]
+        self.__join_check(tblist_3, 1)
+        tdLog.printNoPrefix(f"==========current sql condition check in {tblist_3} over==========")
+        tblist_4 = ["t1", "ct1"]
+        self.__join_check(tblist_4, 1)
+        tdLog.printNoPrefix(f"==========current sql condition check in {tblist_4} over==========")
 
     def __test_error(self):
+        # sourcery skip: extract-duplicate-method, move-assign-in-block
         tdLog.printNoPrefix("==========err sql condition check , must return error==========")
+        err_list_1 = ["ct1","ct2", "ct4"]
+        err_list_2 = ["ct1","ct2", "t1"]
+        err_list_3 = ["ct1","ct4", "t1"]
+        err_list_4 = ["ct2","ct4", "t1"]
+        err_list_5 = ["ct1", "ct2","ct4", "t1"]
+        self.__join_check(err_list_1, -1)
+        tdLog.printNoPrefix(f"==========err sql condition check in {err_list_1} over==========")
+        self.__join_check(err_list_2, -1)
+        tdLog.printNoPrefix(f"==========err sql condition check in {err_list_2} over==========")
+        self.__join_check(err_list_3, -1)
+        tdLog.printNoPrefix(f"==========err sql condition check in {err_list_3} over==========")
+        self.__join_check(err_list_4, -1)
+        tdLog.printNoPrefix(f"==========err sql condition check in {err_list_4} over==========")
+        self.__join_check(err_list_5, -1)
+        tdLog.printNoPrefix(f"==========err sql condition check in {err_list_5} over==========")
+        self.__join_check(["ct2", "ct4"], -1, join_flag=False)
+        tdLog.printNoPrefix("==========err sql condition check in has no join condition over==========")
+
+        tdSql.error( f"select c1, c2 from ct2, ct4 where ct2.{PRIMARY_COL}=ct4.{PRIMARY_COL}" )
+        tdSql.error( f"select ct2.c1, ct2.c2 from ct2, ct4 where ct2.{INT_COL}=ct4.{INT_COL}" )
+        tdSql.error( f"select ct2.c1, ct2.c2 from ct2, ct4 where ct2.{TS_COL}=ct4.{TS_COL}" )
+        tdSql.error( f"select ct2.c1, ct2.c2 from ct2, ct4 where ct2.{PRIMARY_COL}=ct4.{TS_COL}" )
+        tdSql.error( f"select ct2.c1, ct1.c2 from ct2, ct4 where ct2.{PRIMARY_COL}=ct4.{PRIMARY_COL}" )
+        tdSql.error( f"select ct2.c1, ct4.c2 from ct2, ct4 where ct2.{PRIMARY_COL}=ct4.{PRIMARY_COL} and c1 is not null " )
+        tdSql.error( f"select ct2.c1, ct4.c2 from ct2, ct4 where ct2.{PRIMARY_COL}=ct4.{PRIMARY_COL} and ct1.c1 is not null " )
+
+
         tbname = ["ct1", "ct2", "ct4", "t1"]
 
         for tb in tbname:
@@ -150,33 +235,33 @@ class TDTestCase:
         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 } )"
+                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 } )"
+                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 } )"
+                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', 'nchar0', { now_time + 8 } )
+            ( { 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', 'nchar9', { now_time + 9 } )
+            ( { 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 - 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}
+                { 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}
+                { 3.2 * pow(10,38) }, { 1.2 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000}
                 )
             '''
         )
@@ -184,15 +269,15 @@ class TDTestCase:
         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 - 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 }
+                { -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 }
+                { - 3.3 * pow(10,38) }, { -1.3 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 }
                 )
             '''
         )
@@ -200,7 +285,7 @@ class TDTestCase:
         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 } )
+                "binary_{i}", "nchar_测试_{i}", { now_time - 1000 * i } )
                 '''
             tdSql.execute(insert_data)
         tdSql.execute(
@@ -210,12 +295,12 @@ class TDTestCase:
             ( { 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 }
+                "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 }
+                "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 }
                 )
             '''
         )
@@ -228,7 +313,8 @@ class TDTestCase:
         self.__create_tb()
 
         tdLog.printNoPrefix("==========step2:insert data")
-        self.__insert_data(10)
+        self.rows = 10
+        self.__insert_data(self.rows)
 
         tdLog.printNoPrefix("==========step3:all check")
         self.all_test()

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

@@ -191,13 +191,13 @@ class TDTestCase:
     def support_types(self):
         type_error_sql_lists = [
             "select log(ts ,2 ) from t1" , 
-            "select log(c7,2 ) from t1",
+            "select log(c7,c2 ) from t1",
-            "select log(c8,2 ) from t1",
+            "select log(c8,c1 ) from t1",
-            "select log(c9,2 ) from t1",
+            "select log(c9,c2 ) from t1",
-            "select log(ts,2 ) from ct1" , 
+            "select log(ts,c7 ) from ct1" , 
-            "select log(c7,2 ) from ct1",
+            "select log(c7,c9 ) from ct1",
-            "select log(c8,2 ) from ct1",
+            "select log(c8,c2 ) from ct1",
-            "select log(c9,2 ) from ct1",
+            "select log(c9,c1 ) from ct1",
             "select log(ts,2 ) from ct3" , 
             "select log(c7,2 ) from ct3",
             "select log(c8,2 ) from ct3",

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

@@ -0,0 +1,652 @@
+import taos
+import sys
+import datetime
+import inspect
+import math
+from util.log import *
+from util.sql import *
+from util.cases import *
+
+
+class TDTestCase:
+    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 , 
+    "jniDebugFlag":143 ,"simDebugFlag":143,"dDebugFlag":143, "dDebugFlag":143,"vDebugFlag":143,"mDebugFlag":143,"qDebugFlag":143,
+    "wDebugFlag":143,"sDebugFlag":143,"tsdbDebugFlag":143,"tqDebugFlag":143 ,"fsDebugFlag":143 ,"fnDebugFlag":143}
+    def init(self, conn, powSql):
+        tdLog.debug(f"start to excute {__file__}")
+        tdSql.init(conn.cursor())
+    
+    def prepare_datas(self):
+        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()+90d, 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 )
+            '''
+        )
+    
+    def check_result_auto_pow2(self ,origin_query , pow_query):
+
+        pow_result = tdSql.getResult(pow_query)
+        origin_result = tdSql.getResult(origin_query)
+
+        auto_result =[]
+        
+        for row in origin_result:
+            row_check = []
+            for elem in row:
+                if elem == None:
+                    elem = None
+                else:
+                    elem = math.pow(elem,2)
+                row_check.append(elem)
+            auto_result.append(row_check)
+
+        check_status = True
+
+        for row_index , row in enumerate(pow_result):
+            for col_index , elem in enumerate(row):
+                if auto_result[row_index][col_index] == None  and not (auto_result[row_index][col_index] == None and elem == None):
+                    check_status = False
+                elif auto_result[row_index][col_index] != None  and (auto_result[row_index][col_index] - elem > 0.00000001):
+                    check_status = False 
+                else:
+                    pass
+        if not check_status:
+            tdLog.notice("pow function value has not as expected , sql is \"%s\" "%pow_query )
+            sys.exit(1)
+        else:
+            tdLog.info("pow value check pass , it work as expected ,sql is \"%s\"   "%pow_query )
+
+    def check_result_auto_pow1(self ,origin_query , pow_query):
+        pow_result = tdSql.getResult(pow_query)
+        origin_result = tdSql.getResult(origin_query)
+
+        auto_result =[]
+        
+        for row in origin_result:
+            row_check = []
+            for elem in row:
+                if elem == None:
+                    elem = None
+                else :
+                    elem = pow(elem ,1)
+                row_check.append(elem)
+            auto_result.append(row_check)
+
+        check_status = True
+        for row_index , row in enumerate(pow_result):
+            for col_index , elem in enumerate(row):
+                if auto_result[row_index][col_index] == None  and not (auto_result[row_index][col_index] == None and elem == None):
+                    check_status = False
+                elif auto_result[row_index][col_index] != None  and (auto_result[row_index][col_index] - elem > 0.00000001):
+                    check_status = False 
+                else:
+                    pass
+        if not check_status:
+            tdLog.notice("pow function value has not as expected , sql is \"%s\" "%pow_query )
+            sys.exit(1)
+        else:
+            tdLog.info("pow value check pass , it work as expected ,sql is \"%s\"   "%pow_query )
+
+    def check_result_auto_pow__10(self ,origin_query , pow_query):
+        pow_result = tdSql.getResult(pow_query)
+        origin_result = tdSql.getResult(origin_query)
+
+        auto_result =[]
+        
+        for row in origin_result:
+            row_check = []
+            for elem in row:
+                if elem == None:
+                    elem = None
+                elif elem == 0:
+                    elem = None
+                else:
+                    elem = pow(elem ,-10)
+                row_check.append(elem)
+            auto_result.append(row_check)
+
+        check_status = True
+        for row_index , row in enumerate(pow_result):
+            for col_index , elem in enumerate(row):
+                if auto_result[row_index][col_index] == None  and not (auto_result[row_index][col_index] == None and elem == None):
+                    check_status = False
+                elif auto_result[row_index][col_index] != None  and (auto_result[row_index][col_index] - elem > 0.00000001):
+                    check_status = False 
+                else:
+                    pass
+        if not check_status:
+            tdLog.notice("pow function value has not as expected , sql is \"%s\" "%pow_query )
+            sys.exit(1)
+        else:
+            tdLog.info("pow value check pass , it work as expected ,sql is \"%s\"   "%pow_query )
+        
+    def test_errors(self):
+        error_sql_lists = [
+            "select pow from t1",
+            # "select pow(-+--+c1 ,2) from t1",
+            # "select +-pow(c1,2) from t1",
+            # "select ++-pow(c1,2) from t1",
+            # "select ++--pow(c1,2) from t1",
+            # "select - -pow(c1,2)*0 from t1",
+            # "select pow(tbname+1,2) from t1 ",
+            "select pow(123--123,2)==1 from t1",
+            "select pow(c1,2) as 'd1' from t1",
+            "select pow(c1 ,c2 ,2) from t1",
+            "select pow(c1 ,NULL ,2) from t1",
+            "select pow(, 2) from t1;",
+            "select pow(pow(c1, 2) ab from t1)",
+            "select pow(c1 ,2 ) as int from t1",
+            "select pow from stb1",
+            # "select pow(-+--+c1) from stb1",
+            # "select +-pow(c1) from stb1",
+            # "select ++-pow(c1) from stb1",
+            # "select ++--pow(c1) from stb1",
+            # "select - -pow(c1)*0 from stb1",
+            # "select pow(tbname+1) from stb1 ",
+            "select pow(123--123 ,2)==1 from stb1",
+            "select pow(c1 ,2) as 'd1' from stb1",
+            "select pow(c1 ,c2 ,2 ) from stb1",
+            "select pow(c1 ,NULL,2) from stb1",
+            "select pow(,) from stb1;",
+            "select pow(pow(c1 , 2) ab from stb1)",
+            "select pow(c1 , 2) as int from stb1"
+        ]
+        for error_sql in error_sql_lists:
+            tdSql.error(error_sql)
+    
+    def support_types(self):
+        type_error_sql_lists = [
+            "select pow(ts ,2 ) from t1" , 
+            "select pow(c7,c1 ) from t1",
+            "select pow(c8,c2) from t1",
+            "select pow(c9,c3 ) from t1",
+            "select pow(ts,c4 ) from ct1" , 
+            "select pow(c7,c5 ) from ct1",
+            "select pow(c8,c6 ) from ct1",
+            "select pow(c9,c8 ) from ct1",
+            "select pow(ts,2 ) from ct3" , 
+            "select pow(c7,2 ) from ct3",
+            "select pow(c8,2 ) from ct3",
+            "select pow(c9,2 ) from ct3",
+            "select pow(ts,2 ) from ct4" , 
+            "select pow(c7,2 ) from ct4",
+            "select pow(c8,2 ) from ct4",
+            "select pow(c9,2 ) from ct4",
+            "select pow(ts,2 ) from stb1" , 
+            "select pow(c7,2 ) from stb1",
+            "select pow(c8,2 ) from stb1",
+            "select pow(c9,2 ) from stb1" ,
+
+            "select pow(ts,2 ) from stbbb1" , 
+            "select pow(c7,2 ) from stbbb1",
+
+            "select pow(ts,2 ) from tbname",
+            "select pow(c9,2 ) from tbname"
+
+        ]
+        
+        for type_sql in type_error_sql_lists:
+            tdSql.error(type_sql)
+        
+        
+        type_sql_lists = [
+            "select pow(c1,2 ) from t1",
+            "select pow(c2,2 ) from t1",
+            "select pow(c3,2 ) from t1",
+            "select pow(c4,2 ) from t1",
+            "select pow(c5,2 ) from t1",
+            "select pow(c6,2 ) from t1",
+
+            "select pow(c1,2 ) from ct1",
+            "select pow(c2,2 ) from ct1",
+            "select pow(c3,2 ) from ct1",
+            "select pow(c4,2 ) from ct1",
+            "select pow(c5,2 ) from ct1",
+            "select pow(c6,2 ) from ct1",
+
+            "select pow(c1,2 ) from ct3",
+            "select pow(c2,2 ) from ct3",
+            "select pow(c3,2 ) from ct3",
+            "select pow(c4,2 ) from ct3",
+            "select pow(c5,2 ) from ct3",
+            "select pow(c6,2 ) from ct3",
+
+            "select pow(c1,2 ) from stb1",
+            "select pow(c2,2 ) from stb1",
+            "select pow(c3,2 ) from stb1",
+            "select pow(c4,2 ) from stb1",
+            "select pow(c5,2 ) from stb1",
+            "select pow(c6,2 ) from stb1",
+
+            "select pow(c6,2) as alisb from stb1", 
+            "select pow(c6,2) alisb from stb1", 
+        ]
+
+        for type_sql in type_sql_lists:
+            tdSql.query(type_sql)
+    
+    def basic_pow_function(self):
+
+        # basic query 
+        tdSql.query("select c1 from ct3")
+        tdSql.checkRows(0)
+        tdSql.query("select c1 from t1")
+        tdSql.checkRows(12)
+        tdSql.query("select c1 from stb1")
+        tdSql.checkRows(25)
+
+        # used for empty table  , ct3 is empty
+        tdSql.query("select pow(c1 ,2) from ct3")
+        tdSql.checkRows(0)
+        tdSql.query("select pow(c2 ,2) from ct3")
+        tdSql.checkRows(0)
+        tdSql.query("select pow(c3 ,2) from ct3")
+        tdSql.checkRows(0)
+        tdSql.query("select pow(c4 ,2) from ct3")
+        tdSql.checkRows(0)
+        tdSql.query("select pow(c5 ,2) from ct3")
+        tdSql.checkRows(0)
+        tdSql.query("select pow(c6 ,2) from ct3")
+        tdSql.checkRows(0)
+
+
+        # # used for regular table
+        tdSql.query("select pow(c1 ,2) from t1")
+        tdSql.checkData(0, 0, None)
+        tdSql.checkData(1 , 0, 1.000000000)
+        tdSql.checkData(3 , 0, 9.000000000)
+        tdSql.checkData(5 , 0, None)
+
+        tdSql.query("select c1, c2, c3 , c4, c5 from t1")
+        tdSql.checkData(1, 4, 1.11000)
+        tdSql.checkData(3, 3, 33)
+        tdSql.checkData(5, 4, None)
+
+        tdSql.query("select ts,c1, c2, c3 , c4, c5 from t1")
+        tdSql.checkData(1, 5, 1.11000)
+        tdSql.checkData(3, 4, 33)
+        tdSql.checkData(5, 5, None)
+
+        self.check_result_auto_pow2( "select c1, c2, c3 , c4, c5 from t1", "select pow(c1 ,2), pow(c2 ,2) ,pow(c3, 2), pow(c4 ,2), pow(c5 ,2) from t1")
+        self.check_result_auto_pow1( "select c1, c2, c3 , c4, c5 from t1", "select pow(c1 ,1), pow(c2 ,1) ,pow(c3, 1), pow(c4 ,1), pow(c5 ,1) from t1")
+        self.check_result_auto_pow__10( "select c1, c2, c3 , c4, c5 from t1", "select pow(c1 ,-10), pow(c2 ,-10) ,pow(c3, -10), pow(c4 ,-10), pow(c5 ,-10) from t1")
+        
+        # used for sub table
+        tdSql.query("select c1 ,pow(c1 ,2) from ct1")
+        tdSql.checkData(0, 1, 64.000000000)
+        tdSql.checkData(1 , 1, 49.000000000)
+        tdSql.checkData(3 , 1, 25.000000000)
+        tdSql.checkData(4 , 1, 0)
+
+        # # test bug fix for pow(c1,c2)
+
+        tdSql.query("select c1, c5 ,pow(c1,c5) from ct4")
+        tdSql.checkData(0 , 2, None)
+        tdSql.checkData(1 , 2, 104577724.506799981)
+        tdSql.checkData(2 , 2, 3684781.623933245)
+        tdSql.checkData(3 , 2, 152225.429759376)
+        tdSql.checkData(4 , 2, 7573.273783071)
+
+
+        self.check_result_auto_pow2( "select c1, c2, c3 , c4, c5 from ct1", "select pow(c1,2), pow(c2,2) ,pow(c3,2), pow(c4,2), pow(c5,2) from ct1")
+        self.check_result_auto_pow__10( "select c1, c2, c3 , c4, c5 from ct1", "select pow(c1,-10), pow(c2,-10) ,pow(c3,-10), pow(c4,-10), pow(c5,-10) from ct1")
+
+        # nest query for pow functions
+        tdSql.query("select c1  , pow(c1,2) ,pow(pow(c1,2),2) , pow(pow(pow(c1,2),2),2) from ct1;")
+        tdSql.checkData(0 , 0 , 8)
+        tdSql.checkData(0 , 1 , 64.000000000)
+        tdSql.checkData(0 , 2 , 4096.000000000)
+        tdSql.checkData(0 , 3 , 16777216.000000000)
+
+        tdSql.checkData(1 , 0 , 7)
+        tdSql.checkData(1 , 1 , 49.000000000)
+        tdSql.checkData(1 , 2 , 2401.000000000)
+        tdSql.checkData(1 , 3 , 5764801.000000000)
+
+        tdSql.checkData(4 , 0 , 0)
+        tdSql.checkData(4 , 1 , 0.000000000)
+        tdSql.checkData(4 , 2 , 0.000000000)
+        tdSql.checkData(4 , 3 , 0.000000000)
+
+        # # used for stable table 
+        
+        tdSql.query("select pow(c1, 2) from stb1")
+        tdSql.checkRows(25)
+      
+
+        # used for not exists table
+        tdSql.error("select pow(c1, 2) from stbbb1")
+        tdSql.error("select pow(c1, 2) from tbname")
+        tdSql.error("select pow(c1, 2) from ct5")
+
+        # mix with common col 
+        tdSql.query("select c1, pow(c1 ,2) from ct1")
+        tdSql.checkData(0 , 0 ,8)
+        tdSql.checkData(0 , 1 ,64.000000000)
+        tdSql.checkData(4 , 0 ,0)
+        tdSql.checkData(4 , 1 ,0.000000000)
+        tdSql.query("select c1, pow(c1,2) from ct4")
+        tdSql.checkData(0 , 0 , None)
+        tdSql.checkData(0 , 1 ,None)
+        tdSql.checkData(4 , 0 ,5)
+        tdSql.checkData(4 , 1 ,25.000000000)
+        tdSql.checkData(5 , 0 ,None)
+        tdSql.checkData(5 , 1 ,None)
+
+        # mix with common functions
+        tdSql.query("select c1, pow(c1 ,2),pow(c1,2), log(pow(c1,2) ,2) from ct4 ")
+        tdSql.checkData(0 , 0 ,None)
+        tdSql.checkData(0 , 1 ,None)
+        tdSql.checkData(0 , 2 ,None)
+        tdSql.checkData(0 , 3 ,None)
+        
+        tdSql.checkData(3 , 0 , 6)
+        tdSql.checkData(3 , 1 ,36.000000000)
+        tdSql.checkData(3 , 2 ,36.000000000)
+        tdSql.checkData(3 , 3 ,5.169925001)
+
+        tdSql.query("select c1, pow(c1,1),c5, floor(c5 ) from stb1 ")
+
+        # # mix with agg functions , not support
+        tdSql.error("select c1, pow(c1 ,2),c5, count(c5) from stb1 ")
+        tdSql.error("select c1, pow(c1 ,2),c5, count(c5) from ct1 ")
+        tdSql.error("select pow(c1 ,2), count(c5) from stb1 ")
+        tdSql.error("select pow(c1 ,2), count(c5) from ct1 ")
+        tdSql.error("select c1, count(c5) from ct1 ")
+        tdSql.error("select c1, count(c5) from stb1 ")
+
+        # agg functions mix with agg functions
+
+        tdSql.query("select max(c5), count(c5) from stb1")
+        tdSql.query("select max(c5), count(c5) from ct1")
+
+        
+        # bug fix for count
+        tdSql.query("select count(c1) from ct4 ")
+        tdSql.checkData(0,0,9)
+        tdSql.query("select count(*) from ct4 ")
+        tdSql.checkData(0,0,12)
+        tdSql.query("select count(c1) from stb1 ")
+        tdSql.checkData(0,0,22)
+        tdSql.query("select count(*) from stb1 ")
+        tdSql.checkData(0,0,25)
+
+        # # bug fix for compute 
+        tdSql.query("select c1, pow(c1 ,2) -0 ,pow(c1-4 ,2)-0 from ct4 ")
+        tdSql.checkData(0, 0, None)
+        tdSql.checkData(0, 1, None)
+        tdSql.checkData(0, 2, None)
+        tdSql.checkData(1, 0, 8)
+        tdSql.checkData(1, 1, 64.000000000)
+        tdSql.checkData(1, 2, 16.000000000)
+
+        tdSql.query(" select c1, pow(c1 ,2) -0 ,pow(c1-0.1 ,2)-0.1 from ct4")
+        tdSql.checkData(0, 0, None)
+        tdSql.checkData(0, 1, None)
+        tdSql.checkData(0, 2, None)
+        tdSql.checkData(1, 0, 8)
+        tdSql.checkData(1, 1, 64.000000000)
+        tdSql.checkData(1, 2, 62.310000000)
+
+        tdSql.query("select c1, pow(c1, -10), c2, pow(c2, -10), c3, pow(c3, -10) from ct1")
+
+    def test_big_number(self):
+
+        tdSql.query("select c1, pow(c1, 100000000) from ct1")  # bigint to double data overflow
+        tdSql.checkData(0, 1, None)
+        tdSql.checkData(1, 1, None)
+        tdSql.checkData(4, 1, 0.000000000)
+
+
+        tdSql.query("select c1, pow(c1, 10000000000000) from ct1")  # bigint to double data overflow
+        tdSql.checkData(0, 1, None)
+        tdSql.checkData(1, 1, None)
+        tdSql.checkData(4, 1, 0.000000000)
+
+        tdSql.query("select c1, pow(c1, 10000000000000000000000000) from ct1")  # bigint to double data overflow
+        tdSql.query("select c1, pow(c1, 10000000000000000000000000.0) from ct1") # 10000000000000000000000000.0 is a double value
+        tdSql.checkData(0, 1, None)
+        tdSql.checkData(1, 1, None)
+        tdSql.checkData(4, 1, 0.000000000)
+
+        tdSql.query("select c1, pow(c1, 10000000000000000000000000000000000) from ct1")  # bigint to double data overflow
+        tdSql.query("select c1, pow(c1, 10000000000000000000000000000000000.0) from ct1") # 10000000000000000000000000.0 is a double value
+        tdSql.checkData(0, 1, None)
+        tdSql.checkData(1, 1, None)
+        tdSql.checkData(4, 1, 0.000000000)
+
+        tdSql.query("select c1, pow(c1, 10000000000000000000000000000000000000000) from ct1")  # bigint to double data overflow
+        tdSql.query("select c1, pow(c1, 10000000000000000000000000000000000000000.0) from ct1") # 10000000000000000000000000.0 is a double value
+        tdSql.checkData(0, 1, None)
+        tdSql.checkData(1, 1, None)
+        tdSql.checkData(4, 1, 0.000000000)
+
+        tdSql.query("select c1, pow(c1, 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) from ct1")  # bigint to double data overflow
+
+    def pow_base_test(self):
+
+        # base is an regular number ,int or double
+        tdSql.query("select c1, pow(c1, 2) from ct1")
+        tdSql.checkData(0, 1,64.000000000)
+        tdSql.query("select c1, pow(c1, 2.0) from ct1")  
+        tdSql.checkData(0, 1, 64.000000000)
+
+        tdSql.query("select c1, pow(1, 2.0) from ct1")  
+        tdSql.checkData(0, 1, 1.000000000)
+        tdSql.checkRows(13)
+
+
+        # # bug for compute in functions
+        # tdSql.query("select c1, abs(1/0) from ct1") 
+        # tdSql.checkData(0, 0, 8)
+        # tdSql.checkData(0, 1, 1)
+
+        tdSql.query("select c1, pow(1, 2.0) from ct1")  
+        tdSql.checkData(0, 1, 1.000000000)
+        tdSql.checkRows(13)
+
+        # two cols start pow(x,y)
+        tdSql.query("select c1,c2, pow(c1,c2) from ct1") 
+        tdSql.checkData(0, 2, None)
+        tdSql.checkData(1, 2, None)
+        tdSql.checkData(4, 2, 1.000000000)
+
+        tdSql.query("select c1,c2, pow(c2,c1) from ct1") 
+        tdSql.checkData(0, 2, 3897131646727578700481513520437089271808.000000000)
+        tdSql.checkData(1, 2, 17217033054561120738612297152331776.000000000)
+        tdSql.checkData(4, 2, 1.000000000)
+
+        tdSql.query("select c1, pow(2.0 , c1) from ct1") 
+        tdSql.checkData(0, 1, 256.000000000)
+        tdSql.checkData(1, 1, 128.000000000)
+        tdSql.checkData(4, 1, 1.000000000)
+
+        tdSql.query("select c1, pow(2.0 , c1) from ct1") 
+        tdSql.checkData(0, 1, 256.000000000)
+        tdSql.checkData(1, 1, 128.000000000)
+        tdSql.checkData(4, 1, 1.000000000)
+
+    def abs_func_filter(self):
+        tdSql.execute("use db")
+        tdSql.query("select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(pow(c1,2)-0.5) from ct4 where c1>5 ")
+        tdSql.checkRows(3)
+        tdSql.checkData(0,0,8)
+        tdSql.checkData(0,1,8.000000000)
+        tdSql.checkData(0,2,8.000000000)
+        tdSql.checkData(0,3,7.900000000)
+        tdSql.checkData(0,4,64.000000000)
+
+        tdSql.query("select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(pow(c1,2)-0.5) from ct4 where c1=5 ")
+        tdSql.checkRows(1)
+        tdSql.checkData(0,0,5)
+        tdSql.checkData(0,1,5.000000000)
+        tdSql.checkData(0,2,5.000000000)
+        tdSql.checkData(0,3,4.900000000)
+        tdSql.checkData(0,4,25.000000000)
+
+        tdSql.query("select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(pow(c1,2)-0.5) from ct4 where c1=5 ")
+        tdSql.checkRows(1)
+        tdSql.checkData(0,0,5)
+        tdSql.checkData(0,1,5.000000000)
+        tdSql.checkData(0,2,5.000000000)
+        tdSql.checkData(0,3,4.900000000)
+        tdSql.checkData(0,4,25.000000000)
+
+        tdSql.query("select c1,c2 , abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(pow(c1,2)-0.5) from ct4 where c1<pow(c1,2) limit 1 ")
+        tdSql.checkRows(1)
+        tdSql.checkData(0,0,8)
+        tdSql.checkData(0,1,88888)
+        tdSql.checkData(0,2,8.000000000)
+        tdSql.checkData(0,3,8.000000000)
+        tdSql.checkData(0,4,7.900000000)
+        tdSql.checkData(0,5,64.000000000)
+        
+    def pow_Arithmetic(self):
+        pass
+    
+    def check_boundary_values(self):
+
+        tdSql.execute("drop database if exists bound_test")
+        tdSql.execute("create database if not exists bound_test")
+        time.sleep(3)
+        tdSql.execute("use bound_test")
+        tdSql.execute(
+            "create table stb_bound (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(32),c9 nchar(32), c10 timestamp) tags (t1 int);"
+        )
+        tdSql.execute(f'create table sub1_bound using stb_bound tags ( 1 )')
+        tdSql.execute(
+                f"insert into sub1_bound values ( now()-1s, 2147483647, 9223372036854775807, 32767, 127, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            )
+        tdSql.execute(
+                f"insert into sub1_bound values ( now()-1s, -2147483647, -9223372036854775807, -32767, -127, -3.40E+38, -1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            )
+        tdSql.execute(
+                f"insert into sub1_bound values ( now(), 2147483646, 9223372036854775806, 32766, 126, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            )
+        tdSql.execute(
+                f"insert into sub1_bound values ( now(), -2147483646, -9223372036854775806, -32766, -126, -3.40E+38, -1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            )
+        tdSql.error(
+                f"insert into sub1_bound values ( now()+1s, 2147483648, 9223372036854775808, 32768, 128, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            )
+        self.check_result_auto_pow2( "select c1, c2, c3 , c4, c5 from sub1_bound ", "select pow(c1,2), pow(c2,2) ,pow(c3,2), pow(c4,2), pow(c5,2) from sub1_bound")
+        self.check_result_auto_pow__10( "select c1, c2, c3 , c4, c5  from sub1_bound ", "select pow(c1,-10), pow(c2,-10) ,pow(c3,-10), pow(c4,-10), pow(c5,-10) from sub1_bound")
+        
+        self.check_result_auto_pow2( "select c1, c2, c3 , c3, c2 ,c1 from sub1_bound ", "select pow(c1,2), pow(c2,2) ,pow(c3,2), pow(c3,2), pow(c2,2) ,pow(c1,2) from sub1_bound")
+
+
+        self.check_result_auto_pow2("select abs(abs(abs(abs(abs(abs(abs(abs(abs(c1)))))))))  nest_col_func from sub1_bound" , "select pow(abs(c1) ,2) from sub1_bound" )
+        
+        # check basic elem for table per row
+        tdSql.query("select pow(abs(c1),2) ,pow(abs(c2),2) , pow(abs(c3),2) , pow(abs(c4),2), pow(abs(c5),2), pow(abs(c6),2) from sub1_bound ")
+        tdSql.checkData(0,0,math.pow(2147483647,2))
+        tdSql.checkData(0,1,math.pow(9223372036854775807 ,2))
+        tdSql.checkData(0,2,math.pow(32767,2))
+        tdSql.checkData(0,3,math.pow(127 ,2))
+        tdSql.checkData(0,4,math.pow(339999995214436424907732413799364296704.00000,2))
+        tdSql.checkData(1,0,math.pow(2147483647 ,2))
+        tdSql.checkData(1,1,math.pow(9223372036854775807 ,2))
+        tdSql.checkData(1,2,math.pow(32767 ,2))
+        tdSql.checkData(1,3,math.pow(127,2))
+        tdSql.checkData(1,4,math.pow(339999995214436424907732413799364296704.00000 ,2))
+        tdSql.checkData(3,0,math.pow(2147483646,2))
+        tdSql.checkData(3,1,math.pow(9223372036854775806,2))
+        tdSql.checkData(3,2,math.pow(32766,2))
+        tdSql.checkData(3,3,math.pow(126 ,2))
+        tdSql.checkData(3,4,math.pow(339999995214436424907732413799364296704.00000,2))
+        
+        # check  + - * / in functions
+        tdSql.query("select pow(abs(c1+1) ,2) ,pow(abs(c2),2) , pow(abs(c3*1),2) , pow(abs(c4/2),2), pow(abs(c5) ,2)/2, pow(abs(c6) ,2) from sub1_bound ")
+        tdSql.checkData(0,0,math.pow(2147483648.000000000,2))
+        tdSql.checkData(0,1,math.pow(9223372036854775807,2))
+        tdSql.checkData(0,2,math.pow(32767.000000000,2))
+        tdSql.checkData(0,3,math.pow(63.500000000,2))
+        tdSql.checkData(0,5,None)
+      
+    
+    def run(self):  # sourcery skip: extract-duplicate-method, remove-redundant-fstring
+        tdSql.prepare()
+
+        tdLog.printNoPrefix("==========step1:create table ==============")
+        
+        self.prepare_datas()
+
+        tdLog.printNoPrefix("==========step2:test errors ==============")    
+
+        self.test_errors()
+        
+        tdLog.printNoPrefix("==========step3:support types ============") 
+
+        self.support_types()
+
+        tdLog.printNoPrefix("==========step4: pow basic query ============") 
+
+        self.basic_pow_function()
+
+        tdLog.printNoPrefix("==========step5: big number pow query ============") 
+
+        self.test_big_number()
+
+        tdLog.printNoPrefix("==========step6: base  number for pow query ============") 
+
+        self.pow_base_test()
+
+        tdLog.printNoPrefix("==========step7: pow boundary query ============") 
+
+        self.check_boundary_values()
+
+        tdLog.printNoPrefix("==========step8: pow filter query ============") 
+
+        self.abs_func_filter()
+
+        
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success(f"{__file__} successfully executed")
+
+tdCases.addLinux(__file__, TDTestCase())
+tdCases.addWindows(__file__, TDTestCase())

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

@@ -0,0 +1,131 @@
+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+
+from numpy.lib.function_base import insert
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+import numpy as np
+
+# constant define
+WAITS = 5 # wait seconds
+
+class TDTestCase:
+    #
+    # --------------- main frame -------------------
+    #
+    # updatecfgDict = {'debugFlag': 135}
+    # updatecfgDict = {'fqdn': 135}
+
+    def caseDescription(self):
+        '''
+        limit and offset keyword function test cases;
+        case1: limit offset base function test
+        case2: offset return valid
+        '''
+        return 
+
+    # init
+    def init(self, conn, logSql):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+        tdSql.prepare()
+        self.create_tables();
+        self.ts = 1500000000000
+
+
+    # run case  
+    def run(self):
+        # insert data
+        self.insert_data1("t1", self.ts, 1000*10000)
+        self.insert_data1("t4", self.ts, 1000*10000)        
+        # test base case
+        # self.test_case1()
+        tdLog.debug(" LIMIT test_case1 ............ [OK]")
+        # test advance case
+        # self.test_case2()
+        tdLog.debug(" LIMIT test_case2 ............ [OK]")
+
+
+    # stop 
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+    #
+    # --------------- case  -------------------
+    #
+
+    # create table
+    def create_tables(self):
+        # super table
+        tdSql.execute("create table st(ts timestamp, i1 int,i2 int) tags(area int)");
+        # child table
+        tdSql.execute("create table t1 using st tags(1)");
+
+        tdSql.execute("create table st1(ts timestamp, i1 int ,i2 int) tags(area int) sma(i2) ");
+        tdSql.execute("create table t4 using st1 tags(1)");
+
+        return 
+
+    # insert data1
+    def insert_data(self, tbname, ts_start, count):
+        pre_insert = "insert into %s values"%tbname
+        sql = pre_insert
+        tdLog.debug("doing insert table %s rows=%d ..."%(tbname, count))
+        for i in range(count):
+            sql += " (%d,%d)"%(ts_start + i*1000, i )
+            if i >0 and i%30000 == 0:
+                tdSql.execute(sql)
+                sql = pre_insert
+        # end sql        
+        if sql != pre_insert:
+            tdSql.execute(sql)
+
+        tdLog.debug("INSERT TABLE DATA ............ [OK]")
+        return
+
+    def insert_data1(self, tbname, ts_start, count):
+        pre_insert = "insert into %s values"%tbname
+        sql = pre_insert
+        tdLog.debug("doing insert table %s rows=%d ..."%(tbname, count))
+        for i in range(count):
+            sql += " (%d,%d,%d)"%(ts_start + i*1000, i , i+1)
+            if i >0 and i%30000 == 0:
+                tdSql.execute(sql)
+                sql = pre_insert
+        # end sql        
+        if sql != pre_insert:
+            tdSql.execute(sql)
+
+        tdLog.debug("INSERT TABLE DATA ............ [OK]")
+        return
+
+    # test case1 base 
+    # def test_case1(self):
+    #     # 
+    #     # limit base function
+    #     #
+    #     # base no where
+    #     sql = "select * from t1 limit 10"
+    #     tdSql.waitedQuery(sql, 10, WAITS)
+
+
+#
+# add case with filename
+#
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

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

@@ -0,0 +1,551 @@
+import taos
+import sys
+import datetime
+import inspect
+import math
+from util.log import *
+from util.sql import *
+from util.cases import *
+
+
+class TDTestCase:
+    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 , 
+    "jniDebugFlag":143 ,"simDebugFlag":143,"dDebugFlag":143, "dDebugFlag":143,"vDebugFlag":143,"mDebugFlag":143,"qDebugFlag":143,
+    "wDebugFlag":143,"sDebugFlag":143,"tsdbDebugFlag":143,"tqDebugFlag":143 ,"fsDebugFlag":143 ,"fnDebugFlag":143}
+    def init(self, conn, powSql):
+        tdLog.debug(f"start to excute {__file__}")
+        tdSql.init(conn.cursor())
+    
+    def prepare_datas(self):
+        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()+90d, 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 )
+            '''
+        )
+    
+    def check_result_auto_sqrt(self ,origin_query , pow_query):
+
+        pow_result = tdSql.getResult(pow_query)
+        origin_result = tdSql.getResult(origin_query)
+
+        auto_result =[]
+        
+        for row in origin_result:
+            row_check = []
+            for elem in row:
+                if elem == None:
+                    elem = None
+                elif elem < 0:
+                    elem = None
+                else:
+                    elem = math.sqrt(elem)
+                row_check.append(elem)
+            auto_result.append(row_check)
+
+        check_status = True
+
+        for row_index , row in enumerate(pow_result):
+            for col_index , elem in enumerate(row):
+                if auto_result[row_index][col_index] == None  and not (auto_result[row_index][col_index] == None and elem == None):
+                    check_status = False
+                elif auto_result[row_index][col_index] != None  and (auto_result[row_index][col_index] - elem > 0.00000001):
+                    check_status = False 
+                else:
+                    pass
+        if not check_status:
+            tdLog.notice("sqrt function value has not as expected , sql is \"%s\" "%pow_query )
+            sys.exit(1)
+        else:
+            tdLog.info("sqrt value check pass , it work as expected ,sql is \"%s\"   "%pow_query )
+        
+    def test_errors(self):
+        error_sql_lists = [
+            "select sqrt from t1",
+            # "select sqrt(-+--+c1 ) from t1",
+            # "select +-sqrt(c1) from t1",
+            # "select ++-sqrt(c1) from t1",
+            # "select ++--sqrt(c1) from t1",
+            # "select - -sqrt(c1)*0 from t1",
+            # "select sqrt(tbname+1) from t1 ",
+            "select sqrt(123--123)==1 from t1",
+            "select sqrt(c1) as 'd1' from t1",
+            "select sqrt(c1 ,c2) from t1",
+            "select sqrt(c1 ,NULL ) from t1",
+            "select sqrt(,) from t1;",
+            "select sqrt(sqrt(c1) ab from t1)",
+            "select sqrt(c1 ) as int from t1",
+            "select sqrt from stb1",
+            # "select sqrt(-+--+c1) from stb1",
+            # "select +-sqrt(c1) from stb1",
+            # "select ++-sqrt(c1) from stb1",
+            # "select ++--sqrt(c1) from stb1",
+            # "select - -sqrt(c1)*0 from stb1",
+            # "select sqrt(tbname+1) from stb1 ",
+            "select sqrt(123--123)==1 from stb1",
+            "select sqrt(c1) as 'd1' from stb1",
+            "select sqrt(c1 ,c2 ) from stb1",
+            "select sqrt(c1 ,NULL) from stb1",
+            "select sqrt(,) from stb1;",
+            "select sqrt(sqrt(c1) ab from stb1)",
+            "select sqrt(c1) as int from stb1"
+        ]
+        for error_sql in error_sql_lists:
+            tdSql.error(error_sql)
+    
+    def support_types(self):
+        type_error_sql_lists = [
+            "select sqrt(ts) from t1" , 
+            "select sqrt(c7) from t1",
+            "select sqrt(c8) from t1",
+            "select sqrt(c9) from t1",
+            "select sqrt(ts) from ct1" , 
+            "select sqrt(c7) from ct1",
+            "select sqrt(c8) from ct1",
+            "select sqrt(c9) from ct1",
+            "select sqrt(ts) from ct3" , 
+            "select sqrt(c7) from ct3",
+            "select sqrt(c8) from ct3",
+            "select sqrt(c9) from ct3",
+            "select sqrt(ts) from ct4" , 
+            "select sqrt(c7) from ct4",
+            "select sqrt(c8) from ct4",
+            "select sqrt(c9) from ct4",
+            "select sqrt(ts) from stb1" , 
+            "select sqrt(c7) from stb1",
+            "select sqrt(c8) from stb1",
+            "select sqrt(c9) from stb1" ,
+
+            "select sqrt(ts) from stbbb1" , 
+            "select sqrt(c7) from stbbb1",
+
+            "select sqrt(ts) from tbname",
+            "select sqrt(c9) from tbname"
+
+        ]
+        
+        for type_sql in type_error_sql_lists:
+            tdSql.error(type_sql)
+        
+        
+        type_sql_lists = [
+            "select sqrt(c1) from t1",
+            "select sqrt(c2) from t1",
+            "select sqrt(c3) from t1",
+            "select sqrt(c4) from t1",
+            "select sqrt(c5) from t1",
+            "select sqrt(c6) from t1",
+
+            "select sqrt(c1) from ct1",
+            "select sqrt(c2) from ct1",
+            "select sqrt(c3) from ct1",
+            "select sqrt(c4) from ct1",
+            "select sqrt(c5) from ct1",
+            "select sqrt(c6) from ct1",
+
+            "select sqrt(c1) from ct3",
+            "select sqrt(c2) from ct3",
+            "select sqrt(c3) from ct3",
+            "select sqrt(c4) from ct3",
+            "select sqrt(c5) from ct3",
+            "select sqrt(c6) from ct3",
+
+            "select sqrt(c1) from stb1",
+            "select sqrt(c2) from stb1",
+            "select sqrt(c3) from stb1",
+            "select sqrt(c4) from stb1",
+            "select sqrt(c5) from stb1",
+            "select sqrt(c6) from stb1",
+
+            "select sqrt(c6) as alisb from stb1", 
+            "select sqrt(c6) alisb from stb1", 
+        ]
+
+        for type_sql in type_sql_lists:
+            tdSql.query(type_sql)
+    
+    def basic_sqrt_function(self):
+
+        # basic query 
+        tdSql.query("select c1 from ct3")
+        tdSql.checkRows(0)
+        tdSql.query("select c1 from t1")
+        tdSql.checkRows(12)
+        tdSql.query("select c1 from stb1")
+        tdSql.checkRows(25)
+
+        # used for empty table  , ct3 is empty
+        tdSql.query("select sqrt(c1) from ct3")
+        tdSql.checkRows(0)
+        tdSql.query("select sqrt(c2) from ct3")
+        tdSql.checkRows(0)
+        tdSql.query("select sqrt(c3) from ct3")
+        tdSql.checkRows(0)
+        tdSql.query("select sqrt(c4) from ct3")
+        tdSql.checkRows(0)
+        tdSql.query("select sqrt(c5) from ct3")
+        tdSql.checkRows(0)
+        tdSql.query("select sqrt(c6) from ct3")
+        tdSql.checkRows(0)
+
+
+        # # used for regular table
+        tdSql.query("select sqrt(c1) from t1")
+        tdSql.checkData(0, 0, None)
+        tdSql.checkData(1 , 0, 1.000000000)
+        tdSql.checkData(3 , 0, 1.732050808)
+        tdSql.checkData(5 , 0, None)
+
+        tdSql.query("select c1, c2, c3 , c4, c5 from t1")
+        tdSql.checkData(1, 4, 1.11000)
+        tdSql.checkData(3, 3, 33)
+        tdSql.checkData(5, 4, None)
+
+        tdSql.query("select ts,c1, c2, c3 , c4, c5 from t1")
+        tdSql.checkData(1, 5, 1.11000)
+        tdSql.checkData(3, 4, 33)
+        tdSql.checkData(5, 5, None)
+
+        self.check_result_auto_sqrt( "select abs(c1), abs(c2), abs(c3) , abs(c4), abs(c5) from t1", "select sqrt(abs(c1)), sqrt(abs(c2)) ,sqrt(abs(c3)), sqrt(abs(c4)), sqrt(abs(c5)) from t1")
+        
+        # used for sub table
+        tdSql.query("select c2 ,sqrt(c2) from ct1")
+        tdSql.checkData(0, 1, 298.140906284)
+        tdSql.checkData(1 , 1, 278.885281074)
+        tdSql.checkData(3 , 1, 235.701081881)
+        tdSql.checkData(4 , 1, 0.000000000)
+
+        tdSql.query("select c1, c5 ,sqrt(c5) from ct4")
+        tdSql.checkData(0 , 2, None)
+        tdSql.checkData(1 , 2, 2.979932904)
+        tdSql.checkData(2 , 2, 2.787471970)
+        tdSql.checkData(3 , 2, 2.580697551)
+        tdSql.checkData(5 , 2, None)
+
+        self.check_result_auto_sqrt( "select c1, c2, c3 , c4, c5 from ct1", "select sqrt(c1), sqrt(c2) ,sqrt(c3), sqrt(c4), sqrt(c5) from ct1")
+       
+        # nest query for sqrt functions
+        tdSql.query("select c4  , sqrt(c4) ,sqrt(sqrt(c4)) , sqrt(sqrt(sqrt(c4))) from ct1;")
+        tdSql.checkData(0 , 0 , 88)
+        tdSql.checkData(0 , 1 , 9.380831520)
+        tdSql.checkData(0 , 2 , 3.062814314)
+        tdSql.checkData(0 , 3 , 1.750089802)
+
+        tdSql.checkData(1 , 0 , 77)
+        tdSql.checkData(1 , 1 , 8.774964387)
+        tdSql.checkData(1 , 2 , 2.962256638)
+        tdSql.checkData(1 , 3 , 1.721120750)
+
+        tdSql.checkData(11 , 0 , -99)
+        tdSql.checkData(11 , 1 , None)
+        tdSql.checkData(11 , 2 , None)
+        tdSql.checkData(11 , 3 , None)
+
+        # used for stable table 
+        
+        tdSql.query("select sqrt(c1) from stb1")
+        tdSql.checkRows(25)
+      
+
+        # used for not exists table
+        tdSql.error("select sqrt(c1) from stbbb1")
+        tdSql.error("select sqrt(c1) from tbname")
+        tdSql.error("select sqrt(c1) from ct5")
+
+        # mix with common col 
+        tdSql.query("select c1, sqrt(c1) from ct1")
+        tdSql.checkData(0 , 0 ,8)
+        tdSql.checkData(0 , 1 ,2.828427125)
+        tdSql.checkData(4 , 0 ,0)
+        tdSql.checkData(4 , 1 ,0.000000000)
+        tdSql.query("select c2, sqrt(c2) from ct4")
+        tdSql.checkData(0 , 0 , None)
+        tdSql.checkData(0 , 1 ,None)
+        tdSql.checkData(4 , 0 ,55555)
+        tdSql.checkData(4 , 1 ,235.701081881)
+        tdSql.checkData(5 , 0 ,None)
+        tdSql.checkData(5 , 1 ,None)
+
+        # mix with common functions
+        tdSql.query("select c1, sqrt(c1),sqrt(c1), sqrt(sqrt(c1)) from ct4 ")
+        tdSql.checkData(0 , 0 ,None)
+        tdSql.checkData(0 , 1 ,None)
+        tdSql.checkData(0 , 2 ,None)
+        tdSql.checkData(0 , 3 ,None)
+        
+        tdSql.checkData(3 , 0 , 6)
+        tdSql.checkData(3 , 1 ,2.449489743)
+        tdSql.checkData(3 , 2 ,2.449489743)
+        tdSql.checkData(3 , 3 ,1.565084580)
+
+        tdSql.query("select c1, sqrt(c1),c5, floor(c5) from stb1 ")
+
+        # # mix with agg functions , not support
+        tdSql.error("select c1, sqrt(c1),c5, count(c5) from stb1 ")
+        tdSql.error("select c1, sqrt(c1),c5, count(c5) from ct1 ")
+        tdSql.error("select sqrt(c1), count(c5) from stb1 ")
+        tdSql.error("select sqrt(c1), count(c5) from ct1 ")
+        tdSql.error("select c1, count(c5) from ct1 ")
+        tdSql.error("select c1, count(c5) from stb1 ")
+
+        # agg functions mix with agg functions
+
+        tdSql.query("select max(c5), count(c5) from stb1")
+        tdSql.query("select max(c5), count(c5) from ct1")
+
+        
+        # bug fix for count
+        tdSql.query("select count(c1) from ct4 ")
+        tdSql.checkData(0,0,9)
+        tdSql.query("select count(*) from ct4 ")
+        tdSql.checkData(0,0,12)
+        tdSql.query("select count(c1) from stb1 ")
+        tdSql.checkData(0,0,22)
+        tdSql.query("select count(*) from stb1 ")
+        tdSql.checkData(0,0,25)
+
+        # # bug fix for compute 
+        tdSql.query("select c1, sqrt(c1) -0 ,sqrt(c1-4)-0 from ct4 ")
+        tdSql.checkData(0, 0, None)
+        tdSql.checkData(0, 1, None)
+        tdSql.checkData(0, 2, None)
+        tdSql.checkData(1, 0, 8)
+        tdSql.checkData(1, 1, 2.828427125)
+        tdSql.checkData(1, 2, 2.000000000)
+
+        tdSql.query(" select c1, sqrt(c1) -0 ,sqrt(c1-0.1)-0.1 from ct4")
+        tdSql.checkData(0, 0, None)
+        tdSql.checkData(0, 1, None)
+        tdSql.checkData(0, 2, None)
+        tdSql.checkData(1, 0, 8)
+        tdSql.checkData(1, 1, 2.828427125)
+        tdSql.checkData(1, 2, 2.710693865)
+
+        tdSql.query("select c1, sqrt(c1), c2, sqrt(c2), c3, sqrt(c3) from ct1")
+
+    def test_big_number(self):
+
+        tdSql.query("select c1, sqrt(100000000) from ct1")  # bigint to double data overflow
+        tdSql.checkData(4, 1, 10000.000000000)
+
+
+        tdSql.query("select c1, sqrt(10000000000000) from ct1")  # bigint to double data overflow
+        tdSql.checkData(4, 1, 3162277.660168380)
+
+        tdSql.query("select c1, sqrt(c1) + sqrt(10000000000000000000000000) from ct1")  # bigint to double data overflow
+        tdSql.query("select c1, sqrt(c1) + sqrt(10000000000000000000000000.0) from ct1") # 10000000000000000000000000.0 is a double value
+        tdSql.checkData(1, 1, 3162277660171.025390625)
+
+        tdSql.query("select c1, sqrt(10000000000000000000000000000000000) from ct1")  # bigint to double data overflow
+        tdSql.query("select c1, sqrt(10000000000000000000000000000000000.0) from ct1") # 10000000000000000000000000.0 is a double value
+        tdSql.checkData(4, 1, 100000000000000000.000000000)
+
+        tdSql.query("select c1, sqrt(10000000000000000000000000000000000000000) from ct1")  # bigint to double data overflow
+        tdSql.query("select c1, sqrt(10000000000000000000000000000000000000000.0) from ct1") # 10000000000000000000000000.0 is a double value
+
+        tdSql.checkData(4, 1, 100000000000000000000.000000000)
+
+        tdSql.query("select c1, sqrt(10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) from ct1")  # bigint to double data overflow
+
+    def pow_base_test(self):
+
+        # base is an regular number ,int or double
+        tdSql.query("select c1, sqrt(c1) from ct1")
+        tdSql.checkData(0, 1,2.828427125)
+        tdSql.checkRows(13)
+
+        # # bug for compute in functions
+        # tdSql.query("select c1, abs(1/0) from ct1") 
+        # tdSql.checkData(0, 0, 8)
+        # tdSql.checkData(0, 1, 1)
+
+        tdSql.query("select c1, sqrt(1) from ct1")  
+        tdSql.checkData(0, 1, 1.000000000)
+        tdSql.checkRows(13)
+
+        # two cols start sqrt(x,y)
+        tdSql.query("select c1,c2, sqrt(c2) from ct1") 
+        tdSql.checkData(0, 2, 298.140906284)
+        tdSql.checkData(1, 2, 278.885281074)
+        tdSql.checkData(4, 2, 0.000000000)
+
+    def abs_func_filter(self):
+        tdSql.execute("use db")
+        tdSql.query("select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(sqrt(c1)-0.5) from ct4 where c1>5 ")
+        tdSql.checkRows(3)
+        tdSql.checkData(0,0,8)
+        tdSql.checkData(0,1,8.000000000)
+        tdSql.checkData(0,2,8.000000000)
+        tdSql.checkData(0,3,7.900000000)
+        tdSql.checkData(0,4,3.000000000)
+
+        tdSql.query("select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(sqrt(c1)-0.5) from ct4 where c1=5 ")
+        tdSql.checkRows(1)
+        tdSql.checkData(0,0,5)
+        tdSql.checkData(0,1,5.000000000)
+        tdSql.checkData(0,2,5.000000000)
+        tdSql.checkData(0,3,4.900000000)
+        tdSql.checkData(0,4,2.000000000)
+
+        tdSql.query("select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(sqrt(c1)-0.5) from ct4 where c1=5 ")
+        tdSql.checkRows(1)
+        tdSql.checkData(0,0,5)
+        tdSql.checkData(0,1,5.000000000)
+        tdSql.checkData(0,2,5.000000000)
+        tdSql.checkData(0,3,4.900000000)
+        tdSql.checkData(0,4,2.000000000)
+
+        tdSql.query("select c1,c2 , abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(sqrt(c1)-0.5) from ct4 where c1=sqrt(c1) limit 1 ")
+        tdSql.checkRows(1)
+        tdSql.checkData(0,0,1)
+        tdSql.checkData(0,1,11111)
+        tdSql.checkData(0,2,1.000000000)
+        tdSql.checkData(0,3,1.000000000)
+        tdSql.checkData(0,4,0.900000000)
+        tdSql.checkData(0,5,1.000000000)
+        
+    def pow_Arithmetic(self):
+        pass
+    
+    def check_boundary_values(self):
+
+        tdSql.execute("drop database if exists bound_test")
+        tdSql.execute("create database if not exists bound_test")
+        time.sleep(3)
+        tdSql.execute("use bound_test")
+        tdSql.execute(
+            "create table stb_bound (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(32),c9 nchar(32), c10 timestamp) tags (t1 int);"
+        )
+        tdSql.execute(f'create table sub1_bound using stb_bound tags ( 1 )')
+        tdSql.execute(
+                f"insert into sub1_bound values ( now()-1s, 2147483647, 9223372036854775807, 32767, 127, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            )
+        tdSql.execute(
+                f"insert into sub1_bound values ( now()-1s, -2147483647, -9223372036854775807, -32767, -127, -3.40E+38, -1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            )
+        tdSql.execute(
+                f"insert into sub1_bound values ( now(), 2147483646, 9223372036854775806, 32766, 126, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            )
+        tdSql.execute(
+                f"insert into sub1_bound values ( now(), -2147483646, -9223372036854775806, -32766, -126, -3.40E+38, -1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            )
+        tdSql.error(
+                f"insert into sub1_bound values ( now()+1s, 2147483648, 9223372036854775808, 32768, 128, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            )
+        self.check_result_auto_sqrt( "select abs(c1), abs(c2), abs(c3) , abs(c4), abs(c5) from sub1_bound ", "select sqrt(abs(c1)), sqrt(abs(c2)) ,sqrt(abs(c3)), sqrt(abs(c4)), sqrt(abs(c5)) from sub1_bound")
+       
+        self.check_result_auto_sqrt( "select c1, c2, c3 , c3, c2 ,c1 from sub1_bound ", "select sqrt(c1), sqrt(c2) ,sqrt(c3), sqrt(c3), sqrt(c2) ,sqrt(c1) from sub1_bound")
+
+        self.check_result_auto_sqrt("select abs(abs(abs(abs(abs(abs(abs(abs(abs(c1)))))))))  nest_col_func from sub1_bound" , "select sqrt(abs(c1)) from sub1_bound" )
+        
+        # check basic elem for table per row
+        tdSql.query("select sqrt(abs(c1)) ,sqrt(abs(c2)) , sqrt(abs(c3)) , sqrt(abs(c4)), sqrt(abs(c5)), sqrt(abs(c6)) from sub1_bound ")
+        tdSql.checkData(0,0,math.sqrt(2147483647))
+        tdSql.checkData(0,1,math.sqrt(9223372036854775807))
+        tdSql.checkData(0,2,math.sqrt(32767))
+        tdSql.checkData(0,3,math.sqrt(127))
+        tdSql.checkData(0,4,math.sqrt(339999995214436424907732413799364296704.00000))
+        tdSql.checkData(1,0,math.sqrt(2147483647))
+        tdSql.checkData(1,1,math.sqrt(9223372036854775807))
+        tdSql.checkData(1,2,math.sqrt(32767))
+        tdSql.checkData(1,3,math.sqrt(127))
+        tdSql.checkData(1,4,math.sqrt(339999995214436424907732413799364296704.00000))
+        tdSql.checkData(3,0,math.sqrt(2147483646))
+        tdSql.checkData(3,1,math.sqrt(9223372036854775806))
+        tdSql.checkData(3,2,math.sqrt(32766))
+        tdSql.checkData(3,3,math.sqrt(126))
+        tdSql.checkData(3,4,math.sqrt(339999995214436424907732413799364296704.00000))
+
+        # check  + - * / in functions
+        tdSql.query("select sqrt(abs(c1+1)) ,sqrt(abs(c2)) , sqrt(abs(c3*1)) , sqrt(abs(c4/2)), sqrt(abs(c5))/2, sqrt(abs(c6)) from sub1_bound ")
+        tdSql.checkData(0,0,math.sqrt(2147483648.000000000))
+        tdSql.checkData(0,1,math.sqrt(9223372036854775807))
+        tdSql.checkData(0,2,math.sqrt(32767.000000000))
+        tdSql.checkData(0,3,math.sqrt(63.500000000))
+      
+    
+    def run(self):  # sourcery skip: extract-duplicate-method, remove-redundant-fstring
+        tdSql.prepare()
+
+        tdLog.printNoPrefix("==========step1:create table ==============")
+        
+        self.prepare_datas()
+
+        tdLog.printNoPrefix("==========step2:test errors ==============")    
+
+        self.test_errors()
+        
+        tdLog.printNoPrefix("==========step3:support types ============") 
+
+        self.support_types()
+
+        tdLog.printNoPrefix("==========step4: sqrt basic query ============") 
+
+        self.basic_sqrt_function()
+
+        tdLog.printNoPrefix("==========step5: big number sqrt query ============") 
+
+        self.test_big_number()
+
+        tdLog.printNoPrefix("==========step6: base  number for sqrt query ============") 
+
+        self.pow_base_test()
+
+        tdLog.printNoPrefix("==========step7: sqrt boundary query ============") 
+
+        self.check_boundary_values()
+
+        tdLog.printNoPrefix("==========step8: sqrt filter query ============") 
+
+        self.abs_func_filter()
+
+        
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success(f"{__file__} successfully executed")
+
+tdCases.addLinux(__file__, TDTestCase())
+tdCases.addWindows(__file__, TDTestCase())

tests/system-test/fulltest.sh

@@ -26,3 +26,5 @@ python3 ./test.py -f 2-query/ceil.py
 python3 ./test.py -f 2-query/floor.py
 python3 ./test.py -f 2-query/round.py
 python3 ./test.py -f 2-query/log.py
+python3 ./test.py -f 2-query/pow.py
+python3 ./test.py -f 2-query/sqrt.py

tools/shell/src/shellEngine.c

@@ -141,6 +141,9 @@ int32_t shellRunCommand(char *command) {
             *p++ = '\\';
           }
           break;
+        default:
+          *p++ = '\\';
+          break;
       }
       *p++ = c;
       esc = false;

tools/shell/src/shellNettest.c

@@ -21,7 +21,7 @@ static void shellWorkAsClient() {
   SRpcInit    rpcInit = {0};
   SEpSet      epSet = {.inUse = 0, .numOfEps = 1};
   SRpcMsg     rpcRsp = {0};
-  void       *clientRpc = NULL;
+  void *      clientRpc = NULL;
   char        pass[TSDB_PASSWORD_LEN + 1] = {0};
 
   taosEncryptPass_c((uint8_t *)("_pwd"), strlen("_pwd"), pass);
@@ -116,6 +116,7 @@ static void shellWorkAsServer() {
   }
 
   SRpcInit rpcInit = {0};
+  memcpy(rpcInit.localFqdn, tsLocalFqdn, strlen(tsLocalFqdn));
   rpcInit.localPort = pArgs->port;
   rpcInit.label = "CHK";
   rpcInit.numOfThreads = tsNumOfRpcThreads;
@@ -126,7 +127,7 @@ static void shellWorkAsServer() {
 
   void *serverRpc = rpcOpen(&rpcInit);
   if (serverRpc == NULL) {
-    printf("failed to init net test server since %s", terrstr());
+    printf("failed to init net test server since %s\n", terrstr());
   } else {
     printf("network test server is initialized, port:%u\n", pArgs->port);
     taosSetSignal(SIGTERM, shellNettestHandler);

tools/taos-tools

@@ -1 +1 @@
-Subproject commit 2f3dfddd4d9a869e706ba3cf98fb6d769404cd7c
+Subproject commit 59e0ebaf4905e4cb6d95a01c58b3fa507abc5a20