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

cmake/cmake.options

@@ -79,7 +79,7 @@ ENDIF ()
 
 option(
     BUILD_SANITIZER
-    "If build addr2line"
+    "If build sanitizer"
     OFF
     )
 

examples/c/tmq.c

@@ -30,21 +30,35 @@ static void msg_process(TAOS_RES* msg) {
   if (tmq_get_res_type(msg) == TMQ_RES_TABLE_META) {
     tmq_raw_data *raw = tmq_get_raw_meta(msg);
     if(raw){
-      TAOS* pConn = taos_connect("192.168.1.86", "root", "taosdata", "abc1", 0);
+      TAOS* pConn = taos_connect("192.168.1.86", "root", "taosdata", NULL, 0);
       if (pConn == NULL) {
         return;
       }
+
+      TAOS_RES* pRes = taos_query(pConn, "create database if not exists abc1 vgroups 5");
+      if (taos_errno(pRes) != 0) {
+        printf("error in create db, reason:%s\n", taos_errstr(pRes));
+        return;
+      }
+      taos_free_result(pRes);
+
+      pRes = taos_query(pConn, "use abc1");
+      if (taos_errno(pRes) != 0) {
+        printf("error in use db, reason:%s\n", taos_errstr(pRes));
+        return;
+      }
+      taos_free_result(pRes);
+
       int32_t ret = taos_write_raw_meta(pConn, raw);
       printf("write raw data: %s\n", tmq_err2str(ret));
-      free(raw);
       taos_close(pConn);
     }
+    tmq_free_raw_meta(raw);
     char* result = tmq_get_json_meta(msg);
     if(result){
       printf("meta result: %s\n", result);
-      free(result);
     }
-    printf("meta:%p\n", raw);
+    tmq_free_json_meta(result);
     return;
   }
   while (1) {
@@ -68,7 +82,7 @@ int32_t init_env() {
     return -1;
   }
 
-  TAOS_RES* pRes = taos_query(pConn, "create database if not exists abc1 vgroups 1");
+  TAOS_RES* pRes = taos_query(pConn, "create database if not exists abc1 vgroups 5");
   if (taos_errno(pRes) != 0) {
     printf("error in create db, reason:%s\n", taos_errstr(pRes));
     return -1;
@@ -82,15 +96,14 @@ int32_t init_env() {
   }
   taos_free_result(pRes);
 
-  pRes =
+  pRes = taos_query(pConn, "create stable if not exists st1 (ts timestamp, c1 int, c2 float, c3 binary(16)) tags(t1 int, t3 nchar(8), t4 bool)");
-      taos_query(pConn, "create stable if not exists st1 (ts timestamp, c1 int, c2 float, c3 binary(16)) tags(t1 int)");
   if (taos_errno(pRes) != 0) {
     printf("failed to create super table st1, reason:%s\n", taos_errstr(pRes));
     return -1;
   }
   taos_free_result(pRes);
 
-  pRes = taos_query(pConn, "create table if not exists ct0 using st1 tags(1000)");
+  pRes = taos_query(pConn, "create table if not exists ct0 using st1 tags(1000, \"ttt\", true)");
   if (taos_errno(pRes) != 0) {
     printf("failed to create child table tu1, reason:%s\n", taos_errstr(pRes));
     return -1;
@@ -104,13 +117,20 @@ int32_t init_env() {
   }
   taos_free_result(pRes);
 
-  pRes = taos_query(pConn, "create table if not exists ct1 using st1 tags(2000)");
+  pRes = taos_query(pConn, "create table if not exists ct1 using st1(t1) tags(2000)");
   if (taos_errno(pRes) != 0) {
     printf("failed to create child table ct1, reason:%s\n", taos_errstr(pRes));
     return -1;
   }
   taos_free_result(pRes);
 
+  pRes = taos_query(pConn, "create table if not exists ct2 using st1(t1) tags(NULL)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create child table ct2, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
   pRes = taos_query(pConn, "insert into ct1 values(now, 3, 4, 'b')");
   if (taos_errno(pRes) != 0) {
     printf("failed to insert into ct1, reason:%s\n", taos_errstr(pRes));
@@ -118,7 +138,7 @@ int32_t init_env() {
   }
   taos_free_result(pRes);
 
-  pRes = taos_query(pConn, "create table if not exists ct3 using st1 tags(3000)");
+  pRes = taos_query(pConn, "create table if not exists ct3 using st1(t1) tags(3000)");
   if (taos_errno(pRes) != 0) {
     printf("failed to create child table ct3, reason:%s\n", taos_errstr(pRes));
     return -1;
@@ -202,6 +222,13 @@ int32_t init_env() {
   }
   taos_free_result(pRes);
 
+  pRes = taos_query(pConn, "alter table n1 comment 'hello'");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to alter normal table n1, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
   pRes = taos_query(pConn, "alter table n1 drop column c1");
   if (taos_errno(pRes) != 0) {
     printf("failed to alter normal table n1, reason:%s\n", taos_errstr(pRes));
@@ -230,6 +257,27 @@ int32_t init_env() {
   }
   taos_free_result(pRes);
 
+  pRes = taos_query(pConn, "create table jt2 using jt tags('')");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create super table jt2, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create stable if not exists st1 (ts timestamp, c1 int, c2 float, c3 binary(16)) tags(t1 int, t3 nchar(8), t4 bool)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create super table st1, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "drop table st1");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to drop super table st1, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
   return 0;
 }
 

include/client/taos.h

@@ -265,7 +265,9 @@ typedef struct tmq_raw_data tmq_raw_data;
 DLL_EXPORT tmq_res_t     tmq_get_res_type(TAOS_RES *res);
 DLL_EXPORT tmq_raw_data *tmq_get_raw_meta(TAOS_RES *res);
 DLL_EXPORT int32_t       taos_write_raw_meta(TAOS *taos, tmq_raw_data *raw_meta);
-DLL_EXPORT char         *tmq_get_json_meta(TAOS_RES *res);   // Returning null means error. Returned result need to be freed.
+DLL_EXPORT void          tmq_free_raw_meta(tmq_raw_data *rawMeta);
+DLL_EXPORT char         *tmq_get_json_meta(TAOS_RES *res);   // Returning null means error. Returned result need to be freed by tmq_free_json_meta
+DLL_EXPORT void          tmq_free_json_meta(char* jsonMeta);
 DLL_EXPORT const char   *tmq_get_topic_name(TAOS_RES *res);
 DLL_EXPORT const char   *tmq_get_db_name(TAOS_RES *res);
 DLL_EXPORT int32_t       tmq_get_vgroup_id(TAOS_RES *res);

include/common/tcommon.h

@@ -40,7 +40,6 @@ enum {
   || x == TDMT_VND_CREATE_TABLE   \
   || x == TDMT_VND_ALTER_TABLE    \
   || x == TDMT_VND_DROP_TABLE     \
-  || x == TDMT_VND_DROP_TTL_TABLE \
 )
 // clang-format on
 
@@ -162,7 +161,6 @@ typedef struct SQueryTableDataCond {
   int64_t      endVersion;
 } SQueryTableDataCond;
 
-void*   blockDataDestroy(SSDataBlock* pBlock);
 int32_t tEncodeDataBlock(void** buf, const SSDataBlock* pBlock);
 void*   tDecodeDataBlock(const void* buf, SSDataBlock* pBlock);
 
@@ -170,19 +168,6 @@ int32_t tEncodeDataBlocks(void** buf, const SArray* blocks);
 void*   tDecodeDataBlocks(const void* buf, SArray** blocks);
 void    colDataDestroy(SColumnInfoData* pColData);
 
-static FORCE_INLINE void blockDestroyInner(SSDataBlock* pBlock) {
-  int32_t numOfOutput = taosArrayGetSize(pBlock->pDataBlock);
-  for (int32_t i = 0; i < numOfOutput; ++i) {
-    SColumnInfoData* pColInfoData = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, i);
-    colDataDestroy(pColInfoData);
-  }
-
-  taosArrayDestroy(pBlock->pDataBlock);
-  taosMemoryFreeClear(pBlock->pBlockAgg);
-}
-
-static FORCE_INLINE void tDeleteSSDataBlock(SSDataBlock* pBlock) { blockDestroyInner(pBlock); }
-
 //======================================================================================================================
 // the following structure shared by parser and executor
 typedef struct SColumn {

include/common/tdatablock.h

@@ -226,8 +226,12 @@ int32_t blockDataKeepFirstNRows(SSDataBlock* pBlock, size_t n);
 
 int32_t      assignOneDataBlock(SSDataBlock* dst, const SSDataBlock* src);
 int32_t      copyDataBlock(SSDataBlock* dst, const SSDataBlock* src);
-SSDataBlock* createOneDataBlock(const SSDataBlock* pDataBlock, bool copyData);
+
 SSDataBlock* createDataBlock();
+void*        blockDataDestroy(SSDataBlock* pBlock);
+void         blockDataFreeRes(SSDataBlock* pBlock);
+SSDataBlock* createOneDataBlock(const SSDataBlock* pDataBlock, bool copyData);
+
 int32_t      blockDataAppendColInfo(SSDataBlock* pBlock, SColumnInfoData* pColInfoData);
 
 SColumnInfoData  createColumnInfoData(int16_t type, int32_t bytes, int16_t colId);

include/common/tdataformat.h

@@ -171,6 +171,7 @@ struct SColVal {
 
 #pragma pack(push, 1)
 struct STagVal {
+//  char colName[TSDB_COL_NAME_LEN]; // only used for tmq_get_meta
   union {
     int16_t cid;
     char   *pKey;

include/common/tmsg.h

@@ -1939,6 +1939,8 @@ typedef struct SVCreateStbReq {
   SSchemaWrapper schemaRow;
   SSchemaWrapper schemaTag;
   SRSmaParam     rsmaParam;
+  int32_t        alterOriDataLen;
+  void*          alterOriData;
 } SVCreateStbReq;
 
 int tEncodeSVCreateStbReq(SEncoder* pCoder, const SVCreateStbReq* pReq);
@@ -1966,7 +1968,9 @@ typedef struct SVCreateTbReq {
   int8_t   type;
   union {
     struct {
+      char*    name;    // super table name
       tb_uid_t suid;
+      SArray*  tagName;
       uint8_t* pTag;
     } ctb;
     struct {
@@ -1983,6 +1987,9 @@ static FORCE_INLINE void tdDestroySVCreateTbReq(SVCreateTbReq* req) {
   taosMemoryFreeClear(req->comment);
   if (req->type == TSDB_CHILD_TABLE) {
     taosMemoryFreeClear(req->ctb.pTag);
+    taosMemoryFreeClear(req->ctb.name);
+    taosArrayDestroy(req->ctb.tagName);
+    req->ctb.tagName = NULL;
   } else if (req->type == TSDB_NORMAL_TABLE) {
     taosMemoryFreeClear(req->ntb.schemaRow.pSchema);
   }
@@ -2066,12 +2073,14 @@ typedef struct {
   int32_t bytes;
   // TSDB_ALTER_TABLE_DROP_COLUMN
   // TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES
+  int8_t  colModType;
   int32_t colModBytes;
   // TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME
   char* colNewName;
   // TSDB_ALTER_TABLE_UPDATE_TAG_VAL
   char*    tagName;
   int8_t   isNull;
+  int8_t   tagType;
   uint32_t nTagVal;
   uint8_t* pTagVal;
   // TSDB_ALTER_TABLE_UPDATE_OPTIONS
@@ -2858,8 +2867,8 @@ typedef struct {
 
 static FORCE_INLINE int32_t tEncodeSMqMetaRsp(void** buf, const SMqMetaRsp* pRsp) {
   int32_t tlen = 0;
-  // tlen += taosEncodeFixedI64(buf, pRsp->reqOffset);
+  tlen += taosEncodeFixedI64(buf, pRsp->reqOffset);
-  // tlen += taosEncodeFixedI64(buf, pRsp->rspOffset);
+  tlen += taosEncodeFixedI64(buf, pRsp->rspOffset);
   tlen += taosEncodeFixedI16(buf, pRsp->resMsgType);
   tlen += taosEncodeFixedI32(buf, pRsp->metaRspLen);
   tlen += taosEncodeBinary(buf, pRsp->metaRsp, pRsp->metaRspLen);
@@ -2867,8 +2876,7 @@ static FORCE_INLINE int32_t tEncodeSMqMetaRsp(void** buf, const SMqMetaRsp* pRsp
 }
 
 static FORCE_INLINE void* tDecodeSMqMetaRsp(const void* buf, SMqMetaRsp* pRsp) {
-  // buf = taosDecodeFixedI64(buf, &pRsp->reqOffset);
+  buf = taosDecodeFixedI64(buf, &pRsp->reqOffset);buf = taosDecodeFixedI64(buf, &pRsp->rspOffset);
-  // buf = taosDecodeFixedI64(buf, &pRsp->rspOffset);
   buf = taosDecodeFixedI16(buf, &pRsp->resMsgType);
   buf = taosDecodeFixedI32(buf, &pRsp->metaRspLen);
   buf = taosDecodeBinary(buf, &pRsp->metaRsp, pRsp->metaRspLen);

include/common/ttypes.h

@@ -143,6 +143,86 @@ typedef struct {
     }                                          \
   } while (0)
 
+#define SET_TYPED_DATA_MIN(_v, _type)          \
+  do {                                         \
+    switch (_type) {                           \
+      case TSDB_DATA_TYPE_BOOL:                \
+      case TSDB_DATA_TYPE_TINYINT:             \
+        *(int8_t *)(_v) = INT8_MIN;            \
+        break;                                 \
+      case TSDB_DATA_TYPE_SMALLINT:            \
+        *(int16_t *)(_v) = INT16_MIN;          \
+        break;                                 \
+      case TSDB_DATA_TYPE_INT:                 \
+        *(int32_t *)(_v) = INT32_MIN;          \
+        break;                                 \
+      case TSDB_DATA_TYPE_BIGINT:              \
+      case TSDB_DATA_TYPE_TIMESTAMP:           \
+        *(int64_t *)(_v) = INT64_MIN;          \
+        break;                                 \
+      case TSDB_DATA_TYPE_FLOAT:               \
+        *(float *)(_v) = FLT_MIN;              \
+        break;                                 \
+      case TSDB_DATA_TYPE_DOUBLE:              \
+        *(double *)(_v) = DBL_MIN;             \
+        break;                                 \
+      case TSDB_DATA_TYPE_UTINYINT:            \
+        *(uint8_t *)(_v) = 0;                  \
+        break;                                 \
+      case TSDB_DATA_TYPE_USMALLINT:           \
+        *(uint16_t *)(_v) = 0;                 \
+        break;                                 \
+      case TSDB_DATA_TYPE_UBIGINT:             \
+        *(uint64_t *)(_v) = 0;                 \
+        break;                                 \
+      case TSDB_DATA_TYPE_UINT:                \
+        *(uint32_t *)(_v) = 0;                 \
+        break;                                 \
+      default:                                 \
+        break;                                 \
+    }                                          \
+  } while (0)
+
+#define SET_TYPED_DATA_MAX(_v, _type)          \
+  do {                                         \
+    switch (_type) {                           \
+      case TSDB_DATA_TYPE_BOOL:                \
+      case TSDB_DATA_TYPE_TINYINT:             \
+        *(int8_t *)(_v) = INT8_MAX;            \
+        break;                                 \
+      case TSDB_DATA_TYPE_SMALLINT:            \
+        *(int16_t *)(_v) = INT16_MAX;          \
+        break;                                 \
+      case TSDB_DATA_TYPE_INT:                 \
+        *(int32_t *)(_v) = INT32_MAX;          \
+        break;                                 \
+      case TSDB_DATA_TYPE_BIGINT:              \
+      case TSDB_DATA_TYPE_TIMESTAMP:           \
+        *(int64_t *)(_v) = INT64_MAX;          \
+        break;                                 \
+      case TSDB_DATA_TYPE_FLOAT:               \
+        *(float *)(_v) = FLT_MAX;              \
+        break;                                 \
+      case TSDB_DATA_TYPE_DOUBLE:              \
+        *(double *)(_v) = DBL_MAX;             \
+        break;                                 \
+      case TSDB_DATA_TYPE_UTINYINT:            \
+        *(uint8_t *)(_v) = UINT8_MAX;          \
+        break;                                 \
+      case TSDB_DATA_TYPE_USMALLINT:           \
+        *(uint16_t *)(_v) = UINT16_MAX;        \
+        break;                                 \
+      case TSDB_DATA_TYPE_UINT:                \
+        *(uint32_t *)(_v) = UINT32_MAX;        \
+        break;                                 \
+      case TSDB_DATA_TYPE_UBIGINT:             \
+        *(uint64_t *)(_v) = UINT64_MAX;        \
+        break;                                 \
+      default:                                 \
+        break;                                 \
+    }                                          \
+  } while (0)
+
 #define NUM_TO_STRING(_inputType, _input, _outputBytes, _output)                       \
   do {                                                                                 \
     switch (_inputType) {                                                              \

include/libs/parser/parser.h

@@ -29,7 +29,7 @@ struct SMetaData;
 typedef struct SStmtCallback {
   TAOS_STMT* pStmt;
   int32_t (*getTbNameFn)(TAOS_STMT*, char**);
-  int32_t (*setInfoFn)(TAOS_STMT*, STableMeta*, void*, char*, bool, SHashObj*, SHashObj*);
+  int32_t (*setInfoFn)(TAOS_STMT*, STableMeta*, void*, char*, bool, SHashObj*, SHashObj*, const char*);
   int32_t (*getExecInfoFn)(TAOS_STMT*, SHashObj**, SHashObj**);
 } SStmtCallback;
 
@@ -84,7 +84,7 @@ int32_t qBindStmtSingleColValue(void* pBlock, TAOS_MULTI_BIND* bind, char* msgBu
                                 int32_t rowNum);
 int32_t qBuildStmtColFields(void* pDataBlock, int32_t* fieldNum, TAOS_FIELD_E** fields);
 int32_t qBuildStmtTagFields(void* pBlock, void* boundTags, int32_t* fieldNum, TAOS_FIELD_E** fields);
-int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, char* tName, TAOS_MULTI_BIND* bind,
+int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, const char* sTableName, char* tName, TAOS_MULTI_BIND* bind,
                            char* msgBuf, int32_t msgBufLen);
 void    destroyBoundColumnInfo(void* pBoundInfo);
 int32_t qCreateSName(SName* pName, const char* pTableName, int32_t acctId, char* dbName, char* msgBuf,
@@ -93,7 +93,7 @@ int32_t qCreateSName(SName* pName, const char* pTableName, int32_t acctId, char*
 void*   smlInitHandle(SQuery* pQuery);
 void    smlDestroyHandle(void* pHandle);
 int32_t smlBindData(void* handle, SArray* tags, SArray* colsSchema, SArray* cols, bool format, STableMeta* pTableMeta,
-                    char* tableName, char* msgBuf, int16_t msgBufLen);
+                    char* tableName, const char* sTableName, int32_t sTableNameLen, char* msgBuf, int16_t msgBufLen);
 int32_t smlBuildOutput(void* handle, SHashObj* pVgHash);
 
 int32_t rewriteToVnodeModifyOpStmt(SQuery* pQuery, SArray* pBufArray);

include/libs/scalar/scalar.h

@@ -96,6 +96,13 @@ int32_t qEndTsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOu
 
 int32_t qTbnameFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 
+/* Aggregation functions */
+int32_t countScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t sumScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t minScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t maxScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t stddevScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+
 #ifdef __cplusplus
 }
 #endif

include/libs/stream/tstream.h

@@ -340,12 +340,12 @@ static FORCE_INLINE int32_t streamTaskOutput(SStreamTask* pTask, SStreamDataBloc
   if (pTask->sinkType == TASK_SINK__TABLE) {
     ASSERT(pTask->dispatchType == TASK_DISPATCH__NONE);
     pTask->tbSink.tbSinkFunc(pTask, pTask->tbSink.vnode, 0, pBlock->blocks);
-    taosArrayDestroyEx(pBlock->blocks, (FDelete)tDeleteSSDataBlock);
+    taosArrayDestroyEx(pBlock->blocks, (FDelete)blockDataFreeRes);
     taosFreeQitem(pBlock);
   } else if (pTask->sinkType == TASK_SINK__SMA) {
     ASSERT(pTask->dispatchType == TASK_DISPATCH__NONE);
     pTask->smaSink.smaSink(pTask->smaSink.vnode, pTask->smaSink.smaId, pBlock->blocks);
-    taosArrayDestroyEx(pBlock->blocks, (FDelete)tDeleteSSDataBlock);
+    taosArrayDestroyEx(pBlock->blocks, (FDelete)blockDataFreeRes);
     taosFreeQitem(pBlock);
   } else {
     ASSERT(pTask->dispatchType != TASK_DISPATCH__NONE);

include/os/osDef.h

@@ -22,7 +22,10 @@ extern "C" {
 
 #if defined(_TD_DARWIN_64)
   // specific
+#ifndef __COMPAR_FN_T
+#define __COMPAR_FN_T
   typedef int(*__compar_fn_t)(const void *, const void *);
+#endif
 
   // for send function in tsocket.c
   #if defined(MSG_NOSIGNAL)
@@ -41,7 +44,10 @@ extern "C" {
 #endif
 
 #if defined(_ALPINE)
+#ifndef __COMPAR_FN_T
+#define __COMPAR_FN_T
   typedef int(*__compar_fn_t)(const void *, const void *);
+#endif
   void  error (int, int, const char *);
   #ifndef PTHREAD_MUTEX_RECURSIVE_NP
     #define  PTHREAD_MUTEX_RECURSIVE_NP PTHREAD_MUTEX_RECURSIVE
@@ -54,7 +60,10 @@ extern "C" {
   char *stpncpy (char *dest, const char *src, size_t n);
 
   // specific
+#ifndef __COMPAR_FN_T
+#define __COMPAR_FN_T
   typedef int (*__compar_fn_t)(const void *, const void *);
+#endif
   #define ssize_t int
   #define _SSIZE_T_
   #define bzero(ptr, size) memset((ptr), 0, (size))
@@ -69,7 +78,6 @@ extern "C" {
   char *     strsep(char **stringp, const char *delim);
   char *     getpass(const char *prefix);
   char *     strndup(const char *s, size_t n);
-  int        gettimeofday(struct timeval *ptv, void *pTimeZone);
 
   // for send function in tsocket.c
   #define MSG_NOSIGNAL             0

include/util/tencode.h

@@ -440,7 +440,7 @@ static FORCE_INLINE bool tDecodeIsEnd(SDecoder* pCoder) { return (pCoder->size =
 
 static FORCE_INLINE void* tEncoderMalloc(SEncoder* pCoder, int32_t size) {
   void*      p = NULL;
-  SCoderMem* pMem = (SCoderMem*)taosMemoryMalloc(sizeof(*pMem) + size);
+  SCoderMem* pMem = (SCoderMem*)taosMemoryCalloc(1, sizeof(*pMem) + size);
   if (pMem) {
     pMem->next = pCoder->mList;
     pCoder->mList = pMem;
@@ -451,7 +451,7 @@ static FORCE_INLINE void* tEncoderMalloc(SEncoder* pCoder, int32_t size) {
 
 static FORCE_INLINE void* tDecoderMalloc(SDecoder* pCoder, int32_t size) {
   void*      p = NULL;
-  SCoderMem* pMem = (SCoderMem*)taosMemoryMalloc(sizeof(*pMem) + size);
+  SCoderMem* pMem = (SCoderMem*)taosMemoryCalloc(1, sizeof(*pMem) + size);
   if (pMem) {
     pMem->next = pCoder->mList;
     pCoder->mList = pMem;

source/client/src/clientSml.c

@@ -2256,7 +2256,7 @@ static int32_t smlInsertData(SSmlHandle *info) {
     (*pMeta)->tableMeta->uid = tableData->uid;  // one table merge data block together according uid
 
     code = smlBindData(info->exec, tableData->tags, (*pMeta)->cols, tableData->cols, info->dataFormat,
-                       (*pMeta)->tableMeta, tableData->childTableName, info->msgBuf.buf, info->msgBuf.len);
+                       (*pMeta)->tableMeta, tableData->childTableName, tableData->sTableName, tableData->sTableNameLen, info->msgBuf.buf, info->msgBuf.len);
     if (code != TSDB_CODE_SUCCESS) {
       uError("SML:0x%" PRIx64 " smlBindData failed", info->id);
       return code;

source/client/src/clientStmt.c

@@ -136,7 +136,7 @@ int32_t stmtRestoreQueryFields(STscStmt* pStmt) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t stmtUpdateBindInfo(TAOS_STMT* stmt, STableMeta* pTableMeta, void* tags, char* tbFName) {
+int32_t stmtUpdateBindInfo(TAOS_STMT* stmt, STableMeta* pTableMeta, void* tags, char* tbFName, const char* sTableName) {
   STscStmt* pStmt = (STscStmt*)stmt;
 
   strncpy(pStmt->bInfo.tbFName, tbFName, sizeof(pStmt->bInfo.tbFName) - 1);
@@ -147,6 +147,7 @@ int32_t stmtUpdateBindInfo(TAOS_STMT* stmt, STableMeta* pTableMeta, void* tags,
   pStmt->bInfo.tbType = pTableMeta->tableType;
   pStmt->bInfo.boundTags = tags;
   pStmt->bInfo.tagsCached = false;
+  strcpy(pStmt->bInfo.stbFName, sTableName);
 
   return TSDB_CODE_SUCCESS;
 }
@@ -162,10 +163,10 @@ int32_t stmtUpdateExecInfo(TAOS_STMT* stmt, SHashObj* pVgHash, SHashObj* pBlockH
 }
 
 int32_t stmtUpdateInfo(TAOS_STMT* stmt, STableMeta* pTableMeta, void* tags, char* tbFName, bool autoCreateTbl,
-                       SHashObj* pVgHash, SHashObj* pBlockHash) {
+                       SHashObj* pVgHash, SHashObj* pBlockHash, const char* sTableName) {
   STscStmt* pStmt = (STscStmt*)stmt;
 
-  STMT_ERR_RET(stmtUpdateBindInfo(stmt, pTableMeta, tags, tbFName));
+  STMT_ERR_RET(stmtUpdateBindInfo(stmt, pTableMeta, tags, tbFName, sTableName));
   STMT_ERR_RET(stmtUpdateExecInfo(stmt, pVgHash, pBlockHash, autoCreateTbl));
 
   pStmt->sql.autoCreateTbl = autoCreateTbl;
@@ -253,7 +254,7 @@ int32_t stmtCleanBindInfo(STscStmt* pStmt) {
     destroyBoundColumnInfo(pStmt->bInfo.boundTags);
     taosMemoryFreeClear(pStmt->bInfo.boundTags);
   }
-
+  memset(pStmt->bInfo.stbFName, 0, TSDB_TABLE_FNAME_LEN);
   return TSDB_CODE_SUCCESS;
 }
 
@@ -592,7 +593,7 @@ int stmtSetTbTags(TAOS_STMT* stmt, TAOS_MULTI_BIND* tags) {
   }
 
   tscDebug("start to bind stmt tag values");
-  STMT_ERR_RET(qBindStmtTagsValue(*pDataBlock, pStmt->bInfo.boundTags, pStmt->bInfo.tbSuid, pStmt->bInfo.sname.tname,
+  STMT_ERR_RET(qBindStmtTagsValue(*pDataBlock, pStmt->bInfo.boundTags, pStmt->bInfo.tbSuid, pStmt->bInfo.stbFName, pStmt->bInfo.sname.tname,
                                   tags, pStmt->exec.pRequest->msgBuf, pStmt->exec.pRequest->msgBufLen));
 
   return TSDB_CODE_SUCCESS;

source/client/src/tmq.c

@@ -343,7 +343,7 @@ tmq_list_t* tmq_list_new() {
 
 int32_t tmq_list_append(tmq_list_t* list, const char* src) {
   SArray* container = &list->container;
-  char*   topic = strDupUnquo(src);
+  char*   topic = strdup(src);
   if (taosArrayPush(container, &topic) == NULL) return -1;
   return 0;
 }
@@ -1870,8 +1870,7 @@ tmq_raw_data* tmq_get_raw_meta(TAOS_RES* res) {
   return NULL;
 }
 
-static char* buildCreateTableJson(SSchemaWrapper* schemaRow, SSchemaWrapper* schemaTag, char* name, int64_t id,
+static char *buildCreateTableJson(SSchemaWrapper *schemaRow, SSchemaWrapper* schemaTag, char* name, int64_t id, int8_t t){
-                                  int8_t t) {
   char*  string = NULL;
   cJSON* json = cJSON_CreateObject();
   if (json == NULL) {
@@ -1880,10 +1879,10 @@ static char* buildCreateTableJson(SSchemaWrapper* schemaRow, SSchemaWrapper* sch
   cJSON* type = cJSON_CreateString("create");
   cJSON_AddItemToObject(json, "type", type);
 
-  char uid[32] = {0};
+//  char uid[32] = {0};
-  sprintf(uid, "%" PRIi64, id);
+//  sprintf(uid, "%"PRIi64, id);
-  cJSON* id_ = cJSON_CreateString(uid);
+//  cJSON* id_ = cJSON_CreateString(uid);
-  cJSON_AddItemToObject(json, "id", id_);
+//  cJSON_AddItemToObject(json, "id", id_);
   cJSON* tableName = cJSON_CreateString(name);
   cJSON_AddItemToObject(json, "tableName", tableName);
   cJSON* tableType = cJSON_CreateString(t == TSDB_NORMAL_TABLE ? "normal" : "super");
@@ -1938,6 +1937,98 @@ static char* buildCreateTableJson(SSchemaWrapper* schemaRow, SSchemaWrapper* sch
   return string;
 }
 
+static char *buildAlterSTableJson(void* alterData, int32_t alterDataLen){
+  SMAlterStbReq  req = {0};
+  cJSON* json = NULL;
+  char*  string = NULL;
+
+  if (tDeserializeSMAlterStbReq(alterData, alterDataLen, &req) != 0) {
+    goto end;
+  }
+
+  json = cJSON_CreateObject();
+  if (json == NULL) {
+    goto end;
+  }
+  cJSON* type = cJSON_CreateString("alter");
+  cJSON_AddItemToObject(json, "type", type);
+//  cJSON* uid = cJSON_CreateNumber(id);
+//  cJSON_AddItemToObject(json, "uid", uid);
+  SName name = {0};
+  tNameFromString(&name, req.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+  cJSON* tableName = cJSON_CreateString(name.tname);
+  cJSON_AddItemToObject(json, "tableName", tableName);
+  cJSON* tableType = cJSON_CreateString("super");
+  cJSON_AddItemToObject(json, "tableType", tableType);
+
+  cJSON* alterType = cJSON_CreateNumber(req.alterType);
+  cJSON_AddItemToObject(json, "alterType", alterType);
+  switch (req.alterType) {
+    case TSDB_ALTER_TABLE_ADD_TAG:
+    case TSDB_ALTER_TABLE_ADD_COLUMN: {
+      TAOS_FIELD *field = taosArrayGet(req.pFields, 0);
+      cJSON* colName = cJSON_CreateString(field->name);
+      cJSON_AddItemToObject(json, "colName", colName);
+      cJSON* colType = cJSON_CreateNumber(field->type);
+      cJSON_AddItemToObject(json, "colType", colType);
+
+      if(field->type == TSDB_DATA_TYPE_BINARY){
+        int32_t length = field->bytes - VARSTR_HEADER_SIZE;
+        cJSON* cbytes = cJSON_CreateNumber(length);
+        cJSON_AddItemToObject(json, "colLength", cbytes);
+      }else if (field->type == TSDB_DATA_TYPE_NCHAR){
+        int32_t length = (field->bytes - VARSTR_HEADER_SIZE)/TSDB_NCHAR_SIZE;
+        cJSON* cbytes = cJSON_CreateNumber(length);
+        cJSON_AddItemToObject(json, "colLength", cbytes);
+      }
+      break;
+    }
+    case TSDB_ALTER_TABLE_DROP_TAG:
+    case TSDB_ALTER_TABLE_DROP_COLUMN:{
+      TAOS_FIELD *field = taosArrayGet(req.pFields, 0);
+      cJSON* colName = cJSON_CreateString(field->name);
+      cJSON_AddItemToObject(json, "colName", colName);
+      break;
+    }
+    case TSDB_ALTER_TABLE_UPDATE_TAG_BYTES:
+    case TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES:{
+      TAOS_FIELD *field = taosArrayGet(req.pFields, 0);
+      cJSON* colName = cJSON_CreateString(field->name);
+      cJSON_AddItemToObject(json, "colName", colName);
+      cJSON* colType = cJSON_CreateNumber(field->type);
+      cJSON_AddItemToObject(json, "colType", colType);
+      if(field->type == TSDB_DATA_TYPE_BINARY){
+        int32_t length = field->bytes - VARSTR_HEADER_SIZE;
+        cJSON* cbytes = cJSON_CreateNumber(length);
+        cJSON_AddItemToObject(json, "colLength", cbytes);
+      }else if (field->type == TSDB_DATA_TYPE_NCHAR){
+        int32_t length = (field->bytes - VARSTR_HEADER_SIZE)/TSDB_NCHAR_SIZE;
+        cJSON* cbytes = cJSON_CreateNumber(length);
+        cJSON_AddItemToObject(json, "colLength", cbytes);
+      }
+      break;
+    }
+    case TSDB_ALTER_TABLE_UPDATE_TAG_NAME:
+    case TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME:{
+      TAOS_FIELD *oldField = taosArrayGet(req.pFields, 0);
+      TAOS_FIELD *newField = taosArrayGet(req.pFields, 1);
+      cJSON* colName = cJSON_CreateString(oldField->name);
+      cJSON_AddItemToObject(json, "colName", colName);
+      cJSON* colNewName = cJSON_CreateString(newField->name);
+      cJSON_AddItemToObject(json, "colNewName", colNewName);
+      break;
+    }
+    default:
+      break;
+  }
+  string = cJSON_PrintUnformatted(json);
+
+  end:
+  cJSON_Delete(json);
+  tFreeSMAltertbReq(&req);
+  return string;
+}
+
 static char *processCreateStb(SMqMetaRsp *metaRsp){
   SVCreateStbReq req = {0};
   SDecoder       coder;
@@ -1960,53 +2051,77 @@ _err:
   return string;
 }
 
-static char* buildCreateCTableJson(STag* pTag, int64_t sid, char* name, int64_t id) {
+static char *processAlterStb(SMqMetaRsp *metaRsp){
+  SVCreateStbReq req = {0};
+  SDecoder       coder;
   char*  string = NULL;
+
+  // decode and process req
+  void* data = POINTER_SHIFT(metaRsp->metaRsp, sizeof(SMsgHead));
+  int32_t len = metaRsp->metaRspLen - sizeof(SMsgHead);
+  tDecoderInit(&coder, data, len);
+
+  if (tDecodeSVCreateStbReq(&coder, &req) < 0) {
+    goto _err;
+  }
+  string = buildAlterSTableJson(req.alterOriData, req.alterOriDataLen);
+  tDecoderClear(&coder);
+  return string;
+
+  _err:
+  tDecoderClear(&coder);
+  return string;
+}
+
+static char *buildCreateCTableJson(STag* pTag, char* sname, char* name, SArray* tagName, int64_t id){
+  char*  string = NULL;
+  SArray* pTagVals = NULL;
   cJSON* json = cJSON_CreateObject();
   if (json == NULL) {
     return string;
   }
   cJSON* type = cJSON_CreateString("create");
   cJSON_AddItemToObject(json, "type", type);
-  char cid[32] = {0};
+//  char cid[32] = {0};
-  sprintf(cid, "%" PRIi64, id);
+//  sprintf(cid, "%"PRIi64, id);
-  cJSON* cid_ = cJSON_CreateString(cid);
+//  cJSON* cid_ = cJSON_CreateString(cid);
-  cJSON_AddItemToObject(json, "id", cid_);
+//  cJSON_AddItemToObject(json, "id", cid_);
 
   cJSON* tableName = cJSON_CreateString(name);
   cJSON_AddItemToObject(json, "tableName", tableName);
   cJSON* tableType = cJSON_CreateString("child");
   cJSON_AddItemToObject(json, "tableType", tableType);
-
+  cJSON* using = cJSON_CreateString(sname);
-  char sid_[32] = {0};
-  sprintf(sid_, "%" PRIi64, sid);
-  cJSON* using = cJSON_CreateString(sid_);
   cJSON_AddItemToObject(json, "using", using);
 //  cJSON* version = cJSON_CreateNumber(1);
 //  cJSON_AddItemToObject(json, "version", version);
 
   cJSON* tags = cJSON_CreateArray();
+  int32_t code = tTagToValArray(pTag, &pTagVals);
+  if (code) {
+    goto end;
+  }
 
-  if (tTagIsJson(pTag)) {  // todo
+  if (tTagIsJson(pTag)) {
+    STag* p = (STag*)pTag;
+    if(p->nTag == 0){
+      goto end;
+    }
     char* pJson = parseTagDatatoJson(pTag);
-
     cJSON* tag = cJSON_CreateObject();
-    cJSON* tname = cJSON_CreateString("unknown");  // todo
+    STagVal* pTagVal = taosArrayGet(pTagVals, 0);
+
+    char*  ptname = taosArrayGet(tagName, 0);
+    cJSON* tname = cJSON_CreateString(ptname);
     cJSON_AddItemToObject(tag, "name", tname);
+//    cJSON* cid_ = cJSON_CreateString("");
+//    cJSON_AddItemToObject(tag, "cid", cid_);
     cJSON* ttype = cJSON_CreateNumber(TSDB_DATA_TYPE_JSON);
     cJSON_AddItemToObject(tag, "type", ttype);
     cJSON* tvalue = cJSON_CreateString(pJson);
     cJSON_AddItemToObject(tag, "value", tvalue);
     cJSON_AddItemToArray(tags, tag);
-    cJSON_AddItemToObject(json, "tags", tags);
+    taosMemoryFree(pJson);
-
-    string = cJSON_PrintUnformatted(json);
-    goto end;
-  }
-
-  SArray* pTagVals = NULL;
-  int32_t code = tTagToValArray(pTag, &pTagVals);
-  if (code) {
     goto end;
   }
 
@@ -2014,9 +2129,12 @@ static char* buildCreateCTableJson(STag* pTag, int64_t sid, char* name, int64_t
     STagVal* pTagVal = (STagVal*)taosArrayGet(pTagVals, i);
 
     cJSON* tag = cJSON_CreateObject();
-    //    cJSON* tname = cJSON_CreateNumber(pTagVal->cid);
+
-    cJSON* tname = cJSON_CreateString("unkonwn");  // todo
+    char*  ptname = taosArrayGet(tagName, i);
+    cJSON* tname = cJSON_CreateString(ptname);
     cJSON_AddItemToObject(tag, "name", tname);
+//    cJSON* cid = cJSON_CreateNumber(pTagVal->cid);
+//    cJSON_AddItemToObject(tag, "cid", cid);
     cJSON* ttype = cJSON_CreateNumber(pTagVal->type);
     cJSON_AddItemToObject(tag, "type", ttype);
 
@@ -2034,12 +2152,12 @@ static char* buildCreateCTableJson(STag* pTag, int64_t sid, char* name, int64_t
     cJSON_AddItemToObject(tag, "value", tvalue);
     cJSON_AddItemToArray(tags, tag);
   }
-  cJSON_AddItemToObject(json, "tags", tags);
-  string = cJSON_PrintUnformatted(json);
 
   end:
-
+  cJSON_AddItemToObject(json, "tags", tags);
+  string = cJSON_PrintUnformatted(json);
   cJSON_Delete(json);
+  taosArrayDestroy(pTagVals);
   return string;
 }
 
@@ -2060,11 +2178,9 @@ static char* processCreateTable(SMqMetaRsp* metaRsp) {
   for (int32_t iReq = 0; iReq < req.nReqs; iReq++) {
     pCreateReq = req.pReqs + iReq;
     if(pCreateReq->type == TSDB_CHILD_TABLE){
-      string =
+      string = buildCreateCTableJson((STag*)pCreateReq->ctb.pTag, pCreateReq->ctb.name, pCreateReq->name, pCreateReq->ctb.tagName, pCreateReq->uid);
-          buildCreateCTableJson((STag*)pCreateReq->ctb.pTag, pCreateReq->ctb.suid, pCreateReq->name, pCreateReq->uid);
     }else if(pCreateReq->type == TSDB_NORMAL_TABLE){
-      string =
+      string = buildCreateTableJson(&pCreateReq->ntb.schemaRow, NULL, pCreateReq->name, pCreateReq->uid, TSDB_NORMAL_TABLE);
-          buildCreateTableJson(&pCreateReq->ntb.schemaRow, NULL, pCreateReq->name, pCreateReq->uid, TSDB_NORMAL_TABLE);
     }
   }
 
@@ -2100,11 +2216,11 @@ static char* processAlterTable(SMqMetaRsp* metaRsp) {
   cJSON_AddItemToObject(json, "tableName", tableName);
   cJSON* tableType = cJSON_CreateString(vAlterTbReq.action == TSDB_ALTER_TABLE_UPDATE_TAG_VAL ? "child" : "normal");
   cJSON_AddItemToObject(json, "tableType", tableType);
+  cJSON* alterType = cJSON_CreateNumber(vAlterTbReq.action);
+  cJSON_AddItemToObject(json, "alterType", alterType);
 
   switch (vAlterTbReq.action) {
     case TSDB_ALTER_TABLE_ADD_COLUMN: {
-      cJSON* alterType = cJSON_CreateNumber(TSDB_ALTER_TABLE_ADD_COLUMN);
-      cJSON_AddItemToObject(json, "alterType", alterType);
       cJSON* colName = cJSON_CreateString(vAlterTbReq.colName);
       cJSON_AddItemToObject(json, "colName", colName);
       cJSON* colType = cJSON_CreateNumber(vAlterTbReq.type);
@@ -2122,33 +2238,27 @@ static char* processAlterTable(SMqMetaRsp* metaRsp) {
       break;
     }
     case TSDB_ALTER_TABLE_DROP_COLUMN:{
-      cJSON* alterType = cJSON_CreateNumber(TSDB_ALTER_TABLE_DROP_COLUMN);
-      cJSON_AddItemToObject(json, "alterType", alterType);
       cJSON* colName = cJSON_CreateString(vAlterTbReq.colName);
       cJSON_AddItemToObject(json, "colName", colName);
       break;
     }
     case TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES:{
-      cJSON* alterType = cJSON_CreateNumber(TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES);
-      cJSON_AddItemToObject(json, "alterType", alterType);
       cJSON* colName = cJSON_CreateString(vAlterTbReq.colName);
       cJSON_AddItemToObject(json, "colName", colName);
-      cJSON* colType = cJSON_CreateNumber(vAlterTbReq.type);
+      cJSON* colType = cJSON_CreateNumber(vAlterTbReq.colModType);
       cJSON_AddItemToObject(json, "colType", colType);
-      if (vAlterTbReq.type == TSDB_DATA_TYPE_BINARY) {
+      if(vAlterTbReq.colModType == TSDB_DATA_TYPE_BINARY){
-        int32_t length = vAlterTbReq.bytes - VARSTR_HEADER_SIZE;
+        int32_t length = vAlterTbReq.colModBytes - VARSTR_HEADER_SIZE;
         cJSON* cbytes = cJSON_CreateNumber(length);
         cJSON_AddItemToObject(json, "colLength", cbytes);
-      } else if (vAlterTbReq.type == TSDB_DATA_TYPE_NCHAR) {
+      }else if (vAlterTbReq.colModType == TSDB_DATA_TYPE_NCHAR){
-        int32_t length = (vAlterTbReq.bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE;
+        int32_t length = (vAlterTbReq.colModBytes - VARSTR_HEADER_SIZE)/TSDB_NCHAR_SIZE;
         cJSON* cbytes = cJSON_CreateNumber(length);
         cJSON_AddItemToObject(json, "colLength", cbytes);
       }
       break;
     }
     case TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME:{
-      cJSON* alterType = cJSON_CreateNumber(TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME);
-      cJSON_AddItemToObject(json, "alterType", alterType);
       cJSON* colName = cJSON_CreateString(vAlterTbReq.colName);
       cJSON_AddItemToObject(json, "colName", colName);
       cJSON* colNewName = cJSON_CreateString(vAlterTbReq.colNewName);
@@ -2156,14 +2266,32 @@ static char* processAlterTable(SMqMetaRsp* metaRsp) {
       break;
     }
     case TSDB_ALTER_TABLE_UPDATE_TAG_VAL:{
-      cJSON* alterType = cJSON_CreateNumber(TSDB_ALTER_TABLE_UPDATE_TAG_VAL);
-      cJSON_AddItemToObject(json, "alterType", alterType);
       cJSON* tagName = cJSON_CreateString(vAlterTbReq.tagName);
       cJSON_AddItemToObject(json, "colName", tagName);
-      cJSON* colValue = cJSON_CreateString("invalid, todo");  // todo
+
+      bool isNull = vAlterTbReq.isNull;
+      if(vAlterTbReq.tagType == TSDB_DATA_TYPE_JSON){
+        STag *jsonTag = (STag *)vAlterTbReq.pTagVal;
+        if(jsonTag->nTag == 0) isNull = true;
+      }
+      if (!isNull){
+        char* buf = NULL;
+
+        if (vAlterTbReq.tagType == TSDB_DATA_TYPE_JSON) {
+          ASSERT(tTagIsJson(vAlterTbReq.pTagVal) == true);
+          buf = parseTagDatatoJson(vAlterTbReq.pTagVal);
+        } else {
+          buf = taosMemoryCalloc(vAlterTbReq.nTagVal + 1, 1);
+          dataConverToStr(buf, vAlterTbReq.tagType, vAlterTbReq.pTagVal, vAlterTbReq.nTagVal, NULL);
+        }
+
+        cJSON* colValue = cJSON_CreateString(buf);
         cJSON_AddItemToObject(json, "colValue", colValue);
-      cJSON* isNull = cJSON_CreateBool(vAlterTbReq.isNull);
+        taosMemoryFree(buf);
-      cJSON_AddItemToObject(json, "colValueNull", isNull);
+      }
+
+      cJSON* isNullCJson = cJSON_CreateBool(isNull);
+      cJSON_AddItemToObject(json, "colValueNull", isNullCJson);
       break;
     }
     default:
@@ -2195,10 +2323,6 @@ static char* processDropSTable(SMqMetaRsp* metaRsp) {
   }
   cJSON* type = cJSON_CreateString("drop");
   cJSON_AddItemToObject(json, "type", type);
-  char uid[32] = {0};
-  sprintf(uid, "%" PRIi64, req.suid);
-  cJSON* id = cJSON_CreateString(uid);
-  cJSON_AddItemToObject(json, "id", id);
   cJSON* tableName = cJSON_CreateString(req.name);
   cJSON_AddItemToObject(json, "tableName", tableName);
   cJSON* tableType = cJSON_CreateString("super");
@@ -2239,7 +2363,7 @@ static char* processDropTable(SMqMetaRsp* metaRsp) {
   for (int32_t iReq = 0; iReq < req.nReqs; iReq++) {
     SVDropTbReq* pDropTbReq = req.pReqs + iReq;
 
-    cJSON* tableName = cJSON_CreateString(pDropTbReq->name);  // todo
+    cJSON* tableName = cJSON_CreateString(pDropTbReq->name);
     cJSON_AddItemToArray(tableNameList, tableName);
   }
   cJSON_AddItemToObject(json, "tableNameList", tableNameList);
@@ -2260,7 +2384,7 @@ char* tmq_get_json_meta(TAOS_RES* res) {
   if(pMetaRspObj->metaRsp.resMsgType == TDMT_VND_CREATE_STB){
     return processCreateStb(&pMetaRspObj->metaRsp);
   }else if(pMetaRspObj->metaRsp.resMsgType == TDMT_VND_ALTER_STB){
-    return processCreateStb(&pMetaRspObj->metaRsp);
+    return processAlterStb(&pMetaRspObj->metaRsp);
   }else if(pMetaRspObj->metaRsp.resMsgType == TDMT_VND_DROP_STB){
     return processDropSTable(&pMetaRspObj->metaRsp);
   }else if(pMetaRspObj->metaRsp.resMsgType == TDMT_VND_CREATE_TABLE){
@@ -2273,6 +2397,10 @@ char* tmq_get_json_meta(TAOS_RES* res) {
   return NULL;
 }
 
+void tmq_free_json_meta(char* jsonMeta){
+  taosMemoryFreeClear(jsonMeta);
+}
+
 static int32_t taosCreateStb(TAOS *taos, void *meta, int32_t metaLen){
   SVCreateStbReq req = {0};
   SDecoder       coder;
@@ -2312,16 +2440,17 @@ static int32_t taosCreateStb(TAOS* taos, void* meta, int32_t metaLen) {
     strcpy(field.name, pSchema->name);
     taosArrayPush(pReq.pTags, &field);
   }
+
   pReq.colVer = req.schemaRow.version;
   pReq.tagVer = req.schemaTag.version;
   pReq.numOfColumns = req.schemaRow.nCols;
   pReq.numOfTags = req.schemaTag.nCols;
   pReq.commentLen = -1;
   pReq.suid = req.suid;
-  pReq.source = 1;
+  pReq.source = TD_REQ_FROM_TAOX;
+  pReq.igExists = true;
 
   STscObj* pTscObj = pRequest->pTscObj;
-
   SName tableName;
   tNameExtractFullName(toName(pTscObj->acctId, pRequest->pDb, req.name, &tableName), pReq.name);
 
@@ -2380,11 +2509,10 @@ static int32_t taosDropStb(TAOS* taos, void* meta, int32_t metaLen) {
 
   // build drop stable
   pReq.igNotExists = true;
-  pReq.source = 1;
+  pReq.source = TD_REQ_FROM_TAOX;
   pReq.suid = req.suid;
 
   STscObj* pTscObj = pRequest->pTscObj;
-
   SName tableName;
   tNameExtractFullName(toName(pTscObj->acctId, pRequest->pDb, req.name, &tableName), pReq.name);
 
@@ -2439,6 +2567,7 @@ static int32_t taosCreateTable(TAOS* taos, void* meta, int32_t metaLen) {
     goto end;
   }
 
+
   if(!pRequest->pDb){
     code = TSDB_CODE_PAR_DB_NOT_SPECIFIED;
     goto end;
@@ -2588,6 +2717,7 @@ static int32_t taosDropTable(TAOS* taos, void* meta, int32_t metaLen) {
   // loop to create table
   for (int32_t iReq = 0; iReq < req.nReqs; iReq++) {
     pDropReq = req.pReqs + iReq;
+    pDropReq->igNotExists = true;
 
     SVgroupInfo pInfo = {0};
     SName pName;
@@ -2649,6 +2779,7 @@ static int32_t taosAlterTable(TAOS* taos, void* meta, int32_t metaLen) {
   SVgDataBlocks      *pVgData         = NULL;
 
   code = buildRequest(*(int64_t*) taos, "", 0, NULL, false, &pRequest);
+
   if (code != TSDB_CODE_SUCCESS) {
     goto end;
   }
@@ -2730,6 +2861,9 @@ static int32_t taosAlterTable(TAOS* taos, void* meta, int32_t metaLen) {
   pVgData = NULL;
   pArray  = NULL;
   code    = pRequest->code;
+  if (code == TSDB_CODE_VND_TABLE_NOT_EXIST){
+    code = 0;
+  }
 
   end:
   taosArrayDestroy(pArray);
@@ -2762,6 +2896,10 @@ int32_t taos_write_raw_meta(TAOS* taos, tmq_raw_data* raw_meta) {
   return TSDB_CODE_INVALID_PARA;
 }
 
+void tmq_free_raw_meta(tmq_raw_data *rawMeta){
+  taosMemoryFreeClear(rawMeta);
+}
+
 void tmq_commit_async(tmq_t* tmq, const TAOS_RES* msg, tmq_commit_cb* cb, void* param) {
   tmqCommitInner2(tmq, msg, 0, 1, cb, param);
 }

source/common/src/tdatablock.c

@@ -542,8 +542,10 @@ int32_t blockDataToBuf(char* buf, const SSDataBlock* pBlock) {
 }
 
 int32_t blockDataFromBuf(SSDataBlock* pBlock, const char* buf) {
-  pBlock->info.rows = *(int32_t*)buf;
+  int32_t numOfRows = *(int32_t*) buf;
+  blockDataEnsureCapacity(pBlock, numOfRows);
 
+  pBlock->info.rows = numOfRows;
   size_t      numOfCols = taosArrayGetSize(pBlock->pDataBlock);
   const char* pStart = buf + sizeof(uint32_t);
 
@@ -589,6 +591,7 @@ int32_t blockDataFromBuf(SSDataBlock* pBlock, const char* buf) {
   return TSDB_CODE_SUCCESS;
 }
 
+// todo remove this
 int32_t blockDataFromBuf1(SSDataBlock* pBlock, const char* buf, size_t capacity) {
   pBlock->info.rows = *(int32_t*)buf;
   pBlock->info.groupId = *(uint64_t*)(buf + sizeof(int32_t));
@@ -1194,15 +1197,28 @@ int32_t blockDataEnsureCapacity(SSDataBlock* pDataBlock, uint32_t numOfRows) {
   return TSDB_CODE_SUCCESS;
 }
 
+void blockDataFreeRes(SSDataBlock* pBlock) {
+  int32_t numOfOutput = taosArrayGetSize(pBlock->pDataBlock);
+  for (int32_t i = 0; i < numOfOutput; ++i) {
+    SColumnInfoData* pColInfoData = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, i);
+    colDataDestroy(pColInfoData);
+  }
+
+  taosArrayDestroy(pBlock->pDataBlock);
+  taosMemoryFreeClear(pBlock->pBlockAgg);
+  memset(&pBlock->info, 0, sizeof(SDataBlockInfo));
+}
+
 void* blockDataDestroy(SSDataBlock* pBlock) {
   if (pBlock == NULL) {
     return NULL;
   }
 
-  blockDestroyInner(pBlock);
+  blockDataFreeRes(pBlock);
   taosMemoryFreeClear(pBlock);
   return NULL;
 }
+
 int32_t assignOneDataBlock(SSDataBlock* dst, const SSDataBlock* src) {
   ASSERT(src != NULL);
 

source/common/src/tmsg.c

@@ -4871,6 +4871,11 @@ int tEncodeSVCreateStbReq(SEncoder *pCoder, const SVCreateStbReq *pReq) {
     if (tEncodeSRSmaParam(pCoder, &pReq->rsmaParam) < 0) return -1;
   }
 
+  if (tEncodeI32(pCoder, pReq->alterOriDataLen) < 0) return -1;
+  if (pReq->alterOriDataLen > 0) {
+    if (tEncodeBinary(pCoder, pReq->alterOriData, pReq->alterOriDataLen) < 0) return -1;
+  }
+
   tEndEncode(pCoder);
   return 0;
 }
@@ -4887,6 +4892,11 @@ int tDecodeSVCreateStbReq(SDecoder *pCoder, SVCreateStbReq *pReq) {
     if (tDecodeSRSmaParam(pCoder, &pReq->rsmaParam) < 0) return -1;
   }
 
+  if (tDecodeI32(pCoder, &pReq->alterOriDataLen) < 0) return -1;
+  if (pReq->alterOriDataLen > 0) {
+    if (tDecodeBinary(pCoder, (uint8_t **)&pReq->alterOriData, NULL) < 0) return -1;
+  }
+
   tEndDecode(pCoder);
   return 0;
 }
@@ -4930,8 +4940,15 @@ int tEncodeSVCreateTbReq(SEncoder *pCoder, const SVCreateTbReq *pReq) {
   }
 
   if (pReq->type == TSDB_CHILD_TABLE) {
+    if (tEncodeCStr(pCoder, pReq->ctb.name) < 0) return -1;
     if (tEncodeI64(pCoder, pReq->ctb.suid) < 0) return -1;
     if (tEncodeTag(pCoder, (const STag *)pReq->ctb.pTag) < 0) return -1;
+    int32_t len = taosArrayGetSize(pReq->ctb.tagName);
+    if (tEncodeI32(pCoder, len) < 0) return -1;
+    for (int32_t i = 0; i < len; i++){
+      char* name = taosArrayGet(pReq->ctb.tagName, i);
+      if (tEncodeCStr(pCoder, name) < 0) return -1;
+    }
   } else if (pReq->type == TSDB_NORMAL_TABLE) {
     if (tEncodeSSchemaWrapper(pCoder, &pReq->ntb.schemaRow) < 0) return -1;
   } else {
@@ -4959,8 +4976,20 @@ int tDecodeSVCreateTbReq(SDecoder *pCoder, SVCreateTbReq *pReq) {
   }
 
   if (pReq->type == TSDB_CHILD_TABLE) {
+    if (tDecodeCStr(pCoder, &pReq->ctb.name) < 0) return -1;
     if (tDecodeI64(pCoder, &pReq->ctb.suid) < 0) return -1;
     if (tDecodeTag(pCoder, (STag **)&pReq->ctb.pTag) < 0) return -1;
+    int32_t len = 0;
+    if (tDecodeI32(pCoder, &len) < 0) return -1;
+    pReq->ctb.tagName = taosArrayInit(len, TSDB_COL_NAME_LEN);
+    if(pReq->ctb.tagName == NULL) return -1;
+    for (int32_t i = 0; i < len; i++){
+      char name[TSDB_COL_NAME_LEN] = {0};
+      char *tmp = NULL;
+      if (tDecodeCStr(pCoder, &tmp) < 0) return -1;
+      strcpy(name, tmp);
+      taosArrayPush(pReq->ctb.tagName, name);
+    }
   } else if (pReq->type == TSDB_NORMAL_TABLE) {
     if (tDecodeSSchemaWrapperEx(pCoder, &pReq->ntb.schemaRow) < 0) return -1;
   } else {
@@ -5292,6 +5321,7 @@ int32_t tEncodeSVAlterTbReq(SEncoder *pEncoder, const SVAlterTbReq *pReq) {
       break;
     case TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES:
       if (tEncodeCStr(pEncoder, pReq->colName) < 0) return -1;
+      if (tEncodeI8(pEncoder, pReq->colModType) < 0) return -1;
       if (tEncodeI32v(pEncoder, pReq->colModBytes) < 0) return -1;
       break;
     case TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME:
@@ -5301,6 +5331,7 @@ int32_t tEncodeSVAlterTbReq(SEncoder *pEncoder, const SVAlterTbReq *pReq) {
     case TSDB_ALTER_TABLE_UPDATE_TAG_VAL:
       if (tEncodeCStr(pEncoder, pReq->tagName) < 0) return -1;
       if (tEncodeI8(pEncoder, pReq->isNull) < 0) return -1;
+      if (tEncodeI8(pEncoder, pReq->tagType) < 0) return -1;
       if (!pReq->isNull) {
         if (tEncodeBinary(pEncoder, pReq->pTagVal, pReq->nTagVal) < 0) return -1;
       }
@@ -5340,6 +5371,7 @@ int32_t tDecodeSVAlterTbReq(SDecoder *pDecoder, SVAlterTbReq *pReq) {
       break;
     case TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES:
       if (tDecodeCStr(pDecoder, &pReq->colName) < 0) return -1;
+      if (tDecodeI8(pDecoder, &pReq->colModType) < 0) return -1;
       if (tDecodeI32v(pDecoder, &pReq->colModBytes) < 0) return -1;
       break;
     case TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME:
@@ -5349,6 +5381,7 @@ int32_t tDecodeSVAlterTbReq(SDecoder *pDecoder, SVAlterTbReq *pReq) {
     case TSDB_ALTER_TABLE_UPDATE_TAG_VAL:
       if (tDecodeCStr(pDecoder, &pReq->tagName) < 0) return -1;
       if (tDecodeI8(pDecoder, &pReq->isNull) < 0) return -1;
+      if (tDecodeI8(pDecoder, &pReq->tagType) < 0) return -1;
       if (!pReq->isNull) {
         if (tDecodeBinary(pDecoder, &pReq->pTagVal, &pReq->nTagVal) < 0) return -1;
       }

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

@@ -168,7 +168,12 @@ int32_t mmPutMsgToQueue(SMnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc) {
   memcpy(pMsg, pRpc, sizeof(SRpcMsg));
 
   dTrace("msg:%p, is created and will put into %s queue, type:%s", pMsg, pWorker->name, TMSG_INFO(pRpc->msgType));
-  return mmPutMsgToWorker(pMgmt, pWorker, pMsg);
+  int32_t code = mmPutMsgToWorker(pMgmt, pWorker, pMsg);
+  if (code != 0) {
+    dTrace("msg:%p, is freed", pMsg);
+    taosFreeQitem(pMsg);
+  }
+  return code;
 }
 
 int32_t mmStartWorker(SMnodeMgmt *pMgmt) {

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

@@ -125,7 +125,7 @@ typedef struct SMnode {
 } SMnode;
 
 void    mndSetMsgHandle(SMnode *pMnode, tmsg_t msgType, MndMsgFp fp);
-int64_t mndGenerateUid(char *name, int32_t len);
+int64_t mndGenerateUid(const char *name, int32_t len);
 
 int32_t mndAcquireRpcRef(SMnode *pMnode);
 void    mndReleaseRpcRef(SMnode *pMnode);

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

@@ -624,7 +624,7 @@ void mndSetMsgHandle(SMnode *pMnode, tmsg_t msgType, MndMsgFp fp) {
 }
 
 // Note: uid 0 is reserved
-int64_t mndGenerateUid(char *name, int32_t len) {
+int64_t mndGenerateUid(const char *name, int32_t len) {
   int32_t hashval = MurmurHash3_32(name, len);
   do {
     int64_t us = taosGetTimestampUs();

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

@@ -479,7 +479,8 @@ static void mndDestroySmaObj(SSmaObj *pSmaObj) {
   }
 }
 
-static int32_t mndCreateSma(SMnode *pMnode, SRpcMsg *pReq, SMCreateSmaReq *pCreate, SDbObj *pDb, SStbObj *pStb) {
+static int32_t mndCreateSma(SMnode *pMnode, SRpcMsg *pReq, SMCreateSmaReq *pCreate, SDbObj *pDb, SStbObj *pStb,
+                            const char *streamName) {
   SSmaObj smaObj = {0};
   memcpy(smaObj.name, pCreate->name, TSDB_TABLE_FNAME_LEN);
   memcpy(smaObj.stb, pStb->name, TSDB_TABLE_FNAME_LEN);
@@ -520,12 +521,12 @@ static int32_t mndCreateSma(SMnode *pMnode, SRpcMsg *pReq, SMCreateSmaReq *pCrea
   }
 
   SStreamObj streamObj = {0};
-  tstrncpy(streamObj.name, pCreate->name, TSDB_STREAM_FNAME_LEN);
+  tstrncpy(streamObj.name, streamName, TSDB_STREAM_FNAME_LEN);
   tstrncpy(streamObj.sourceDb, pDb->name, TSDB_DB_FNAME_LEN);
   tstrncpy(streamObj.targetDb, streamObj.sourceDb, TSDB_DB_FNAME_LEN);
   streamObj.createTime = taosGetTimestampMs();
   streamObj.updateTime = streamObj.createTime;
-  streamObj.uid = mndGenerateUid(pCreate->name, strlen(pCreate->name));
+  streamObj.uid = mndGenerateUid(streamName, strlen(streamName));
   streamObj.sourceDbUid = pDb->uid;
   streamObj.targetDbUid = pDb->uid;
   streamObj.version = 1;
@@ -590,7 +591,7 @@ static int32_t mndCreateSma(SMnode *pMnode, SRpcMsg *pReq, SMCreateSmaReq *pCrea
   if (pTrans == NULL) goto _OVER;
   mndTransSetDbName(pTrans, pDb->name, NULL);
   mndTransSetSerial(pTrans);
-  mDebug("trans:%d, used to create sma:%s", pTrans->id, pCreate->name);
+  mDebug("trans:%d, used to create sma:%s stream:%s", pTrans->id, pCreate->name, streamObj.name);
 
   if (mndSetCreateSmaRedoLogs(pMnode, pTrans, &smaObj) != 0) goto _OVER;
   if (mndSetCreateSmaVgroupRedoLogs(pMnode, pTrans, &streamObj.fixedSinkVg) != 0) goto _OVER;
@@ -638,6 +639,14 @@ static int32_t mndCheckCreateSmaReq(SMCreateSmaReq *pCreate) {
   return 0;
 }
 
+static void mndGetStreamNameFromSmaName(char *streamName, char *smaName) {
+  SName n;
+  tNameFromString(&n, smaName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+  streamName[0] = '1';
+  streamName[1] = '.';
+  strcpy(streamName + 2, tNameGetTableName(&n));
+}
+
 static int32_t mndProcessCreateSmaReq(SRpcMsg *pReq) {
   SMnode        *pMnode = pReq->info.node;
   int32_t        code = -1;
@@ -663,9 +672,12 @@ static int32_t mndProcessCreateSmaReq(SRpcMsg *pReq) {
     goto _OVER;
   }
 
-  pStream = mndAcquireStream(pMnode, createReq.name);
+  char streamName[TSDB_TABLE_FNAME_LEN] = {0};
+  mndGetStreamNameFromSmaName(streamName, createReq.name);
+
+  pStream = mndAcquireStream(pMnode, streamName);
   if (pStream != NULL) {
-    mError("sma:%s, failed to create since stream:%s already exist", createReq.name, createReq.name);
+    mError("sma:%s, failed to create since stream:%s already exist", createReq.name, streamName);
     terrno = TSDB_CODE_MND_STREAM_ALREADY_EXIST;
     goto _OVER;
   }
@@ -692,7 +704,7 @@ static int32_t mndProcessCreateSmaReq(SRpcMsg *pReq) {
     goto _OVER;
   }
 
-  code = mndCreateSma(pMnode, pReq, &createReq, pDb, pStb);
+  code = mndCreateSma(pMnode, pReq, &createReq, pDb, pStb, streamName);
   if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;
 
 _OVER:
@@ -789,7 +801,10 @@ static int32_t mndDropSma(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SSmaObj *p
   mDebug("trans:%d, used to drop sma:%s", pTrans->id, pSma->name);
   mndTransSetDbName(pTrans, pDb->name, NULL);
 
-  SStreamObj *pStream = mndAcquireStream(pMnode, pSma->name);
+  char streamName[TSDB_TABLE_FNAME_LEN] = {0};
+  mndGetStreamNameFromSmaName(streamName, pSma->name);
+
+  SStreamObj *pStream = mndAcquireStream(pMnode, streamName);
   if (pStream == NULL || pStream->smaId != pSma->uid) {
     sdbRelease(pMnode->pSdb, pStream);
     goto _OVER;
@@ -838,7 +853,10 @@ int32_t mndDropSmasByStb(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *p
       pVgroup = mndAcquireVgroup(pMnode, pSma->dstVgId);
       if (pVgroup == NULL) goto _OVER;
 
-      SStreamObj *pStream = mndAcquireStream(pMnode, pSma->name);
+      char streamName[TSDB_TABLE_FNAME_LEN] = {0};
+      mndGetStreamNameFromSmaName(streamName, pSma->name);
+
+      SStreamObj *pStream = mndAcquireStream(pMnode, streamName);
       if (pStream != NULL && pStream->smaId == pSma->uid) {
         if (mndDropStreamTasks(pMnode, pTrans, pStream) < 0) {
           mError("stream:%s, failed to drop task since %s", pStream->name, terrstr());

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

@@ -45,7 +45,7 @@ static int32_t  mndProcessTableMetaReq(SRpcMsg *pReq);
 static int32_t  mndRetrieveStb(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
 static void     mndCancelGetNextStb(SMnode *pMnode, void *pIter);
 static int32_t  mndProcessTableCfgReq(SRpcMsg *pReq);
-static int32_t  mndAlterStbImp(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SStbObj *pStb, bool needRsp);
+static int32_t  mndAlterStbImp(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SStbObj *pStb, bool needRsp, void* alterOriData, int32_t alterOriDataLen);
 
 int32_t mndInitStb(SMnode *pMnode) {
   SSdbTable table = {
@@ -409,7 +409,7 @@ static FORCE_INLINE int32_t schemaExColIdCompare(const void *colId, const void *
   return 0;
 }
 
-static void *mndBuildVCreateStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pStb, int32_t *pContLen) {
+static void *mndBuildVCreateStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pStb, int32_t *pContLen, void* alterOriData, int32_t alterOriDataLen) {
   SEncoder       encoder = {0};
   int32_t        contLen;
   SName          name = {0};
@@ -422,6 +422,8 @@ static void *mndBuildVCreateStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pSt
   req.name = (char *)tNameGetTableName(&name);
   req.suid = pStb->uid;
   req.rollup = pStb->ast1Len > 0 ? 1 : 0;
+  req.alterOriData = alterOriData;
+  req.alterOriDataLen = alterOriDataLen;
   // todo
   req.schemaRow.nCols = pStb->numOfColumns;
   req.schemaRow.version = pStb->colVer;
@@ -626,7 +628,7 @@ static int32_t mndSetCreateStbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj
       continue;
     }
 
-    void *pReq = mndBuildVCreateStbReq(pMnode, pVgroup, pStb, &contLen);
+    void *pReq = mndBuildVCreateStbReq(pMnode, pVgroup, pStb, &contLen, NULL, 0);
     if (pReq == NULL) {
       sdbCancelFetch(pSdb, pIter);
       sdbRelease(pSdb, pVgroup);
@@ -706,10 +708,10 @@ int32_t mndBuildStbFromReq(SMnode *pMnode, SStbObj *pDst, SMCreateStbReq *pCreat
   memcpy(pDst->db, pDb->name, TSDB_DB_FNAME_LEN);
   pDst->createdTime = taosGetTimestampMs();
   pDst->updateTime = pDst->createdTime;
-  pDst->uid = (pCreate->source == 1) ? pCreate->suid : mndGenerateUid(pCreate->name, TSDB_TABLE_FNAME_LEN);
+  pDst->uid = (pCreate->source == TD_REQ_FROM_TAOX) ? pCreate->suid : mndGenerateUid(pCreate->name, TSDB_TABLE_FNAME_LEN);
   pDst->dbUid = pDb->uid;
-  pDst->tagVer = (pCreate->source != TD_REQ_FROM_APP) ? pCreate->tagVer : 1;
+  pDst->tagVer = 1;
-  pDst->colVer = (pCreate->source != TD_REQ_FROM_APP) ? pCreate->colVer : 1;
+  pDst->colVer = 1;
   pDst->smaVer = 1;
   pDst->nextColId = 1;
   pDst->maxdelay[0] = pCreate->delay1;
@@ -849,6 +851,75 @@ static int32_t mndProcessTtlTimer(SRpcMsg *pReq) {
   return 0;
 }
 
+static int32_t mndFindSuperTableTagIndex(const SStbObj *pStb, const char *tagName) {
+  for (int32_t tag = 0; tag < pStb->numOfTags; tag++) {
+    if (strcasecmp(pStb->pTags[tag].name, tagName) == 0) {
+      return tag;
+    }
+  }
+
+  return -1;
+}
+
+static int32_t mndFindSuperTableColumnIndex(const SStbObj *pStb, const char *colName) {
+  for (int32_t col = 0; col < pStb->numOfColumns; col++) {
+    if (strcasecmp(pStb->pColumns[col].name, colName) == 0) {
+      return col;
+    }
+  }
+
+  return -1;
+}
+
+static int32_t mndBuildStbFromAlter(SStbObj *pStb, SStbObj *pDst, SMCreateStbReq *createReq) {
+  taosRLockLatch(&pStb->lock);
+  memcpy(pDst, pStb, sizeof(SStbObj));
+  taosRUnLockLatch(&pStb->lock);
+
+  pDst->updateTime = taosGetTimestampMs();
+  pDst->numOfColumns = createReq->numOfColumns;
+  pDst->numOfTags = createReq->numOfTags;
+  pDst->pColumns = taosMemoryCalloc(1, pDst->numOfColumns * sizeof(SSchema));
+  pDst->pTags = taosMemoryCalloc(1, pDst->numOfTags * sizeof(SSchema));
+  if (pDst->pColumns == NULL || pDst->pTags == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
+
+  for (int32_t i = 0; i < pDst->numOfColumns; ++i) {
+    SField  *pField = taosArrayGet(createReq->pColumns, i);
+    SSchema *pSchema = &pDst->pColumns[i];
+    pSchema->type = pField->type;
+    pSchema->bytes = pField->bytes;
+    pSchema->flags = pField->flags;
+    memcpy(pSchema->name, pField->name, TSDB_COL_NAME_LEN);
+    int32_t cIndex = mndFindSuperTableColumnIndex(pStb, pField->name);
+    if (cIndex >= 0){
+      pSchema->colId = pStb->pColumns[cIndex].colId;
+    }else{
+      pSchema->colId = pDst->nextColId++;
+    }
+  }
+
+  for (int32_t i = 0; i < pDst->numOfTags; ++i) {
+    SField  *pField = taosArrayGet(createReq->pTags, i);
+    SSchema *pSchema = &pDst->pTags[i];
+    pSchema->type = pField->type;
+    pSchema->bytes = pField->bytes;
+    memcpy(pSchema->name, pField->name, TSDB_COL_NAME_LEN);
+    int32_t cIndex = mndFindSuperTableTagIndex(pStb, pField->name);
+    if (cIndex >= 0){
+      pSchema->colId = pStb->pTags[cIndex].colId;
+    }else{
+      pSchema->colId = pDst->nextColId++;
+    }
+
+  }
+  pDst->tagVer = createReq->tagVer;
+  pDst->colVer = createReq->colVer;
+  return TSDB_CODE_SUCCESS;
+}
+
 static int32_t mndProcessCreateStbReq(SRpcMsg *pReq) {
   SMnode        *pMnode = pReq->info.node;
   int32_t        code = -1;
@@ -881,9 +952,9 @@ static int32_t mndProcessCreateStbReq(SRpcMsg *pReq) {
         terrno = TSDB_CODE_MND_STABLE_UID_NOT_MATCH;
         goto _OVER;
       } else if (createReq.tagVer > 0 || createReq.colVer > 0) {
-        int32_t tagDelta = pStb->tagVer - createReq.tagVer;
+        int32_t tagDelta = createReq.tagVer - pStb->tagVer;
-        int32_t colDelta = pStb->colVer - createReq.colVer;
+        int32_t colDelta = createReq.colVer - pStb->colVer;
-        int32_t verDelta = tagDelta + verDelta;
+        int32_t verDelta = tagDelta + colDelta;
         mInfo("stb:%s, already exist while create, input tagVer:%d colVer:%d, exist tagVer:%d colVer:%d",
               createReq.name, createReq.tagVer, createReq.colVer, pStb->tagVer, pStb->colVer);
         if (tagDelta <= 0 && colDelta <= 0) {
@@ -910,6 +981,10 @@ static int32_t mndProcessCreateStbReq(SRpcMsg *pReq) {
     }
   } else if (terrno != TSDB_CODE_MND_STB_NOT_EXIST) {
     goto _OVER;
+  } else if (createReq.source == TD_REQ_FROM_TAOX && (createReq.tagVer != 1 || createReq.colVer != 1)){
+    mInfo("stb:%s, alter table does not need to be done, because table is deleted", createReq.name);
+    code = 0;
+    goto _OVER;
   }
 
   pDb = mndAcquireDbByStb(pMnode, createReq.name);
@@ -934,7 +1009,16 @@ static int32_t mndProcessCreateStbReq(SRpcMsg *pReq) {
 
   if (isAlter) {
     bool needRsp = false;
-    code = mndAlterStbImp(pMnode, pReq, pDb, pStb, needRsp);
+    SStbObj pDst = {0};
+    if (mndBuildStbFromAlter(pStb, &pDst, &createReq) != 0) {
+      taosMemoryFreeClear(pDst.pTags);
+      taosMemoryFreeClear(pDst.pColumns);
+      goto _OVER;
+    }
+
+    code = mndAlterStbImp(pMnode, pReq, pDb, &pDst, needRsp, NULL, 0);
+    taosMemoryFreeClear(pDst.pTags);
+    taosMemoryFreeClear(pDst.pColumns);
   } else {
     code = mndCreateStb(pMnode, pReq, &createReq, pDb);
   }
@@ -972,26 +1056,6 @@ static int32_t mndCheckAlterStbReq(SMAlterStbReq *pAlter) {
   return 0;
 }
 
-static int32_t mndFindSuperTableTagIndex(const SStbObj *pStb, const char *tagName) {
-  for (int32_t tag = 0; tag < pStb->numOfTags; tag++) {
-    if (strcasecmp(pStb->pTags[tag].name, tagName) == 0) {
-      return tag;
-    }
-  }
-
-  return -1;
-}
-
-static int32_t mndFindSuperTableColumnIndex(const SStbObj *pStb, const char *colName) {
-  for (int32_t col = 0; col < pStb->numOfColumns; col++) {
-    if (strcasecmp(pStb->pColumns[col].name, colName) == 0) {
-      return col;
-    }
-  }
-
-  return -1;
-}
-
 static int32_t mndAllocStbSchemas(const SStbObj *pOld, SStbObj *pNew) {
   pNew->pTags = taosMemoryCalloc(pNew->numOfTags, sizeof(SSchema));
   pNew->pColumns = taosMemoryCalloc(pNew->numOfColumns, sizeof(SSchema));
@@ -1315,7 +1379,7 @@ static int32_t mndSetAlterStbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *
   return 0;
 }
 
-static int32_t mndSetAlterStbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *pStb) {
+static int32_t mndSetAlterStbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *pStb, void* alterOriData, int32_t alterOriDataLen) {
   SSdb   *pSdb = pMnode->pSdb;
   SVgObj *pVgroup = NULL;
   void   *pIter = NULL;
@@ -1329,7 +1393,7 @@ static int32_t mndSetAlterStbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj
       continue;
     }
 
-    void *pReq = mndBuildVCreateStbReq(pMnode, pVgroup, pStb, &contLen);
+    void *pReq = mndBuildVCreateStbReq(pMnode, pVgroup, pStb, &contLen, alterOriData, alterOriDataLen);
     if (pReq == NULL) {
       sdbCancelFetch(pSdb, pIter);
       sdbRelease(pSdb, pVgroup);
@@ -1542,7 +1606,7 @@ static int32_t mndBuildSMAlterStbRsp(SDbObj *pDb, SStbObj *pObj, void **pCont, i
   return 0;
 }
 
-static int32_t mndAlterStbImp(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SStbObj *pStb, bool needRsp) {
+static int32_t mndAlterStbImp(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SStbObj *pStb, bool needRsp, void* alterOriData, int32_t alterOriDataLen) {
   int32_t code = -1;
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB_INSIDE, pReq);
   if (pTrans == NULL) goto _OVER;
@@ -1559,7 +1623,7 @@ static int32_t mndAlterStbImp(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SStbOb
 
   if (mndSetAlterStbRedoLogs(pMnode, pTrans, pDb, pStb) != 0) goto _OVER;
   if (mndSetAlterStbCommitLogs(pMnode, pTrans, pDb, pStb) != 0) goto _OVER;
-  if (mndSetAlterStbRedoActions(pMnode, pTrans, pDb, pStb) != 0) goto _OVER;
+  if (mndSetAlterStbRedoActions(pMnode, pTrans, pDb, pStb, alterOriData, alterOriDataLen) != 0) goto _OVER;
   if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
 
   code = 0;
@@ -1620,7 +1684,7 @@ static int32_t mndAlterStb(SMnode *pMnode, SRpcMsg *pReq, const SMAlterStbReq *p
   }
 
   if (code != 0) goto _OVER;
-  code = mndAlterStbImp(pMnode, pReq, pDb, &stbObj, needRsp);
+  code = mndAlterStbImp(pMnode, pReq, pDb, &stbObj, needRsp, pReq->pCont, pReq->contLen);
 
 _OVER:
   taosMemoryFreeClear(stbObj.pTags);
@@ -1785,8 +1849,8 @@ static int32_t mndProcessDropStbReq(SRpcMsg *pReq) {
     }
   }
 
-  if (dropReq.source != TD_REQ_FROM_APP && pStb->uid != dropReq.suid) {
+  if (dropReq.source == TD_REQ_FROM_TAOX && pStb->uid != dropReq.suid) {
-    terrno = TSDB_CODE_MND_STB_NOT_EXIST;
+    code = 0;
     goto _OVER;
   }
 

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

@@ -236,6 +236,7 @@ static int32_t mndStreamGetPlanString(const char *ast, int8_t triggerType, int64
 
 static int32_t mndBuildStreamObjFromCreateReq(SMnode *pMnode, SStreamObj *pObj, SCMCreateStreamReq *pCreate) {
   SNode      *pAst = NULL;
+  SQueryPlan *pPlan = NULL;
 
   mDebug("stream:%s to create", pCreate->name);
   memcpy(pObj->name, pCreate->name, TSDB_STREAM_FNAME_LEN);
@@ -293,7 +294,6 @@ static int32_t mndBuildStreamObjFromCreateReq(SMnode *pMnode, SStreamObj *pObj,
     goto FAIL;
   }
 
-  SQueryPlan  *pPlan = NULL;
   SPlanContext cxt = {
       .pAstRoot = pAst,
       .topicQuery = false,
@@ -317,6 +317,7 @@ static int32_t mndBuildStreamObjFromCreateReq(SMnode *pMnode, SStreamObj *pObj,
 
 FAIL:
   if (pAst != NULL) nodesDestroyNode(pAst);
+  if (pPlan != NULL) qDestroyQueryPlan(pPlan);
   return 0;
 }
 
@@ -541,7 +542,7 @@ static int32_t mndProcessCreateStreamReq(SRpcMsg *pReq) {
   // build stream obj from request
   SStreamObj streamObj = {0};
   if (mndBuildStreamObjFromCreateReq(pMnode, &streamObj, &createStreamReq) < 0) {
-    ASSERT(0);
+    /*ASSERT(0);*/
     mError("stream:%s, failed to create since %s", createStreamReq.name, terrstr());
     goto _OVER;
   }
@@ -689,7 +690,14 @@ int32_t mndDropStreamByDb(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {
         terrno = TSDB_CODE_MND_STREAM_ALREADY_EXIST;
         return -1;
       } else {
-        // TODO drop all task on snode
+#if 0
+        if (mndDropStreamTasks(pMnode, pTrans, pStream) < 0) {
+          mError("stream:%s, failed to drop task since %s", pStream->name, terrstr());
+          sdbRelease(pMnode->pSdb, pStream);
+          sdbCancelFetch(pSdb, pIter);
+          return -1;
+        }
+#endif
         if (mndPersistDropStreamLog(pMnode, pTrans, pStream) < 0) {
           sdbRelease(pSdb, pStream);
           sdbCancelFetch(pSdb, pIter);

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

@@ -1125,6 +1125,11 @@ static int metaSaveToSkmDb(SMeta *pMeta, const SMetaEntry *pME) {
   skmDbKey.uid = pME->uid;
   skmDbKey.sver = pSW->version;
 
+  // if receive tmq meta message is: create stable1 then delete stable1 then create stable1 with multi vgroups
+  if (tdbTbGet(pMeta->pSkmDb, &skmDbKey, sizeof(skmDbKey), NULL, NULL) == 0) {
+    return rcode;
+  }
+
   // encode schema
   int32_t ret = 0;
   tEncodeSize(tEncodeSSchemaWrapper, pSW, vLen, ret);

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

@@ -214,7 +214,6 @@ static int32_t tdInitSmaStat(SSmaStat **pSmaStat, int8_t smaType, const SSma *pS
       }
       pRSmaStat->refId = refId;
 
-
       // init hash
       RSMA_INFO_HASH(pRSmaStat) = taosHashInit(
           RSMA_TASK_INFO_HASH_SLOT, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_ENTRY_LOCK);
@@ -256,6 +255,7 @@ static void tdDestroyRSmaStat(void *pRSmaStat) {
 
     // step 2: destroy the rsma info and associated fetch tasks
     // TODO: use taosHashSetFreeFp when taosHashSetFreeFp is ready.
+#if 1
     if (taosHashGetSize(RSMA_INFO_HASH(pStat)) > 0) {
       void *infoHash = taosHashIterate(RSMA_INFO_HASH(pStat), NULL);
       while (infoHash) {
@@ -264,6 +264,7 @@ static void tdDestroyRSmaStat(void *pRSmaStat) {
         infoHash = taosHashIterate(RSMA_INFO_HASH(pStat), infoHash);
       }
     }
+#endif
     taosHashCleanup(RSMA_INFO_HASH(pStat));
 
     // step 3: wait all triggered fetch tasks finished

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

@@ -30,7 +30,7 @@ typedef struct SRSmaQTaskInfoIter SRSmaQTaskInfoIter;
 static int32_t    tdUidStorePut(STbUidStore *pStore, tb_uid_t suid, tb_uid_t *uid);
 static int32_t    tdUpdateTbUidListImpl(SSma *pSma, tb_uid_t *suid, SArray *tbUids);
 static int32_t    tdSetRSmaInfoItemParams(SSma *pSma, SRSmaParam *param, SRSmaStat *pStat, SRSmaInfo *pRSmaInfo,
-                                          SReadHandle *handle, int8_t idx);
+                                          int8_t idx);
 static int32_t    tdExecuteRSmaImpl(SSma *pSma, const void *pMsg, int32_t inputType, SRSmaInfoItem *rsmaItem,
                                     STSchema *pTSchema, tb_uid_t suid, int8_t level);
 static SRSmaInfo *tdGetRSmaInfoBySuid(SSma *pSma, int64_t suid);
@@ -256,14 +256,20 @@ int32_t tdFetchTbUidList(SSma *pSma, STbUidStore **ppStore, tb_uid_t suid, tb_ui
 }
 
 static int32_t tdSetRSmaInfoItemParams(SSma *pSma, SRSmaParam *param, SRSmaStat *pStat, SRSmaInfo *pRSmaInfo,
-                                       SReadHandle *pReadHandle, int8_t idx) {
+                                       int8_t idx) {
   SRetention *pRetention = SMA_RETENTION(pSma);
   STsdbCfg   *pTsdbCfg = SMA_TSDB_CFG(pSma);
 
+  SReadHandle handle = {
+      .meta = pSma->pVnode->pMeta,
+      .vnode = pSma->pVnode,
+      .initTqReader = 1,
+  };
+
   if (param->qmsg[idx]) {
     SRSmaInfoItem *pItem = &(pRSmaInfo->items[idx]);
     pItem->refId = RSMA_REF_ID(pStat);
-    pItem->taskInfo = qCreateStreamExecTaskInfo(param->qmsg[idx], pReadHandle);
+    pItem->taskInfo = qCreateStreamExecTaskInfo(param->qmsg[idx], &handle);
     if (!pItem->taskInfo) {
       terrno = TSDB_CODE_RSMA_QTASKINFO_CREATE;
       goto _err;
@@ -299,10 +305,6 @@ _err:
  * @return int32_t
  */
 int32_t tdProcessRSmaCreateImpl(SSma *pSma, SRSmaParam *param, int64_t suid, const char *tbName) {
-  SVnode *pVnode = pSma->pVnode;
-  SMeta  *pMeta = pVnode->pMeta;
-  SMsgCb *pMsgCb = &pVnode->msgCb;
-
   if ((param->qmsgLen[0] == 0) && (param->qmsgLen[1] == 0)) {
     smaDebug("vgId:%d, no qmsg1/qmsg2 for rollup table %s %" PRIi64, SMA_VID(pSma), tbName, suid);
     return TSDB_CODE_SUCCESS;
@@ -331,19 +333,6 @@ int32_t tdProcessRSmaCreateImpl(SSma *pSma, SRSmaParam *param, int64_t suid, con
     return TSDB_CODE_FAILED;
   }
 
-  STqReader *pReader = tqOpenReader(pVnode);
-  if (!pReader) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    goto _err;
-  }
-
-  SReadHandle handle = {
-      .tqReader = pReader,
-      .meta = pMeta,
-      .pMsgCb = pMsgCb,
-      .vnode = pVnode,
-  };
-
   STSchema *pTSchema = metaGetTbTSchema(SMA_META(pSma), suid, -1);
   if (!pTSchema) {
     terrno = TSDB_CODE_TDB_IVD_TB_SCHEMA_VERSION;
@@ -352,11 +341,11 @@ int32_t tdProcessRSmaCreateImpl(SSma *pSma, SRSmaParam *param, int64_t suid, con
   pRSmaInfo->pTSchema = pTSchema;
   pRSmaInfo->suid = suid;
 
-  if (tdSetRSmaInfoItemParams(pSma, param, pStat, pRSmaInfo, &handle, 0) < 0) {
+  if (tdSetRSmaInfoItemParams(pSma, param, pStat, pRSmaInfo, 0) < 0) {
     goto _err;
   }
 
-  if (tdSetRSmaInfoItemParams(pSma, param, pStat, pRSmaInfo, &handle, 1) < 0) {
+  if (tdSetRSmaInfoItemParams(pSma, param, pStat, pRSmaInfo, 1) < 0) {
     goto _err;
   }
 
@@ -369,7 +358,6 @@ int32_t tdProcessRSmaCreateImpl(SSma *pSma, SRSmaParam *param, int64_t suid, con
   return TSDB_CODE_SUCCESS;
 _err:
   tdFreeRSmaInfo(pSma, pRSmaInfo);
-  taosMemoryFree(pReader);
   return TSDB_CODE_FAILED;
 }
 
@@ -412,8 +400,6 @@ int32_t tdProcessRSmaDrop(SSma *pSma,  SVDropStbReq *pReq) {
     return TSDB_CODE_SUCCESS;
   }
 
-  
-
   smaDebug("vgId:%d, drop rsma for table %" PRIi64 " succeed", TD_VID(pVnode), pReq->suid);
   return TSDB_CODE_SUCCESS;
 }

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

@@ -82,6 +82,13 @@ void tqClose(STQ* pTq) {
   if (pTq) {
     tqOffsetClose(pTq->pOffsetStore);
     taosHashCleanup(pTq->handles);
+    void* pIter = NULL;
+    while (1) {
+      pIter = taosHashIterate(pTq->pStreamTasks, pIter);
+      if (pIter == NULL) break;
+      SStreamTask* pTask = *(SStreamTask**)pIter;
+      tFreeSStreamTask(pTask);
+    }
     taosHashCleanup(pTq->pStreamTasks);
     taosHashCleanup(pTq->pushMgr);
     taosMemoryFree(pTq->path);
@@ -401,7 +408,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
         tqDebug("fetch meta msg, ver:%" PRId64 ", type:%d", pHead->version, pHead->msgType);
         SMqMetaRsp metaRsp = {0};
         /*metaRsp.reqOffset = pReq->reqOffset.version;*/
-        /*metaRsp.rspOffset = fetchVer;*/
+        metaRsp.rspOffset = fetchVer;
         /*metaRsp.rspOffsetNew.version = fetchVer;*/
         tqOffsetResetToLog(&metaRsp.reqOffsetNew, pReq->reqOffset.version);
         tqOffsetResetToLog(&metaRsp.rspOffsetNew, fetchVer);
@@ -608,7 +615,8 @@ int32_t tqProcessTaskDeployReq(STQ* pTq, char* msg, int32_t msgLen) {
 
   streamSetupTrigger(pTask);
 
-  tqInfo("deploy stream task id %d child id %d on vgId:%d", pTask->taskId, pTask->selfChildId, TD_VID(pTq->pVnode));
+  tqInfo("deploy stream task on vg %d, task id %d, child id %d", TD_VID(pTq->pVnode), pTask->taskId,
+         pTask->selfChildId);
 
   taosHashPut(pTq->pStreamTasks, &pTask->taskId, sizeof(int32_t), &pTask, sizeof(void*));
 
@@ -634,9 +642,6 @@ int32_t tqProcessStreamTrigger(STQ* pTq, SSubmitReq* pReq) {
     pIter = taosHashIterate(pTq->pStreamTasks, pIter);
     if (pIter == NULL) break;
     SStreamTask* pTask = *(SStreamTask**)pIter;
-    if (atomic_load_8(&pTask->taskStatus) == TASK_STATUS__DROPPING) {
-      continue;
-    }
     if (!pTask->isDataScan) continue;
 
     if (!failed) {
@@ -665,11 +670,12 @@ int32_t tqProcessTaskRunReq(STQ* pTq, SRpcMsg* pMsg) {
   SStreamTaskRunReq* pReq = pMsg->pCont;
   int32_t            taskId = pReq->taskId;
   SStreamTask*       pTask = *(SStreamTask**)taosHashGet(pTq->pStreamTasks, &taskId, sizeof(int32_t));
-  if (atomic_load_8(&pTask->taskStatus) != TASK_STATUS__NORMAL) {
+  if (pTask) {
-    return 0;
-  }
     streamProcessRunReq(pTask);
     return 0;
+  } else {
+    return -1;
+  }
 }
 
 int32_t tqProcessTaskDispatchReq(STQ* pTq, SRpcMsg* pMsg) {
@@ -682,55 +688,62 @@ int32_t tqProcessTaskDispatchReq(STQ* pTq, SRpcMsg* pMsg) {
   tDecodeStreamDispatchReq(&decoder, &req);
   int32_t      taskId = req.taskId;
   SStreamTask* pTask = *(SStreamTask**)taosHashGet(pTq->pStreamTasks, &taskId, sizeof(int32_t));
-  if (atomic_load_8(&pTask->taskStatus) != TASK_STATUS__NORMAL) {
+  if (pTask) {
-    return 0;
-  }
     SRpcMsg rsp = {
         .info = pMsg->info,
         .code = 0,
     };
     streamProcessDispatchReq(pTask, &req, &rsp);
     return 0;
+  } else {
+    return -1;
+  }
 }
 
 int32_t tqProcessTaskRecoverReq(STQ* pTq, SRpcMsg* pMsg) {
   SStreamTaskRecoverReq* pReq = pMsg->pCont;
   int32_t                taskId = pReq->taskId;
   SStreamTask*           pTask = *(SStreamTask**)taosHashGet(pTq->pStreamTasks, &taskId, sizeof(int32_t));
-  if (atomic_load_8(&pTask->taskStatus) != TASK_STATUS__NORMAL) {
+  if (pTask) {
-    return 0;
-  }
     streamProcessRecoverReq(pTask, pReq, pMsg);
     return 0;
+  } else {
+    return -1;
+  }
 }
 
 int32_t tqProcessTaskDispatchRsp(STQ* pTq, SRpcMsg* pMsg) {
   SStreamDispatchRsp* pRsp = POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead));
   int32_t             taskId = pRsp->taskId;
   SStreamTask*        pTask = *(SStreamTask**)taosHashGet(pTq->pStreamTasks, &taskId, sizeof(int32_t));
-  if (atomic_load_8(&pTask->taskStatus) != TASK_STATUS__NORMAL) {
+  if (pTask) {
-    return 0;
-  }
     streamProcessDispatchRsp(pTask, pRsp);
     return 0;
+  } else {
+    return -1;
+  }
 }
 
 int32_t tqProcessTaskRecoverRsp(STQ* pTq, SRpcMsg* pMsg) {
   SStreamTaskRecoverRsp* pRsp = pMsg->pCont;
   int32_t                taskId = pRsp->taskId;
   SStreamTask*           pTask = *(SStreamTask**)taosHashGet(pTq->pStreamTasks, &taskId, sizeof(int32_t));
-  if (atomic_load_8(&pTask->taskStatus) != TASK_STATUS__NORMAL) {
+  if (pTask) {
-    return 0;
-  }
     streamProcessRecoverRsp(pTask, pRsp);
     return 0;
+  } else {
+    return -1;
+  }
 }
 
 int32_t tqProcessTaskDropReq(STQ* pTq, char* msg, int32_t msgLen) {
   SVDropStreamTaskReq* pReq = (SVDropStreamTaskReq*)msg;
 
   SStreamTask* pTask = *(SStreamTask**)taosHashGet(pTq->pStreamTasks, &pReq->taskId, sizeof(int32_t));
+  if (pTask) {
+    taosHashRemove(pTq->pStreamTasks, &pReq->taskId, sizeof(int32_t));
     atomic_store_8(&pTask->taskStatus, TASK_STATUS__DROPPING);
+  }
   // todo
   // clear queue
   // push drop req into queue

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

@@ -98,8 +98,21 @@ STqReader* tqOpenReader(SVnode* pVnode) {
 
 void tqCloseReader(STqReader* pReader) {
   // close wal reader
+  if (pReader->pWalReader) {
+    walCloseReader(pReader->pWalReader);
+  }
   // free cached schema
+  if (pReader->pSchema) {
+    taosMemoryFree(pReader->pSchema);
+  }
+  if (pReader->pSchemaWrapper) {
+    tDeleteSSchemaWrapper(pReader->pSchemaWrapper);
+  }
+  if (pReader->pColIdList) {
+    taosArrayDestroy(pReader->pColIdList);
+  }
   // free hash
+  taosHashCleanup(pReader->tbIdHash);
   taosMemoryFree(pReader);
 }
 
@@ -319,7 +332,7 @@ int32_t tqRetrieveDataBlock(SSDataBlock* pBlock, STqReader* pReader) {
   return 0;
 
 FAIL:
-  tDeleteSSDataBlock(pBlock);
+  blockDataFreeRes(pBlock);
   return -1;
 }
 

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

@@ -50,6 +50,7 @@ SSubmitReq* tdBlockToSubmit(const SArray* pBlocks, const STSchema* pTSchema, boo
 
       SVCreateTbReq createTbReq = {0};
       createTbReq.name = buildCtbNameByGroupId(stbFullName, pDataBlock->info.groupId);
+      createTbReq.ctb.name = strdup(stbFullName);
       createTbReq.flags = 0;
       createTbReq.type = TSDB_CHILD_TABLE;
       createTbReq.ctb.suid = suid;
@@ -146,7 +147,7 @@ SSubmitReq* tdBlockToSubmit(const SArray* pBlocks, const STSchema* pTSchema, boo
         const STColumn*  pColumn = &pTSchema->columns[k];
         SColumnInfoData* pColData = taosArrayGet(pDataBlock->pDataBlock, k);
         if (colDataIsNull_s(pColData, j)) {
-          tdAppendColValToRow(&rb, pColumn->colId, pColumn->type, TD_VTYPE_NONE, NULL, false, pColumn->offset, k);
+          tdAppendColValToRow(&rb, pColumn->colId, pColumn->type, TD_VTYPE_NULL, NULL, false, pColumn->offset, k);
         } else {
           void* data = colDataGetData(pColData, j);
           tdAppendColValToRow(&rb, pColumn->colId, pColumn->type, TD_VTYPE_NORM, data, true, pColumn->offset, k);

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

@@ -209,10 +209,10 @@ static void resetDataBlockScanInfo(SHashObj* pTableMap) {
     p->iterInit = false;
     p->iiter.hasVal = false;
     if (p->iter.iter != NULL) {
-      tsdbTbDataIterDestroy(p->iter.iter);
+      p->iter.iter = tsdbTbDataIterDestroy(p->iter.iter);
     }
 
-    taosArrayDestroy(p->delSkyline);
+    p->delSkyline = taosArrayDestroy(p->delSkyline);
   }
 }
 
@@ -224,18 +224,15 @@ static void destroyBlockScanInfo(SHashObj* pTableMap) {
     p->iiter.hasVal = false;
 
     if (p->iter.iter != NULL) {
-      tsdbTbDataIterDestroy(p->iter.iter);
+      p->iter.iter = tsdbTbDataIterDestroy(p->iter.iter);
-      p->iter.iter = NULL;
     }
 
     if (p->iiter.iter != NULL) {
-      tsdbTbDataIterDestroy(p->iiter.iter);
+      p->iiter.iter = tsdbTbDataIterDestroy(p->iiter.iter);
-      p->iiter.iter = NULL;
     }
 
-    taosArrayDestroy(p->delSkyline);
+    p->delSkyline = taosArrayDestroy(p->delSkyline);
-    taosArrayDestroy(p->pBlockList);
+    p->pBlockList = taosArrayDestroy(p->pBlockList);
-    p->delSkyline = NULL;
   }
 
   taosHashCleanup(pTableMap);

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

@@ -494,8 +494,6 @@ static int32_t vnodeProcessCreateTbReq(SVnode *pVnode, int64_t version, void *pR
     taosArrayPush(rsp.pArray, &cRsp);
   }
 
-  tDecoderClear(&decoder);
-
   tqUpdateTbUidList(pVnode->pTq, tbUids, true);
   tdUpdateTbUidList(pVnode->pSma, pStore);
   tdUidStoreFree(pStore);
@@ -512,9 +510,12 @@ static int32_t vnodeProcessCreateTbReq(SVnode *pVnode, int64_t version, void *pR
   }
   tEncoderInit(&encoder, pRsp->pCont, pRsp->contLen);
   tEncodeSVCreateTbBatchRsp(&encoder, &rsp);
-  tEncoderClear(&encoder);
 
 _exit:
+  for (int32_t iReq = 0; iReq < req.nReqs; iReq++) {
+    pCreateReq = req.pReqs + iReq;
+    taosArrayDestroy(pCreateReq->ctb.tagName);
+  }
   taosArrayDestroy(rsp.pArray);
   taosArrayDestroy(tbUids);
   tDecoderClear(&decoder);
@@ -611,7 +612,7 @@ static int32_t vnodeProcessAlterTbReq(SVnode *pVnode, int64_t version, void *pRe
 
   // process
   if (metaAlterTable(pVnode->pMeta, version, &vAlterTbReq, &vMetaRsp) < 0) {
-    vAlterTbRsp.code = TSDB_CODE_INVALID_MSG;
+    vAlterTbRsp.code = terrno;
     tDecoderClear(&dc);
     rcode = -1;
     goto _exit;
@@ -795,6 +796,7 @@ static int32_t vnodeProcessSubmitReq(SVnode *pVnode, int64_t version, void *pReq
       if (tDecodeSVCreateTbReq(&decoder, &createTbReq) < 0) {
         pRsp->code = TSDB_CODE_INVALID_MSG;
         tDecoderClear(&decoder);
+        taosArrayDestroy(createTbReq.ctb.tagName);
         goto _exit;
       }
 
@@ -802,6 +804,7 @@ static int32_t vnodeProcessSubmitReq(SVnode *pVnode, int64_t version, void *pReq
         if (terrno != TSDB_CODE_TDB_TABLE_ALREADY_EXIST) {
           submitBlkRsp.code = terrno;
           tDecoderClear(&decoder);
+          taosArrayDestroy(createTbReq.ctb.tagName);
           goto _exit;
         }
       }
@@ -822,6 +825,7 @@ static int32_t vnodeProcessSubmitReq(SVnode *pVnode, int64_t version, void *pReq
       vnodeDebugPrintSingleSubmitMsg(pVnode->pMeta, pBlock, &msgIter, "real uid");
 #endif
       tDecoderClear(&decoder);
+      taosArrayDestroy(createTbReq.ctb.tagName);
     } else {
       submitBlkRsp.tblFName = taosMemoryMalloc(TSDB_TABLE_FNAME_LEN);
       sprintf(submitBlkRsp.tblFName, "%s.", pVnode->config.dbname);

source/libs/executor/inc/executorimpl.h

@@ -147,7 +147,6 @@ typedef struct {
   SSDataBlock*   pullOverBlk;   // for streaming
   SWalFilterCond cond;
   int64_t        lastScanUid;
-  SStreamQueue*  inputQueue;
 } SStreamTaskInfo;
 
 typedef struct SExecTaskInfo {
@@ -561,6 +560,7 @@ typedef struct SFillOperatorInfo {
   SNode*            pCondition;
   SArray*           pColMatchColInfo;
   int32_t           primaryTsCol;
+  uint64_t          curGroupId;       // current handled group id
 } SFillOperatorInfo;
 
 typedef struct SGroupbyOperatorInfo {

source/libs/executor/src/executil.c

@@ -307,7 +307,6 @@ int32_t getTableList(void* metaHandle, void* pVnode, SScanPhysiNode* pScanNode,
   SNode* pTagIndexCond = (SNode*)pListInfo->pTagIndexCond;
   if (pScanNode->tableType == TSDB_SUPER_TABLE) {
     if (pTagIndexCond) {
-      ///<<<<<<< HEAD
       SIndexMetaArg metaArg = {
           .metaEx = metaHandle, .idx = tsdbGetIdx(metaHandle), .ivtIdx = tsdbGetIvtIdx(metaHandle), .suid = tableUid};
 
@@ -315,20 +314,9 @@ int32_t getTableList(void* metaHandle, void* pVnode, SScanPhysiNode* pScanNode,
       SIdxFltStatus status = SFLT_NOT_INDEX;
       code = doFilterTag(pTagIndexCond, &metaArg, res, &status);
       if (code != 0 || status == SFLT_NOT_INDEX) {
-        code = TSDB_CODE_INDEX_REBUILDING;
+        qError("failed to get tableIds from index, reason:%s, suid:%" PRIu64, tstrerror(code), tableUid);
-      }
-      //=======
-      //      SArray* res = taosArrayInit(8, sizeof(uint64_t));
-      //      // code = doFilterTag(pTagIndexCond, &metaArg, res);
 //        code = TSDB_CODE_INDEX_REBUILDING;
-      //>>>>>>> dvv
-      if (code == TSDB_CODE_INDEX_REBUILDING) {
         code = vnodeGetAllTableList(pVnode, tableUid, pListInfo->pTableList);
-      } else if (code != TSDB_CODE_SUCCESS) {
-        qError("failed to get tableIds, reason:%s, suid:%" PRIu64, tstrerror(code), tableUid);
-        taosArrayDestroy(res);
-        terrno = code;
-        return code;
       } else {
         qDebug("success to get tableIds, size:%d, suid:%" PRIu64, (int)taosArrayGetSize(res), tableUid);
       }
@@ -347,6 +335,10 @@ int32_t getTableList(void* metaHandle, void* pVnode, SScanPhysiNode* pScanNode,
       terrno = code;
       return code;
     }
+  } else {  // Create one table group.
+    STableKeyInfo info = {.lastKey = 0, .uid = tableUid, .groupId = 0};
+    taosArrayPush(pListInfo->pTableList, &info);
+  }
 
   if (pTagCond) {
     int32_t i = 0;
@@ -361,10 +353,6 @@ int32_t getTableList(void* metaHandle, void* pVnode, SScanPhysiNode* pScanNode,
       i++;
     }
   }
-  } else {  // Create one table group.
-    STableKeyInfo info = {.lastKey = 0, .uid = tableUid, .groupId = 0};
-    taosArrayPush(pListInfo->pTableList, &info);
-  }
 
   pListInfo->pGroupList = taosArrayInit(4, POINTER_BYTES);
   if (pListInfo->pGroupList == NULL) {
@@ -853,6 +841,9 @@ static STimeWindow doCalculateTimeWindow(int64_t ts, SInterval* pInterval) {
     w.ekey = taosTimeAdd(w.skey, pInterval->interval, pInterval->intervalUnit, pInterval->precision) - 1;
   } else {
     int64_t st = w.skey;
+    if (pInterval->offset > 0) {
+      st = taosTimeAdd(st, pInterval->offset, pInterval->offsetUnit, pInterval->precision);
+    }
 
     if (st > ts) {
       st -= ((st - ts + pInterval->sliding - 1) / pInterval->sliding) * pInterval->sliding;

source/libs/executor/src/executorMain.c

@@ -44,13 +44,6 @@ int32_t qCreateExecTask(SReadHandle* readHandle, int32_t vgId, uint64_t taskId,
     goto _error;
   }
 
-  if (model == OPTR_EXEC_MODEL_STREAM) {
-    (*pTask)->streamInfo.inputQueue = streamQueueOpen();
-    if ((*pTask)->streamInfo.inputQueue == NULL) {
-      goto _error;
-    }
-  }
-
   SDataSinkMgtCfg cfg = {.maxDataBlockNum = 1000, .maxDataBlockNumPerQuery = 100};
   code = dsDataSinkMgtInit(&cfg);
   if (code != TSDB_CODE_SUCCESS) {
@@ -259,12 +252,14 @@ int32_t qExtractStreamScanner(qTaskInfo_t tinfo, void** scanner) {
   }
 }
 
+#if 0
 int32_t qStreamInput(qTaskInfo_t tinfo, void* pItem) {
   SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo;
   ASSERT(pTaskInfo->execModel == OPTR_EXEC_MODEL_STREAM);
   taosWriteQitem(pTaskInfo->streamInfo.inputQueue->queue, pItem);
   return 0;
 }
+#endif
 
 void* qExtractReaderFromStreamScanner(void* scanner) {
   SStreamScanInfo* pInfo = scanner;

source/libs/executor/src/executorimpl.c

@@ -1637,8 +1637,6 @@ static int32_t compressQueryColData(SColumnInfoData* pColRes, int32_t numOfRows,
 
 int32_t doFillTimeIntervalGapsInResults(struct SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t capacity) {
   int32_t numOfRows = (int32_t)taosFillResultDataBlock(pFillInfo, pBlock, capacity - pBlock->info.rows);
-  pBlock->info.rows += numOfRows;
-
   return pBlock->info.rows;
 }
 
@@ -3344,14 +3342,15 @@ static void doHandleRemainBlockForNewGroupImpl(SFillOperatorInfo* pInfo, SResult
   taosFillSetInputDataBlock(pInfo->pFillInfo, pInfo->existNewGroupBlock);
 
   doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, pResultInfo->capacity);
+  pInfo->curGroupId = pInfo->existNewGroupBlock->info.groupId;
   pInfo->existNewGroupBlock = NULL;
-  *newgroup = true;
+//  *newgroup = true;
 }
 
 static void doHandleRemainBlockFromNewGroup(SFillOperatorInfo* pInfo, SResultInfo* pResultInfo, bool* newgroup,
                                             SExecTaskInfo* pTaskInfo) {
   if (taosFillHasMoreResults(pInfo->pFillInfo)) {
-    *newgroup = false;
+//    *newgroup = false;
     doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, (int32_t)pResultInfo->capacity);
     if (pInfo->pRes->info.rows > pResultInfo->threshold || (!pInfo->multigroupResult)) {
       return;
@@ -3373,10 +3372,7 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) {
 
   blockDataCleanup(pResBlock);
 
-  // todo handle different group data interpolation
+  doHandleRemainBlockFromNewGroup(pInfo, pResultInfo, NULL, pTaskInfo);
-  bool  n = false;
-  bool* newgroup = &n;
-  doHandleRemainBlockFromNewGroup(pInfo, pResultInfo, newgroup, pTaskInfo);
   if (pResBlock->info.rows > pResultInfo->threshold || (!pInfo->multigroupResult && pResBlock->info.rows > 0)) {
     return pResBlock;
   }
@@ -3384,20 +3380,6 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) {
   SOperatorInfo* pDownstream = pOperator->pDownstream[0];
   while (1) {
     SSDataBlock* pBlock = pDownstream->fpSet.getNextFn(pDownstream);
-    if (*newgroup) {
-      assert(pBlock != NULL);
-    }
-
-    blockDataUpdateTsWindow(pBlock, pInfo->primaryTsCol);
-
-    if (*newgroup && pInfo->totalInputRows > 0) {  // there are already processed current group data block
-      pInfo->existNewGroupBlock = pBlock;
-      *newgroup = false;
-
-      // Fill the previous group data block, before handle the data block of new group.
-      // Close the fill operation for previous group data block
-      taosFillSetStartInfo(pInfo->pFillInfo, 0, pInfo->win.ekey);
-    } else {
     if (pBlock == NULL) {
       if (pInfo->totalInputRows == 0) {
         pOperator->status = OP_EXEC_DONE;
@@ -3406,9 +3388,21 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) {
 
       taosFillSetStartInfo(pInfo->pFillInfo, 0, pInfo->win.ekey);
     } else {
+      blockDataUpdateTsWindow(pBlock, pInfo->primaryTsCol);
+
+      if (pInfo->curGroupId == 0 || pInfo->curGroupId == pBlock->info.groupId) {
+        pInfo->curGroupId = pBlock->info.groupId;   // the first data block
+
         pInfo->totalInputRows += pBlock->info.rows;
+
         taosFillSetStartInfo(pInfo->pFillInfo, pBlock->info.rows, pBlock->info.window.ekey);
         taosFillSetInputDataBlock(pInfo->pFillInfo, pBlock);
+      } else if (pInfo->curGroupId != pBlock->info.groupId) { // the new group data block
+        pInfo->existNewGroupBlock = pBlock;
+
+        // Fill the previous group data block, before handle the data block of new group.
+        // Close the fill operation for previous group data block
+        taosFillSetStartInfo(pInfo->pFillInfo, 0, pInfo->win.ekey);
       }
     }
 
@@ -3419,17 +3413,17 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) {
     if (pResBlock->info.rows > 0) {
       // 1. The result in current group not reach the threshold of output result, continue
       // 2. If multiple group results existing in one SSDataBlock is not allowed, return immediately
-      if (pResBlock->info.rows > pResultInfo->threshold || pBlock == NULL || (!pInfo->multigroupResult)) {
+      if (pResBlock->info.rows > pResultInfo->threshold || pBlock == NULL || pInfo->existNewGroupBlock != NULL) {
         return pResBlock;
       }
 
-      doHandleRemainBlockFromNewGroup(pInfo, pResultInfo, newgroup, pTaskInfo);
+      doHandleRemainBlockFromNewGroup(pInfo, pResultInfo, NULL, pTaskInfo);
-      if (pResBlock->info.rows > pOperator->resultInfo.threshold || pBlock == NULL) {
+      if (pResBlock->info.rows >= pOperator->resultInfo.threshold || pBlock == NULL) {
         return pResBlock;
       }
     } else if (pInfo->existNewGroupBlock) {  // try next group
       assert(pBlock != NULL);
-      doHandleRemainBlockForNewGroupImpl(pInfo, pResultInfo, newgroup, pTaskInfo);
+      doHandleRemainBlockForNewGroupImpl(pInfo, pResultInfo, NULL, pTaskInfo);
       if (pResBlock->info.rows > pResultInfo->threshold) {
         return pResBlock;
       }

source/libs/executor/src/scanoperator.c

@@ -874,16 +874,16 @@ static bool prepareRangeScan(SStreamScanInfo* pInfo, SSDataBlock* pBlock, int32_
   return true;
 }
 
-static STimeWindow getSlidingWindow(TSKEY* tsCol, SInterval* pInterval, SDataBlockInfo* pDataBlockInfo, int32_t* pRowIndex) {
+static STimeWindow getSlidingWindow(TSKEY* tsCol, SInterval* pInterval, SDataBlockInfo* pDataBlockInfo,
+                                    int32_t* pRowIndex) {
   SResultRowInfo dumyInfo;
   dumyInfo.cur.pageId = -1;
-  STimeWindow win = getActiveTimeWindow(NULL, &dumyInfo, tsCol[*pRowIndex], pInterval,
+  STimeWindow win = getActiveTimeWindow(NULL, &dumyInfo, tsCol[*pRowIndex], pInterval, TSDB_ORDER_ASC);
-      TSDB_ORDER_ASC);
   STimeWindow endWin = win;
   STimeWindow preWin = win;
   while (1) {
-    (*pRowIndex) += getNumOfRowsInTimeWindow(pDataBlockInfo, tsCol, *pRowIndex, endWin.ekey,
+    (*pRowIndex) += getNumOfRowsInTimeWindow(pDataBlockInfo, tsCol, *pRowIndex, endWin.ekey, binarySearchForKey, NULL,
-        binarySearchForKey, NULL, TSDB_ORDER_ASC);
+                                             TSDB_ORDER_ASC);
     do {
       preWin = endWin;
       getNextTimeWindow(pInterval, &endWin, TSDB_ORDER_ASC);
@@ -923,7 +923,8 @@ static bool prepareDataScan(SStreamScanInfo* pInfo, SSDataBlock* pSDB, int32_t t
       pInfo->updateWin.ekey = tsCols[*pRowIndex - 1];
       // win = getActiveTimeWindow(NULL, &dumyInfo, tsCols[*pRowIndex], &pInfo->interval, TSDB_ORDER_ASC);
       // (*pRowIndex) +=
-      //     getNumOfRowsInTimeWindow(&pSDB->info, tsCols, *pRowIndex, win.ekey, binarySearchForKey, NULL, TSDB_ORDER_ASC);
+      //     getNumOfRowsInTimeWindow(&pSDB->info, tsCols, *pRowIndex, win.ekey, binarySearchForKey, NULL,
+      //     TSDB_ORDER_ASC);
     }
     needRead = true;
   } else if (isStateWindow(pInfo)) {
@@ -1177,7 +1178,6 @@ static int32_t setBlockIntoRes(SStreamScanInfo* pInfo, const SSDataBlock* pBlock
     for (int32_t j = 0; j < blockDataGetNumOfCols(pBlock); ++j) {
       SColumnInfoData* pResCol = bdGetColumnInfoData(pBlock, j);
       if (pResCol->info.colId == pColMatchInfo->colId) {
-
         SColumnInfoData* pDst = taosArrayGet(pInfo->pRes->pDataBlock, pColMatchInfo->targetSlotId);
         colDataAssign(pDst, pResCol, pBlock->info.rows, &pInfo->pRes->info);
         //        taosArraySet(pInfo->pRes->pDataBlock, pColMatchInfo->targetSlotId, pResCol);
@@ -1193,8 +1193,6 @@ static int32_t setBlockIntoRes(SStreamScanInfo* pInfo, const SSDataBlock* pBlock
     }
   }
 
-  taosArrayDestroy(pBlock->pDataBlock);
-
   ASSERT(pInfo->pRes->pDataBlock != NULL);
 
   // currently only the tbname pseudo column
@@ -1202,12 +1200,14 @@ static int32_t setBlockIntoRes(SStreamScanInfo* pInfo, const SSDataBlock* pBlock
     int32_t code = addTagPseudoColumnData(&pInfo->readHandle, pInfo->pPseudoExpr, pInfo->numOfPseudoExpr, pInfo->pRes,
                                           GET_TASKID(pTaskInfo));
     if (code != TSDB_CODE_SUCCESS) {
+      blockDataFreeRes((SSDataBlock*)pBlock);
       longjmp(pTaskInfo->env, code);
     }
   }
 
   doFilter(pInfo->pCondition, pInfo->pRes);
   blockDataUpdateTsWindow(pInfo->pRes, pInfo->primaryTsIndex);
+  blockDataFreeRes((SSDataBlock*)pBlock);
   return 0;
 }
 
@@ -1441,6 +1441,29 @@ SOperatorInfo* createRawScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNo
   return NULL;
 }
 
+static void destroyStreamScanOperatorInfo(void* param, int32_t numOfOutput) {
+  SStreamScanInfo* pStreamScan = (SStreamScanInfo*)param;
+#if 1
+  if (pStreamScan->pTableScanOp && pStreamScan->pTableScanOp->info) {
+    STableScanInfo* pTableScanInfo = pStreamScan->pTableScanOp->info;
+    destroyTableScanOperatorInfo(pTableScanInfo, 1);
+  }
+#endif
+  if (pStreamScan->tqReader) {
+    tqCloseReader(pStreamScan->tqReader);
+  }
+  if (pStreamScan->pColMatchInfo) {
+    taosArrayDestroy(pStreamScan->pColMatchInfo);
+  }
+  updateInfoDestroy(pStreamScan->pUpdateInfo);
+  blockDataDestroy(pStreamScan->pRes);
+  blockDataDestroy(pStreamScan->pUpdateRes);
+  blockDataDestroy(pStreamScan->pPullDataRes);
+  blockDataDestroy(pStreamScan->pDeleteDataRes);
+  taosArrayDestroy(pStreamScan->pBlockLists);
+  taosMemoryFree(pStreamScan);
+}
+
 SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode* pTableScanNode,
                                             SExecTaskInfo* pTaskInfo, STimeWindowAggSupp* pTwSup, uint64_t queryId,
                                             uint64_t taskId) {
@@ -1555,8 +1578,8 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys
   pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pRes->pDataBlock);
   pOperator->pTaskInfo = pTaskInfo;
 
-  pOperator->fpSet =
+  pOperator->fpSet = createOperatorFpSet(operatorDummyOpenFn, doStreamScan, NULL, NULL, destroyStreamScanOperatorInfo,
-      createOperatorFpSet(operatorDummyOpenFn, doStreamScan, NULL, NULL, operatorDummyCloseFn, NULL, NULL, NULL);
+                                         NULL, NULL, NULL);
 
   return pOperator;
 
@@ -2595,11 +2618,19 @@ static SSDataBlock* getTableDataBlock(void* param) {
   return NULL;
 }
 
-SArray* generateSortByTsInfo(int32_t order) {
+SArray* generateSortByTsInfo(SArray* colMatchInfo, int32_t order) {
+  int32_t tsTargetSlotId = 0;
+  for (int32_t i = 0; i < taosArrayGetSize(colMatchInfo); ++i) {
+    SColMatchInfo* colInfo = taosArrayGet(colMatchInfo, i);
+    if (colInfo->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
+      tsTargetSlotId = colInfo->targetSlotId;
+    }
+  }
+
   SArray*         pList = taosArrayInit(1, sizeof(SBlockOrderInfo));
   SBlockOrderInfo bi = {0};
   bi.order = order;
-  bi.slotId = 0;
+  bi.slotId = tsTargetSlotId;
   bi.nullFirst = NULL_ORDER_FIRST;
 
   taosArrayPush(pList, &bi);
@@ -2848,7 +2879,7 @@ SOperatorInfo* createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanN
 
   pInfo->sortSourceParams = taosArrayInit(64, sizeof(STableMergeScanSortSourceParam));
 
-  pInfo->pSortInfo = generateSortByTsInfo(pInfo->cond.order);
+  pInfo->pSortInfo = generateSortByTsInfo(pInfo->pColMatchInfo, pInfo->cond.order);
   pInfo->pSortInputBlock = createOneDataBlock(pInfo->pResBlock, false);
 
   int32_t rowSize = pInfo->pResBlock->info.rowSize;

source/libs/executor/src/tfill.c

@@ -53,7 +53,7 @@ static void setNullRow(SSDataBlock* pBlock, int64_t ts, int32_t rowIndex) {
   // the first are always the timestamp column, so start from the second column.
   for (int32_t i = 0; i < taosArrayGetSize(pBlock->pDataBlock); ++i) {
     SColumnInfoData* p = taosArrayGet(pBlock->pDataBlock, i);
-    if (p->info.type == TSDB_DATA_TYPE_TIMESTAMP) {
+    if (p->info.type == TSDB_DATA_TYPE_TIMESTAMP) {  // handle timestamp
       colDataAppend(p, rowIndex, (const char*)&ts, false);
     } else {
       colDataAppendNULL(p, rowIndex);
@@ -72,65 +72,75 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock*
   int32_t step = GET_FORWARD_DIRECTION_FACTOR(pFillInfo->order);
 
 //   set the primary timestamp column value
-  int32_t          index = pFillInfo->numOfCurrent;
+  int32_t index = pBlock->info.rows;
-  SColumnInfoData* pCol0 = taosArrayGet(pBlock->pDataBlock, pFillInfo->tsSlotId);
-  char*            val = colDataGetData(pCol0, index);
-
-  // set the primary timestamp value
-  *(TSKEY*)val = pFillInfo->currentKey;
 
   // set the other values
   if (pFillInfo->type == TSDB_FILL_PREV) {
     SArray* p = FILL_IS_ASC_FILL(pFillInfo) ? pFillInfo->prev : pFillInfo->next;
 
-    for (int32_t i = 1; i < pFillInfo->numOfCols; ++i) {
+    for (int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
       SFillColInfo* pCol = &pFillInfo->pFillCol[i];
       if (TSDB_COL_IS_TAG(pCol->flag)) {
         continue;
       }
 
-      SGroupKeys*      pKey = taosArrayGet(p, i);
       SColumnInfoData* pDstColInfoData = taosArrayGet(pBlock->pDataBlock, GET_DEST_SLOT_ID(pCol));
+
+      if (pDstColInfoData->info.type == TSDB_DATA_TYPE_TIMESTAMP) {
+        colDataAppend(pDstColInfoData, index, (const char*)&pFillInfo->currentKey, false);
+      } else {
+        SGroupKeys* pKey = taosArrayGet(p, i);
         doSetVal(pDstColInfoData, index, pKey);
       }
+    }
   } else if (pFillInfo->type == TSDB_FILL_NEXT) {
     SArray* p = FILL_IS_ASC_FILL(pFillInfo) ? pFillInfo->next : pFillInfo->prev;
     // todo  refactor: start from 0 not 1
-    for (int32_t i = 1; i < pFillInfo->numOfCols; ++i) {
+    for (int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
       SFillColInfo* pCol = &pFillInfo->pFillCol[i];
       if (TSDB_COL_IS_TAG(pCol->flag)) {
         continue;
       }
 
-      SGroupKeys*      pKey = taosArrayGet(p, i);
       SColumnInfoData* pDstColInfoData = taosArrayGet(pBlock->pDataBlock, GET_DEST_SLOT_ID(pCol));
+
+      if (pDstColInfoData->info.type == TSDB_DATA_TYPE_TIMESTAMP) {
+        colDataAppend(pDstColInfoData, index, (const char*)&pFillInfo->currentKey, false);
+      } else {
+        SGroupKeys* pKey = taosArrayGet(p, i);
         doSetVal(pDstColInfoData, index, pKey);
       }
+    }
   } else if (pFillInfo->type == TSDB_FILL_LINEAR) {
     // TODO : linear interpolation supports NULL value
     if (outOfBound) {
       setNullRow(pBlock, pFillInfo->currentKey, index);
     } else {
-      for (int32_t i = 1; i < pFillInfo->numOfCols; ++i) {
+      for (int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
         SFillColInfo* pCol = &pFillInfo->pFillCol[i];
         if (TSDB_COL_IS_TAG(pCol->flag)) {
           continue;
         }
 
-        int32_t srcSlotId = GET_SRC_SLOT_ID(pCol);
-
         int32_t          dstSlotId = GET_DEST_SLOT_ID(pCol);
         SColumnInfoData* pDstCol = taosArrayGet(pBlock->pDataBlock, dstSlotId);
 
-        int16_t     type = pCol->pExpr->base.resSchema.type;
+        int16_t type = pDstCol->info.type;
+        if (type == TSDB_DATA_TYPE_TIMESTAMP) {
+          colDataAppend(pDstCol, index, (const char*)&pFillInfo->currentKey, false);
+          continue;
+        }
+
         SGroupKeys* pKey = taosArrayGet(pFillInfo->prev, i);
         if (IS_VAR_DATA_TYPE(type) || type == TSDB_DATA_TYPE_BOOL || pKey->isNull) {
           colDataAppendNULL(pDstCol, index);
           continue;
         }
 
-        SGroupKeys* pKey1 = taosArrayGet(pFillInfo->prev, 0);
+        SGroupKeys* pKey1 = taosArrayGet(pFillInfo->prev, pFillInfo->tsSlotId);
+
         int64_t prevTs = *(int64_t*)pKey1->pData;
+        int32_t srcSlotId = GET_SRC_SLOT_ID(pCol);
 
         SColumnInfoData* pSrcCol = taosArrayGet(pSrcBlock->pDataBlock, srcSlotId);
         char*            data = colDataGetData(pSrcCol, pFillInfo->index);
@@ -148,7 +158,7 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock*
   } else if (pFillInfo->type == TSDB_FILL_NULL) {  // fill with NULL
     setNullRow(pBlock, pFillInfo->currentKey, index);
   } else {  // fill with user specified value for each column
-    for (int32_t i = 1; i < pFillInfo->numOfCols; ++i) {
+    for (int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
       SFillColInfo* pCol = &pFillInfo->pFillCol[i];
       if (TSDB_COL_IS_TAG(pCol->flag) /* || IS_VAR_DATA_TYPE(pCol->schema.type)*/) {
         continue;
@@ -171,6 +181,8 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock*
         colDataAppend(pDst, index, (char*)&v, false);
       } else if (pDst->info.type == TSDB_DATA_TYPE_TIMESTAMP) {
         colDataAppend(pDst, index, (const char*)&pFillInfo->currentKey, false);
+      } else {  // varchar/nchar data
+        colDataAppendNULL(pDst, index);
       }
     }
   }
@@ -179,6 +191,7 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock*
   SInterval* pInterval = &pFillInfo->interval;
   pFillInfo->currentKey =
       taosTimeAdd(pFillInfo->currentKey, pInterval->sliding * step, pInterval->slidingUnit, pInterval->precision);
+  pBlock->info.rows += 1;
   pFillInfo->numOfCurrent++;
 }
 
@@ -229,8 +242,7 @@ static void copyCurrentRowIntoBuf(SFillInfo* pFillInfo, int32_t rowIndex, SArray
 static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t outputRows) {
   pFillInfo->numOfCurrent = 0;
 
-  // todo make sure the first column is always the primary timestamp column?
+  SColumnInfoData* pTsCol = taosArrayGet(pFillInfo->pSrcBlock->pDataBlock, pFillInfo->tsSlotId);
-  SColumnInfoData* pTsCol = taosArrayGet(pFillInfo->pSrcBlock->pDataBlock, 0);
 
   int32_t step = GET_FORWARD_DIRECTION_FACTOR(pFillInfo->order);
   bool    ascFill = FILL_IS_ASC_FILL(pFillInfo);
@@ -262,11 +274,11 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t
       }
     } else {
       assert(pFillInfo->currentKey == ts);
+      int32_t index = pBlock->info.rows;
 
       if (pFillInfo->type == TSDB_FILL_NEXT && (pFillInfo->index + 1) < pFillInfo->numOfRows) {
-        ++pFillInfo->index;
+        int32_t nextRowIndex = pFillInfo->index + 1;
-        copyCurrentRowIntoBuf(pFillInfo, pFillInfo->index, pFillInfo->next);
+        copyCurrentRowIntoBuf(pFillInfo, nextRowIndex, pFillInfo->next);
-        --pFillInfo->index;
       }
 
       // assign rows to dst buffer
@@ -286,24 +298,24 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t
         if (i == 0 || (/*pCol->functionId != FUNCTION_COUNT &&*/ !colDataIsNull_s(pSrc, pFillInfo->index)) /*||
             (pCol->functionId == FUNCTION_COUNT && GET_INT64_VAL(src) != 0)*/) {
           bool isNull = colDataIsNull_s(pSrc, pFillInfo->index);
-          colDataAppend(pDst, pFillInfo->numOfCurrent, src, isNull);
+          colDataAppend(pDst, index, src, isNull);
           saveColData(pFillInfo->prev, i, src, isNull);
         } else {  // i > 0 and data is null , do interpolation
           if (pFillInfo->type == TSDB_FILL_PREV) {
             SGroupKeys* pKey = taosArrayGet(pFillInfo->prev, i);
-            doSetVal(pDst, pFillInfo->numOfCurrent, pKey);
+            doSetVal(pDst, index, pKey);
           } else if (pFillInfo->type == TSDB_FILL_LINEAR) {
             bool isNull = colDataIsNull_s(pSrc, pFillInfo->index);
-            colDataAppend(pDst, pFillInfo->numOfCurrent, src, isNull);
+            colDataAppend(pDst, index, src, isNull);
             saveColData(pFillInfo->prev, i, src, isNull);
           } else if (pFillInfo->type == TSDB_FILL_NULL) {
-            colDataAppendNULL(pDst, pFillInfo->numOfCurrent);
+            colDataAppendNULL(pDst, index);
           } else if (pFillInfo->type == TSDB_FILL_NEXT) {
             SGroupKeys* pKey = taosArrayGet(pFillInfo->next, i);
-            doSetVal(pDst, pFillInfo->numOfCurrent, pKey);
+            doSetVal(pDst, index, pKey);
           } else {
             SVariant* pVar = &pFillInfo->pFillCol[i].fillVal;
-            colDataAppend(pDst, pFillInfo->numOfCurrent, (char*)&pVar->i, false);
+            colDataAppend(pDst, index, (char*)&pVar->i, false);
           }
         }
       }
@@ -314,6 +326,7 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t
       pFillInfo->currentKey =
           taosTimeAdd(pFillInfo->currentKey, pInterval->sliding * step, pInterval->slidingUnit, pInterval->precision);
 
+      pBlock->info.rows += 1;
       pFillInfo->index += 1;
       pFillInfo->numOfCurrent += 1;
     }

source/libs/executor/src/timewindowoperator.c

@@ -1537,7 +1537,6 @@ void destroyStreamFinalIntervalOperatorInfo(void* param, int32_t numOfOutput) {
     for (int32_t i = 0; i < size; i++) {
       SOperatorInfo* pChildOp = taosArrayGetP(pInfo->pChildren, i);
       destroyStreamFinalIntervalOperatorInfo(pChildOp->info, numOfOutput);
-      taosMemoryFreeClear(pChildOp->info);
       taosMemoryFreeClear(pChildOp);
     }
   }

source/libs/function/src/builtins.c

@@ -1886,6 +1886,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .getEnvFunc   = getCountFuncEnv,
     .initFunc     = functionSetup,
     .processFunc  = countFunction,
+    .sprocessFunc = countScalarFunction,
     .finalizeFunc = functionFinalize,
     .invertFunc   = countInvertFunction,
     .combineFunc  = combineFunction,
@@ -1901,6 +1902,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .getEnvFunc   = getSumFuncEnv,
     .initFunc     = functionSetup,
     .processFunc  = sumFunction,
+    .sprocessFunc = sumScalarFunction,
     .finalizeFunc = functionFinalize,
     .invertFunc   = sumInvertFunction,
     .combineFunc  = sumCombine,
@@ -1916,6 +1918,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .getEnvFunc   = getMinmaxFuncEnv,
     .initFunc     = minmaxFunctionSetup,
     .processFunc  = minFunction,
+    .sprocessFunc = minScalarFunction,
     .finalizeFunc = minmaxFunctionFinalize,
     .combineFunc  = minCombine,
     .pPartialFunc = "min",
@@ -1930,6 +1933,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .getEnvFunc   = getMinmaxFuncEnv,
     .initFunc     = minmaxFunctionSetup,
     .processFunc  = maxFunction,
+    .sprocessFunc = maxScalarFunction,
     .finalizeFunc = minmaxFunctionFinalize,
     .combineFunc  = maxCombine,
     .pPartialFunc = "max",
@@ -1943,6 +1947,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .getEnvFunc   = getStddevFuncEnv,
     .initFunc     = stddevFunctionSetup,
     .processFunc  = stddevFunction,
+    .sprocessFunc = stddevScalarFunction,
     .finalizeFunc = stddevFinalize,
     .invertFunc   = stddevInvertFunction,
     .combineFunc  = stddevCombine,

source/libs/function/src/builtinsimpl.c

@@ -3460,9 +3460,16 @@ void doAddIntoResult(SqlFunctionCtx* pCtx, void* pData, int32_t rowIndex, SSData
   }
 }
 
+/*
+ * +------------------------------------+--------------+--------------+
+ * |            null bitmap             |              |              |
+ * |(n columns, one bit for each column)| src column #1| src column #2|
+ * +------------------------------------+--------------+--------------+
+ */
 void saveTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, STuplePos* pPos) {
   SFilePage* pPage = NULL;
 
+  // todo refactor: move away
   int32_t completeRowSize = pCtx->subsidiaries.num * sizeof(bool);
   for (int32_t j = 0; j < pCtx->subsidiaries.num; ++j) {
     SqlFunctionCtx* pc = pCtx->subsidiaries.pCtx[j];
@@ -3475,12 +3482,15 @@ void saveTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pS
   } else {
     pPage = getBufPage(pCtx->pBuf, pCtx->curBufPage);
     if (pPage->num + completeRowSize > getBufPageSize(pCtx->pBuf)) {
+      // current page is all used, let's prepare a new buffer page
+      releaseBufPage(pCtx->pBuf, pPage);
       pPage = getNewBufPage(pCtx->pBuf, 0, &pCtx->curBufPage);
       pPage->num = sizeof(SFilePage);
     }
   }
 
   pPos->pageId = pCtx->curBufPage;
+  pPos->offset = pPage->num;
 
   // keep the current row data, extract method
   int32_t offset = 0;
@@ -3508,7 +3518,6 @@ void saveTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pS
     offset += pCol->info.bytes;
   }
 
-  pPos->offset = pPage->num;
   pPage->num += completeRowSize;
 
   setBufPageDirty(pPage, true);
@@ -4834,7 +4843,7 @@ static void doReservoirSample(SqlFunctionCtx* pCtx, SSampleInfo* pInfo, char* da
   if (pInfo->numSampled < pInfo->samples) {
     sampleAssignResult(pInfo, data, pInfo->numSampled);
     if (pCtx->subsidiaries.num > 0) {
-      saveTupleData(pCtx, index, pCtx->pSrcBlock, pInfo->tuplePos + pInfo->numSampled * sizeof(STuplePos));
+      saveTupleData(pCtx, index, pCtx->pSrcBlock, &pInfo->tuplePos[pInfo->numSampled]);
     }
     pInfo->numSampled++;
   } else {
@@ -4842,7 +4851,7 @@ static void doReservoirSample(SqlFunctionCtx* pCtx, SSampleInfo* pInfo, char* da
     if (j < pInfo->samples) {
       sampleAssignResult(pInfo, data, j);
       if (pCtx->subsidiaries.num > 0) {
-        copyTupleData(pCtx, index, pCtx->pSrcBlock, pInfo->tuplePos + j * sizeof(STuplePos));
+        copyTupleData(pCtx, index, pCtx->pSrcBlock, &pInfo->tuplePos[j]);
       }
     }
   }
@@ -4880,7 +4889,7 @@ int32_t sampleFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
   int32_t currentRow = pBlock->info.rows;
   for (int32_t i = 0; i < pInfo->numSampled; ++i) {
     colDataAppend(pCol, currentRow + i, pInfo->data + i * pInfo->colBytes, false);
-    setSelectivityValue(pCtx, pBlock, pInfo->tuplePos + i * sizeof(STuplePos), currentRow + i);
+    setSelectivityValue(pCtx, pBlock, &pInfo->tuplePos[i], currentRow + i);
   }
 
   return pInfo->numSampled;
@@ -6017,8 +6026,6 @@ int32_t lastrowFunction(SqlFunctionCtx* pCtx) {
       }
 
       pInfo->ts = cts;
-      pResInfo->numOfRes = 1;
-
       if (pCtx->subsidiaries.num > 0) {
         STuplePos* pTuplePos = (STuplePos*)(pInfo->buf + bytes + sizeof(TSKEY));
         if (!pInfo->hasResult) {

source/libs/function/src/udfd.c

@@ -296,8 +296,8 @@ void udfdProcessCallRequest(SUvUdfWork *uvUdf, SUdfRequest *request) {
 
   switch (call->callType) {
     case TSDB_UDF_CALL_SCALA_PROC: {
-      tDeleteSSDataBlock(&call->block);
+      blockDataFreeRes(&call->block);
-      tDeleteSSDataBlock(&subRsp->resultData);
+      blockDataFreeRes(&subRsp->resultData);
       break;
     }
     case TSDB_UDF_CALL_AGG_INIT: {
@@ -305,7 +305,7 @@ void udfdProcessCallRequest(SUvUdfWork *uvUdf, SUdfRequest *request) {
       break;
     }
     case TSDB_UDF_CALL_AGG_PROC: {
-      tDeleteSSDataBlock(&call->block);
+      blockDataFreeRes(&call->block);
       freeUdfInterBuf(&subRsp->resultBuf);
       break;
     }

source/libs/nodes/src/nodesCodeFuncs.c

@@ -225,6 +225,8 @@ const char* nodesNodeName(ENodeType type) {
       return "PhysiBlockDistScan";
     case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN:
       return "PhysiLastRowScan";
+    case QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN:
+      return "PhysiTableMergeScan";
     case QUERY_NODE_PHYSICAL_PLAN_PROJECT:
       return "PhysiProject";
     case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN:

source/libs/parser/src/parInsert.c

@@ -71,6 +71,7 @@ typedef struct SInsertParseContext {
   SVnodeModifOpStmt* pOutput;
   SStmtCallback*     pStmtCb;
   SParseMetaCache*   pMetaCache;
+  char               sTableName[TSDB_TABLE_NAME_LEN];
 } SInsertParseContext;
 
 typedef struct SInsertParseSyntaxCxt {
@@ -734,11 +735,13 @@ static int32_t parseBoundColumns(SInsertParseContext* pCxt, SParsedDataColInfo*
   return TSDB_CODE_SUCCESS;
 }
 
-static void buildCreateTbReq(SVCreateTbReq* pTbReq, const char* tname, STag* pTag, int64_t suid) {
+static void buildCreateTbReq(SVCreateTbReq* pTbReq, const char* tname, STag* pTag, int64_t suid, const char* sname, SArray* tagName) {
   pTbReq->type = TD_CHILD_TABLE;
   pTbReq->name = strdup(tname);
   pTbReq->ctb.suid = suid;
+  if(sname) pTbReq->ctb.name = strdup(sname);
   pTbReq->ctb.pTag = (uint8_t*)pTag;
+  pTbReq->ctb.tagName = taosArrayDup(tagName);
   pTbReq->commentLen = -1;
 
   return;
@@ -758,6 +761,7 @@ static int32_t parseTagToken(char** end, SToken* pToken, SSchema* pSchema, int16
     return TSDB_CODE_SUCCESS;
   }
 
+//  strcpy(val->colName, pSchema->name);
   val->cid = pSchema->colId;
   val->type = pSchema->type;
 
@@ -936,6 +940,7 @@ static int32_t parseTagToken(char** end, SToken* pToken, SSchema* pSchema, int16
 static int32_t parseTagsClause(SInsertParseContext* pCxt, SSchema* pSchema, uint8_t precision, const char* tName) {
   int32_t code = TSDB_CODE_SUCCESS;
   SArray* pTagVals = taosArrayInit(pCxt->tags.numOfBound, sizeof(STagVal));
+  SArray* tagName = taosArrayInit(8, TSDB_COL_NAME_LEN);
   SToken  sToken;
   bool    isParseBindParam = false;
   bool    isJson = false;
@@ -965,6 +970,10 @@ static int32_t parseTagsClause(SInsertParseContext* pCxt, SSchema* pSchema, uint
       taosMemoryFree(tmpTokenBuf);
       goto end;
     }
+
+    if (!isNullStr(&sToken)) {
+      taosArrayPush(tagName, pTagSchema->name);
+    }
     if (pTagSchema->type == TSDB_DATA_TYPE_JSON) {
       if (sToken.n > (TSDB_MAX_JSON_TAG_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE) {
         code = buildSyntaxErrMsg(&pCxt->msg, "json string too long than 4095", sToken.z);
@@ -1004,7 +1013,7 @@ static int32_t parseTagsClause(SInsertParseContext* pCxt, SSchema* pSchema, uint
     goto end;
   }
 
-  buildCreateTbReq(&pCxt->createTblReq, tName, pTag, pCxt->pTableMeta->suid);
+  buildCreateTbReq(&pCxt->createTblReq, tName, pTag, pCxt->pTableMeta->suid, pCxt->sTableName, tagName);
 
 end:
   for (int i = 0; i < taosArrayGetSize(pTagVals); ++i) {
@@ -1014,6 +1023,7 @@ end:
     }
   }
   taosArrayDestroy(pTagVals);
+  taosArrayDestroy(tagName);
   return code;
 }
 
@@ -1089,6 +1099,7 @@ static int32_t parseUsingClause(SInsertParseContext* pCxt, SName* name, char* tb
   createSName(&sname, &sToken, pCxt->pComCxt->acctId, pCxt->pComCxt->db, &pCxt->msg);
   char dbFName[TSDB_DB_FNAME_LEN];
   tNameGetFullDbName(&sname, dbFName);
+  strcpy(pCxt->sTableName, sname.tname);
 
   CHECK_CODE(getSTableMeta(pCxt, &sname, dbFName));
   if (TSDB_SUPER_TABLE != pCxt->pTableMeta->tableType) {
@@ -1332,15 +1343,10 @@ static int32_t parseDataFromFile(SInsertParseContext* pCxt, SToken filePath, STa
   return TSDB_CODE_SUCCESS;
 }
 
-void destroyCreateSubTbReq(SVCreateTbReq* pReq) {
-  taosMemoryFreeClear(pReq->name);
-  taosMemoryFreeClear(pReq->ctb.pTag);
-}
-
 static void destroyInsertParseContextForTable(SInsertParseContext* pCxt) {
   taosMemoryFreeClear(pCxt->pTableMeta);
   destroyBoundColumnInfo(&pCxt->tags);
-  destroyCreateSubTbReq(&pCxt->createTblReq);
+  tdDestroySVCreateTbReq(&pCxt->createTblReq);
 }
 
 static void destroySubTableHashElem(void* p) { taosMemoryFree(*(STableMeta**)p); }
@@ -1486,7 +1492,7 @@ static int32_t parseInsertBody(SInsertParseContext* pCxt) {
     }
     memcpy(tags, &pCxt->tags, sizeof(pCxt->tags));
     (*pCxt->pStmtCb->setInfoFn)(pCxt->pStmtCb->pStmt, pCxt->pTableMeta, tags, tbFName, autoCreateTbl,
-                                pCxt->pVgroupsHashObj, pCxt->pTableBlockHashObj);
+                                pCxt->pVgroupsHashObj, pCxt->pTableBlockHashObj, pCxt->sTableName);
 
     memset(&pCxt->tags, 0, sizeof(pCxt->tags));
     pCxt->pVgroupsHashObj = NULL;
@@ -1515,6 +1521,7 @@ int32_t parseInsertSql(SParseContext* pContext, SQuery** pQuery, SParseMetaCache
       .pSql = (char*)pContext->pSql,
       .msg = {.buf = pContext->pMsg, .len = pContext->msgLen},
       .pTableMeta = NULL,
+      .createTblReq = {0},
       .pSubTableHashObj = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_VARCHAR), true, HASH_NO_LOCK),
       .pTableNameHashObj = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_VARCHAR), true, HASH_NO_LOCK),
       .pDbFNameHashObj = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_VARCHAR), true, HASH_NO_LOCK),
@@ -1795,7 +1802,7 @@ int32_t qBuildStmtOutput(SQuery* pQuery, SHashObj* pVgHash, SHashObj* pBlockHash
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, char* tName, TAOS_MULTI_BIND* bind,
+int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, const char* sTableName, char* tName, TAOS_MULTI_BIND* bind,
                            char* msgBuf, int32_t msgBufLen) {
   STableDataBlocks*   pDataBlock = (STableDataBlocks*)pBlock;
   SMsgBuf             pBuf = {.buf = msgBuf, .len = msgBufLen};
@@ -1809,6 +1816,11 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, char* tN
     return buildInvalidOperationMsg(&pBuf, "out of memory");
   }
 
+  SArray* tagName = taosArrayInit(8, TSDB_COL_NAME_LEN);
+  if (!tagName) {
+    return buildInvalidOperationMsg(&pBuf, "out of memory");
+  }
+
   int32_t  code = TSDB_CODE_SUCCESS;
   SSchema* pSchema = getTableTagSchema(pDataBlock->pTableMeta);
 
@@ -1825,6 +1837,7 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, char* tN
     if (IS_VAR_DATA_TYPE(pTagSchema->type)) {
       colLen = bind[c].length[0];
     }
+    taosArrayPush(tagName, pTagSchema->name);
     if (pTagSchema->type == TSDB_DATA_TYPE_JSON) {
       if (colLen > (TSDB_MAX_JSON_TAG_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE) {
         code = buildSyntaxErrMsg(&pBuf, "json string too long than 4095", bind[c].buffer);
@@ -1841,6 +1854,7 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, char* tN
       }
     } else {
       STagVal val = {.cid = pTagSchema->colId, .type = pTagSchema->type};
+//      strcpy(val.colName, pTagSchema->name);
       if (pTagSchema->type == TSDB_DATA_TYPE_BINARY) {
         val.pData = (uint8_t*)bind[c].buffer;
         val.nData = colLen;
@@ -1877,9 +1891,9 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, char* tN
   }
 
   SVCreateTbReq tbReq = {0};
-  buildCreateTbReq(&tbReq, tName, pTag, suid);
+  buildCreateTbReq(&tbReq, tName, pTag, suid, sTableName, tagName);
   code = buildCreateTbMsg(pDataBlock, &tbReq);
-  destroyCreateSubTbReq(&tbReq);
+  tdDestroySVCreateTbReq(&tbReq);
 
 end:
   for (int i = 0; i < taosArrayGetSize(pTagArray); ++i) {
@@ -1889,6 +1903,7 @@ end:
     }
   }
   taosArrayDestroy(pTagArray);
+  taosArrayDestroy(tagName);
 
   return code;
 }
@@ -2143,7 +2158,7 @@ typedef struct SmlExecHandle {
 static void smlDestroyTableHandle(void* pHandle) {
   SmlExecTableHandle* handle = (SmlExecTableHandle*)pHandle;
   destroyBoundColumnInfo(&handle->tags);
-  destroyCreateSubTbReq(&handle->createTblReq);
+  tdDestroySVCreateTbReq(&handle->createTblReq);
 }
 
 static int32_t smlBoundColumnData(SArray* cols, SParsedDataColInfo* pColList, SSchema* pSchema) {
@@ -2229,18 +2244,24 @@ static int32_t smlBoundColumnData(SArray* cols, SParsedDataColInfo* pColList, SS
  * @param msg
  * @return int32_t
  */
-static int32_t smlBuildTagRow(SArray* cols, SParsedDataColInfo* tags, SSchema* pSchema, STag** ppTag, SMsgBuf* msg) {
+static int32_t smlBuildTagRow(SArray* cols, SParsedDataColInfo* tags, SSchema* pSchema, STag** ppTag, SArray** tagName, SMsgBuf* msg) {
   SArray* pTagArray = taosArrayInit(tags->numOfBound, sizeof(STagVal));
   if (!pTagArray) {
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
+  *tagName = taosArrayInit(8, TSDB_COL_NAME_LEN);
+  if (!*tagName) {
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
 
   int32_t code = TSDB_CODE_SUCCESS;
   for (int i = 0; i < tags->numOfBound; ++i) {
     SSchema* pTagSchema = &pSchema[tags->boundColumns[i]];
     SSmlKv*  kv = taosArrayGetP(cols, i);
 
+    taosArrayPush(*tagName, pTagSchema->name);
     STagVal val = {.cid = pTagSchema->colId, .type = pTagSchema->type};
+//    strcpy(val.colName, pTagSchema->name);
     if (pTagSchema->type == TSDB_DATA_TYPE_BINARY) {
       val.pData = (uint8_t*)kv->value;
       val.nData = kv->length;
@@ -2284,7 +2305,7 @@ end:
 }
 
 int32_t smlBindData(void* handle, SArray* tags, SArray* colsSchema, SArray* cols, bool format, STableMeta* pTableMeta,
-                    char* tableName, char* msgBuf, int16_t msgBufLen) {
+                    char* tableName, const char* sTableName, int32_t sTableNameLen, char* msgBuf, int16_t msgBufLen) {
   SMsgBuf pBuf = {.buf = msgBuf, .len = msgBufLen};
 
   SSmlExecHandle* smlHandle = (SSmlExecHandle*)handle;
@@ -2297,12 +2318,19 @@ int32_t smlBindData(void* handle, SArray* tags, SArray* colsSchema, SArray* cols
     return ret;
   }
   STag* pTag = NULL;
-  ret = smlBuildTagRow(tags, &smlHandle->tableExecHandle.tags, pTagsSchema, &pTag, &pBuf);
+  SArray* tagName = NULL;
+  ret = smlBuildTagRow(tags, &smlHandle->tableExecHandle.tags, pTagsSchema, &pTag, &tagName, &pBuf);
   if (ret != TSDB_CODE_SUCCESS) {
+    taosArrayDestroy(tagName);
     return ret;
   }
 
-  buildCreateTbReq(&smlHandle->tableExecHandle.createTblReq, tableName, pTag, pTableMeta->suid);
+  buildCreateTbReq(&smlHandle->tableExecHandle.createTblReq, tableName, pTag, pTableMeta->suid, NULL, tagName);
+  taosArrayDestroy(tagName);
+
+  smlHandle->tableExecHandle.createTblReq.ctb.name = taosMemoryMalloc(sTableNameLen + 1);
+  memcpy(smlHandle->tableExecHandle.createTblReq.ctb.name, sTableName, sTableNameLen);
+  smlHandle->tableExecHandle.createTblReq.ctb.name[sTableNameLen] = 0;
 
   STableDataBlocks* pDataBlock = NULL;
   ret = getDataBlockFromList(smlHandle->pBlockHash, &pTableMeta->uid, sizeof(pTableMeta->uid),

source/libs/parser/src/parTranslater.c

@@ -3754,6 +3754,9 @@ static int32_t buildCreateStbReq(STranslateContext* pCxt, SCreateTableStmt* pStm
   pReq->delay2 = pStmt->pOptions->maxDelay2;
   pReq->watermark1 = pStmt->pOptions->watermark1;
   pReq->watermark2 = pStmt->pOptions->watermark2;
+  pReq->colVer = 1;
+  pReq->tagVer = 1;
+  pReq->source = TD_REQ_FROM_APP;
   columnDefNodeToField(pStmt->pCols, &pReq->pColumns);
   columnDefNodeToField(pStmt->pTags, &pReq->pTags);
   pReq->numOfColumns = LIST_LENGTH(pStmt->pCols);
@@ -5337,6 +5340,8 @@ static void destroyCreateTbReqBatch(void* data) {
       taosMemoryFreeClear(pTableReq->ntb.schemaRow.pSchema);
     } else if (pTableReq->type == TSDB_CHILD_TABLE) {
       taosMemoryFreeClear(pTableReq->ctb.pTag);
+      taosMemoryFreeClear(pTableReq->ctb.name);
+      taosArrayDestroy(pTableReq->ctb.tagName);
     }
   }
 
@@ -5408,7 +5413,7 @@ static int32_t rewriteCreateTable(STranslateContext* pCxt, SQuery* pQuery) {
 }
 
 static void addCreateTbReqIntoVgroup(int32_t acctId, SHashObj* pVgroupHashmap, SCreateSubTableClause* pStmt,
-                                     const STag* pTag, uint64_t suid, SVgroupInfo* pVgInfo) {
+                                     const STag* pTag, uint64_t suid, const char* sTableNmae, SVgroupInfo* pVgInfo, SArray* tagName) {
 //  char  dbFName[TSDB_DB_FNAME_LEN] = {0};
 //  SName name = {.type = TSDB_DB_NAME_T, .acctId = acctId};
 //  strcpy(name.dbname, pStmt->dbName);
@@ -5425,7 +5430,9 @@ static void addCreateTbReqIntoVgroup(int32_t acctId, SHashObj* pVgroupHashmap, S
     req.commentLen = -1;
   }
   req.ctb.suid = suid;
+  req.ctb.name = strdup(sTableNmae);
   req.ctb.pTag = (uint8_t*)pTag;
+  req.ctb.tagName = taosArrayDup(tagName);
   if (pStmt->ignoreExists) {
     req.flags |= TD_CREATE_IF_NOT_EXISTS;
   }
@@ -5517,6 +5524,7 @@ static int32_t buildNormalTagVal(STranslateContext* pCxt, SSchema* pTagSchema, S
   if (pVal->node.resType.type != TSDB_DATA_TYPE_NULL) {
     void*   nodeVal = nodesGetValueFromNode(pVal);
     STagVal val = {.cid = pTagSchema->colId, .type = pTagSchema->type};
+//    strcpy(val.colName, pTagSchema->name);
     if (IS_VAR_DATA_TYPE(pTagSchema->type)) {
       val.pData = varDataVal(nodeVal);
       val.nData = varDataLen(nodeVal);
@@ -5529,7 +5537,7 @@ static int32_t buildNormalTagVal(STranslateContext* pCxt, SSchema* pTagSchema, S
 }
 
 static int32_t buildKVRowForBindTags(STranslateContext* pCxt, SCreateSubTableClause* pStmt, STableMeta* pSuperTableMeta,
-                                     STag** ppTag) {
+                                     STag** ppTag, SArray* tagName) {
   int32_t numOfTags = getNumOfTags(pSuperTableMeta);
   if (LIST_LENGTH(pStmt->pValsOfTags) != LIST_LENGTH(pStmt->pSpecificTags) ||
       numOfTags < LIST_LENGTH(pStmt->pValsOfTags)) {
@@ -5560,8 +5568,10 @@ static int32_t buildKVRowForBindTags(STranslateContext* pCxt, SCreateSubTableCla
       if (pSchema->type == TSDB_DATA_TYPE_JSON) {
         isJson = true;
         code = buildJsonTagVal(pCxt, pSchema, pVal, pTagArray, ppTag);
+        taosArrayPush(tagName, pCol->colName);
       } else if (pVal->node.resType.type != TSDB_DATA_TYPE_NULL) {
         code = buildNormalTagVal(pCxt, pSchema, pVal, pTagArray);
+        taosArrayPush(tagName, pCol->colName);
       }
     }
     if (TSDB_CODE_SUCCESS == code) {
@@ -5582,7 +5592,7 @@ static int32_t buildKVRowForBindTags(STranslateContext* pCxt, SCreateSubTableCla
 }
 
 static int32_t buildKVRowForAllTags(STranslateContext* pCxt, SCreateSubTableClause* pStmt, STableMeta* pSuperTableMeta,
-                                    STag** ppTag) {
+                                    STag** ppTag, SArray* tagName) {
   if (getNumOfTags(pSuperTableMeta) != LIST_LENGTH(pStmt->pValsOfTags)) {
     return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_TAGS_NOT_MATCHED);
   }
@@ -5607,9 +5617,11 @@ static int32_t buildKVRowForAllTags(STranslateContext* pCxt, SCreateSubTableClau
       if (pTagSchema->type == TSDB_DATA_TYPE_JSON) {
         isJson = true;
         code = buildJsonTagVal(pCxt, pTagSchema, pVal, pTagArray, ppTag);
+        taosArrayPush(tagName, pTagSchema->name);
       } else if (pVal->node.resType.type != TSDB_DATA_TYPE_NULL && !pVal->isNull) {
         char*   tmpVal = nodesGetValueFromNode(pVal);
         STagVal val = {.cid = pTagSchema->colId, .type = pTagSchema->type};
+//        strcpy(val.colName, pTagSchema->name);
         if (IS_VAR_DATA_TYPE(pTagSchema->type)) {
           val.pData = varDataVal(tmpVal);
           val.nData = varDataLen(tmpVal);
@@ -5617,6 +5629,7 @@ static int32_t buildKVRowForAllTags(STranslateContext* pCxt, SCreateSubTableClau
           memcpy(&val.i64, tmpVal, pTagSchema->bytes);
         }
         taosArrayPush(pTagArray, &val);
+        taosArrayPush(tagName, pTagSchema->name);
       }
     }
     if (TSDB_CODE_SUCCESS == code) {
@@ -5652,12 +5665,13 @@ static int32_t rewriteCreateSubTable(STranslateContext* pCxt, SCreateSubTableCla
   }
 
   STag* pTag = NULL;
+  SArray* tagName = taosArrayInit(8, TSDB_COL_NAME_LEN);
 
   if (TSDB_CODE_SUCCESS == code) {
     if (NULL != pStmt->pSpecificTags) {
-      code = buildKVRowForBindTags(pCxt, pStmt, pSuperTableMeta, &pTag);
+      code = buildKVRowForBindTags(pCxt, pStmt, pSuperTableMeta, &pTag, tagName);
     } else {
-      code = buildKVRowForAllTags(pCxt, pStmt, pSuperTableMeta, &pTag);
+      code = buildKVRowForAllTags(pCxt, pStmt, pSuperTableMeta, &pTag, tagName);
     }
   }
 
@@ -5666,9 +5680,10 @@ static int32_t rewriteCreateSubTable(STranslateContext* pCxt, SCreateSubTableCla
     code = getTableHashVgroup(pCxt, pStmt->dbName, pStmt->tableName, &info);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    addCreateTbReqIntoVgroup(pCxt->pParseCxt->acctId, pVgroupHashmap, pStmt, pTag, pSuperTableMeta->uid, &info);
+    addCreateTbReqIntoVgroup(pCxt->pParseCxt->acctId, pVgroupHashmap, pStmt, pTag, pSuperTableMeta->uid, pStmt->useTableName, &info, tagName);
   }
 
+  taosArrayDestroy(tagName);
   taosMemoryFreeClear(pSuperTableMeta);
   return code;
 }
@@ -5883,9 +5898,8 @@ static int32_t buildUpdateTagValReq(STranslateContext* pCxt, SAlterTableStmt* pS
     return pCxt->errCode;
   }
 
-  pReq->isNull = (TSDB_DATA_TYPE_NULL == pStmt->pVal->node.resType.type);
+  pReq->tagType = targetDt.type;
   if (targetDt.type == TSDB_DATA_TYPE_JSON) {
-    pReq->isNull = 0;
     if (pStmt->pVal->literal &&
         strlen(pStmt->pVal->literal) > (TSDB_MAX_JSON_TAG_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE) {
       return buildSyntaxErrMsg(&pCxt->msgBuf, "json string too long than 4095", pStmt->pVal->literal);
@@ -5913,6 +5927,7 @@ static int32_t buildUpdateTagValReq(STranslateContext* pCxt, SAlterTableStmt* pS
     pReq->pTagVal = (uint8_t*)pTag;
     pStmt->pVal->datum.p = (char*)pTag;  // for free
   } else {
+    pReq->isNull = (TSDB_DATA_TYPE_NULL == pStmt->pVal->node.resType.type);
     pReq->nTagVal = pStmt->pVal->node.resType.bytes;
     pReq->pTagVal = nodesGetValueFromNode(pStmt->pVal);
 
@@ -5939,7 +5954,8 @@ static int32_t buildAddColReq(STranslateContext* pCxt, SAlterTableStmt* pStmt, S
 
   pReq->type = pStmt->dataType.type;
   pReq->flags = COL_SMA_ON;
-  pReq->bytes = pStmt->dataType.bytes;
+  // pReq->bytes = pStmt->dataType.bytes;
+  pReq->bytes = calcTypeBytes(pStmt->dataType);
   return TSDB_CODE_SUCCESS;
 }
 
@@ -5966,7 +5982,7 @@ static int32_t buildDropColReq(STranslateContext* pCxt, SAlterTableStmt* pStmt,
 static int32_t buildUpdateColReq(STranslateContext* pCxt, SAlterTableStmt* pStmt, STableMeta* pTableMeta,
                                  SVAlterTbReq* pReq) {
   pReq->colModBytes = calcTypeBytes(pStmt->dataType);
-
+  pReq->colModType = pStmt->dataType.type;
   SSchema* pSchema = getColSchema(pTableMeta, pStmt->colName);
   if (NULL == pSchema) {
     return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_COLUMN, pStmt->colName);

source/libs/parser/src/parUtil.c

@@ -389,6 +389,7 @@ int32_t parseJsontoTagData(const char* json, SArray* pTagVals, STag** ppTag, voi
       continue;
     }
     STagVal val = {0};
+//    strcpy(val.colName, colName);
     val.pKey = jsonKey;
     taosHashPut(keyHash, jsonKey, keyLen, &keyLen,
                 CHAR_BYTES);  // add key to hash to remove dumplicate, value is useless

source/libs/scalar/src/scalar.c

@@ -728,8 +728,9 @@ EDealRes sclRewriteFunction(SNode** pNode, SScalarCtx *ctx) {
   res->translate = true;
 
   if (colDataIsNull_s(output.columnData, 0)) {
-    res->node.resType.type = TSDB_DATA_TYPE_NULL;
+    res->isNull = true;
-    res->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_NULL].bytes;    
+    //res->node.resType.type = TSDB_DATA_TYPE_NULL;
+    //res->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_NULL].bytes;
   } else {
     res->node.resType.type = output.columnData->info.type;
     res->node.resType.bytes = output.columnData->info.bytes;

source/libs/scalar/src/sclfunc.c

@@ -702,6 +702,7 @@ int32_t substrFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOu
   return TSDB_CODE_SUCCESS;
 }
 
+/** Conversion functions **/
 int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
   int16_t inputType  = GET_PARAM_TYPE(&pInput[0]);
   int16_t inputLen   = GET_PARAM_BYTES(&pInput[0]);
@@ -1164,6 +1165,7 @@ int32_t toJsonFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOu
   return TSDB_CODE_SUCCESS;
 }
 
+/** Time functions **/
 int32_t timeTruncateFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
   int32_t type = GET_PARAM_TYPE(&pInput[0]);
 
@@ -1736,3 +1738,296 @@ int32_t qTbnameFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pO
   pOutput->numOfRows += pInput->numOfRows;
   return TSDB_CODE_SUCCESS;
 }
+
+
+/** Aggregation functions **/
+int32_t countScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
+  SColumnInfoData *pInputData  = pInput->columnData;
+  SColumnInfoData *pOutputData = pOutput->columnData;
+
+  int64_t *out = (int64_t *)pOutputData->pData;
+  bool hasNull = false;
+  *out = 0;
+  for (int32_t i = 0; i < pInput->numOfRows; ++i) {
+    if (colDataIsNull_s(pInputData, i)) {
+      hasNull = true;
+      break;
+    }
+    (*out)++;
+  }
+
+  if (hasNull) {
+    colDataAppendNULL(pOutputData, 0);
+  }
+
+  pOutput->numOfRows = 1;
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t sumScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
+  SColumnInfoData *pInputData  = pInput->columnData;
+  SColumnInfoData *pOutputData = pOutput->columnData;
+
+  int32_t type = GET_PARAM_TYPE(pInput);
+  bool hasNull = false;
+  for (int32_t i = 0; i < pInput->numOfRows; ++i) {
+    if (colDataIsNull_s(pInputData, i)) {
+      hasNull = true;
+      break;
+    }
+
+    if (IS_SIGNED_NUMERIC_TYPE(type)) {
+      int64_t *in  = (int64_t *)pInputData->pData;
+      int64_t *out = (int64_t *)pOutputData->pData;
+      *out += in[i];
+    } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
+      uint64_t *in  = (uint64_t *)pInputData->pData;
+      uint64_t *out = (uint64_t *)pOutputData->pData;
+      *out += in[i];
+    } else if (IS_FLOAT_TYPE(type)) {
+      double *in  = (double *)pInputData->pData;
+      double *out = (double *)pOutputData->pData;
+      *out += in[i];
+    }
+  }
+
+  if (hasNull) {
+    colDataAppendNULL(pOutputData, 0);
+  }
+
+  pOutput->numOfRows = 1;
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t doMinMaxScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput, bool isMinFunc) {
+  SColumnInfoData *pInputData  = pInput->columnData;
+  SColumnInfoData *pOutputData = pOutput->columnData;
+
+  int32_t type = GET_PARAM_TYPE(pInput);
+
+  bool hasNull = false;
+  if (isMinFunc) {
+    SET_TYPED_DATA_MAX(pOutputData->pData, type);
+  } else {
+    SET_TYPED_DATA_MIN(pOutputData->pData, type);
+  }
+
+  for (int32_t i = 0; i < pInput->numOfRows; ++i) {
+    if (colDataIsNull_s(pInputData, i)) {
+      hasNull = true;
+      break;
+    }
+
+    switch(type) {
+      case TSDB_DATA_TYPE_BOOL:
+      case TSDB_DATA_TYPE_TINYINT: {
+        int8_t *in  = (int8_t *)pInputData->pData;
+        int8_t *out = (int8_t *)pOutputData->pData;
+        if((in[i] > *out) ^ isMinFunc) {
+          *out = in[i];
+        }
+        break;
+      }
+      case TSDB_DATA_TYPE_SMALLINT: {
+        int16_t *in  = (int16_t *)pInputData->pData;
+        int16_t *out = (int16_t *)pOutputData->pData;
+        if((in[i] > *out) ^ isMinFunc) {
+          *out = in[i];
+        }
+        break;
+      }
+      case TSDB_DATA_TYPE_INT: {
+        int32_t *in  = (int32_t *)pInputData->pData;
+        int32_t *out = (int32_t *)pOutputData->pData;
+        if((in[i] > *out) ^ isMinFunc) {
+          *out = in[i];
+        }
+        break;
+      }
+      case TSDB_DATA_TYPE_BIGINT: {
+        int64_t *in  = (int64_t *)pInputData->pData;
+        int64_t *out = (int64_t *)pOutputData->pData;
+        if((in[i] > *out) ^ isMinFunc) {
+          *out = in[i];
+        }
+        break;
+      }
+      case TSDB_DATA_TYPE_UTINYINT: {
+        uint8_t *in  = (uint8_t *)pInputData->pData;
+        uint8_t *out = (uint8_t *)pOutputData->pData;
+        if((in[i] > *out) ^ isMinFunc) {
+          *out = in[i];
+        }
+        break;
+      }
+      case TSDB_DATA_TYPE_USMALLINT: {
+        uint16_t *in  = (uint16_t *)pInputData->pData;
+        uint16_t *out = (uint16_t *)pOutputData->pData;
+        if((in[i] > *out) ^ isMinFunc) {
+          *out = in[i];
+        }
+        break;
+      }
+      case TSDB_DATA_TYPE_UINT: {
+        uint32_t *in  = (uint32_t *)pInputData->pData;
+        uint32_t *out = (uint32_t *)pOutputData->pData;
+        if((in[i] > *out) ^ isMinFunc) {
+          *out = in[i];
+        }
+        break;
+      }
+      case TSDB_DATA_TYPE_UBIGINT: {
+        uint64_t *in  = (uint64_t *)pInputData->pData;
+        uint64_t *out = (uint64_t *)pOutputData->pData;
+        if((in[i] > *out) ^ isMinFunc) {
+          *out = in[i];
+        }
+        break;
+      }
+      case TSDB_DATA_TYPE_FLOAT: {
+        float *in  = (float *)pInputData->pData;
+        float *out = (float *)pOutputData->pData;
+        if((in[i] > *out) ^ isMinFunc) {
+          *out = in[i];
+        }
+        break;
+      }
+      case TSDB_DATA_TYPE_DOUBLE: {
+        double *in  = (double *)pInputData->pData;
+        double *out = (double *)pOutputData->pData;
+        if((in[i] > *out) ^ isMinFunc) {
+          *out = in[i];
+        }
+        break;
+      }
+    }
+  }
+
+  if (hasNull) {
+    colDataAppendNULL(pOutputData, 0);
+  }
+
+  pOutput->numOfRows = 1;
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t minScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
+  return doMinMaxScalarFunction(pInput, inputNum, pOutput, true);
+}
+
+int32_t maxScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
+  return doMinMaxScalarFunction(pInput, inputNum, pOutput, false);
+}
+
+int32_t stddevScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
+  SColumnInfoData *pInputData  = pInput->columnData;
+  SColumnInfoData *pOutputData = pOutput->columnData;
+
+  int32_t type = GET_PARAM_TYPE(pInput);
+  //int64_t count = 0, sum = 0, qSum = 0;
+  bool hasNull = false;
+
+  for (int32_t i = 0; i < pInput->numOfRows; ++i) {
+    if (colDataIsNull_s(pInputData, i)) {
+      hasNull = true;
+      break;
+    }
+#if 0
+    switch(type) {
+      case TSDB_DATA_TYPE_TINYINT: {
+        int8_t *in  = (int8_t *)pInputData->pData;
+        sum += in[i];
+        qSum += in[i] * in[i];
+        count++;
+        break;
+      }
+      case TSDB_DATA_TYPE_SMALLINT: {
+        int16_t *in  = (int16_t *)pInputData->pData;
+        sum += in[i];
+        qSum += in[i] * in[i];
+        count++;
+        break;
+      }
+      case TSDB_DATA_TYPE_INT: {
+        int32_t *in  = (int32_t *)pInputData->pData;
+        sum += in[i];
+        qSum += in[i] * in[i];
+        count++;
+        break;
+      }
+      case TSDB_DATA_TYPE_BIGINT: {
+        int64_t *in  = (int64_t *)pInputData->pData;
+        sum += in[i];
+        qSum += in[i] * in[i];
+        count++;
+        break;
+      }
+      case TSDB_DATA_TYPE_UTINYINT: {
+        uint8_t *in  = (uint8_t *)pInputData->pData;
+        sum += in[i];
+        qSum += in[i] * in[i];
+        count++;
+        break;
+      }
+      case TSDB_DATA_TYPE_USMALLINT: {
+        uint16_t *in  = (uint16_t *)pInputData->pData;
+        sum += in[i];
+        qSum += in[i] * in[i];
+        count++;
+        break;
+      }
+      case TSDB_DATA_TYPE_UINT: {
+        uint32_t *in  = (uint32_t *)pInputData->pData;
+        sum += in[i];
+        qSum += in[i] * in[i];
+        count++;
+        break;
+      }
+      case TSDB_DATA_TYPE_UBIGINT: {
+        uint64_t *in  = (uint64_t *)pInputData->pData;
+        sum += in[i];
+        qSum += in[i] * in[i];
+        count++;
+        break;
+      }
+      case TSDB_DATA_TYPE_FLOAT: {
+        float *in  = (float *)pInputData->pData;
+        sum += in[i];
+        qSum += in[i] * in[i];
+        count++;
+        break;
+      }
+      case TSDB_DATA_TYPE_DOUBLE: {
+        double *in  = (double *)pInputData->pData;
+        sum += in[i];
+        qSum += in[i] * in[i];
+        count++;
+        break;
+      }
+    }
+#endif
+  }
+
+  double *out  = (double *)pOutputData->pData;
+  if (hasNull) {
+    colDataAppendNULL(pOutputData, 0);
+  } else {
+    *out = 0;
+#if 0
+    double avg = 0;
+    if (IS_SIGNED_NUMERIC_TYPE(type)) {
+      avg = (int64_t)sum / (double)count;
+      *out =  sqrt(fabs((int64_t)qSum / ((double)count) - avg * avg));
+    } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
+      avg = (uint64_t)sum / (double)count;
+      *out =  sqrt(fabs((uint64_t)qSum / ((double)count) - avg * avg));
+    } else if (IS_FLOAT_TYPE(type)) {
+      avg = (double)sum / (double)count;
+      *out =  sqrt(fabs((double)qSum / ((double)count) - avg * avg));
+    }
+#endif
+  }
+
+  pOutput->numOfRows = 1;
+  return TSDB_CODE_SUCCESS;
+}

source/libs/scalar/src/sclvector.c

@@ -1477,7 +1477,8 @@ void vectorAssign(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam *pOut,
 
   pOut->numOfRows = pLeft->numOfRows;
 
-  if (IS_HELPER_NULL(pRight->columnData, 0)) {
+//  if (IS_HELPER_NULL(pRight->columnData, 0)) {
+  if(colDataIsNull_s(pRight->columnData, 0)){
     for (int32_t i = 0; i < pOut->numOfRows; ++i) {
       colDataAppend(pOutputCol, i, NULL, true);
     }

source/libs/stream/src/streamData.c

@@ -116,7 +116,7 @@ void streamFreeQitem(SStreamQueueItem* data) {
     blockDataDestroy(((SStreamTrigger*)data)->pBlock);
     taosFreeQitem(data);
   } else if (type == STREAM_INPUT__DATA_BLOCK || type == STREAM_INPUT__DATA_RETRIEVE) {
-    taosArrayDestroyEx(((SStreamDataBlock*)data)->blocks, (FDelete)tDeleteSSDataBlock);
+    taosArrayDestroyEx(((SStreamDataBlock*)data)->blocks, (FDelete)blockDataFreeRes);
     taosFreeQitem(data);
   } else if (type == STREAM_INPUT__DATA_SUBMIT) {
     streamDataSubmitRefDec((SStreamDataSubmit*)data);

source/libs/stream/src/streamDispatch.c

@@ -313,7 +313,7 @@ int32_t streamDispatch(SStreamTask* pTask, SMsgCb* pMsgCb) {
     atomic_store_8(&pTask->outputStatus, TASK_OUTPUT_STATUS__NORMAL);
     return -1;
   }
-  taosArrayDestroyEx(pBlock->blocks, (FDelete)tDeleteSSDataBlock);
+  taosArrayDestroyEx(pBlock->blocks, (FDelete)blockDataFreeRes);
   taosFreeQitem(pBlock);
 
   tmsgSendReq(pEpSet, &dispatchMsg);

source/libs/stream/src/streamExec.c

@@ -74,7 +74,6 @@ static int32_t streamTaskExecImpl(SStreamTask* pTask, void* data, SArray* pRes)
 }
 
 static SArray* streamExecForQall(SStreamTask* pTask, SArray* pRes) {
-  while (1) {
   int32_t cnt = 0;
   void*   data = NULL;
   while (1) {
@@ -99,17 +98,18 @@ static SArray* streamExecForQall(SStreamTask* pTask, SArray* pRes) {
       }
     }
   }
-    if (data == NULL) break;
-
-    qDebug("stream task %d exec begin, batch msg: %d", pTask->taskId, cnt);
-    streamTaskExecImpl(pTask, data, pRes);
-    qDebug("stream task %d exec end", pTask->taskId);
-
   if (pTask->taskStatus == TASK_STATUS__DROPPING) {
-      taosArrayDestroyEx(pRes, (FDelete)tDeleteSSDataBlock);
+    if (data) streamFreeQitem(data);
+    taosArrayDestroyEx(pRes, (FDelete)blockDataFreeRes);
     return NULL;
   }
 
+  if (data == NULL) return pRes;
+
+  qDebug("stream task %d exec begin, msg batch: %d", pTask->taskId, cnt);
+  streamTaskExecImpl(pTask, data, pRes);
+  qDebug("stream task %d exec end", pTask->taskId);
+
   if (taosArrayGetSize(pRes) != 0) {
     SStreamDataBlock* qRes = taosAllocateQitem(sizeof(SStreamDataBlock), DEF_QITEM);
     if (qRes == NULL) {
@@ -121,7 +121,7 @@ static SArray* streamExecForQall(SStreamTask* pTask, SArray* pRes) {
     qRes->blocks = pRes;
     if (streamTaskOutput(pTask, qRes) < 0) {
       /*streamQueueProcessFail(pTask->inputQueue);*/
-        taosArrayDestroyEx(pRes, (FDelete)tDeleteSSDataBlock);
+      taosArrayDestroyEx(pRes, (FDelete)blockDataFreeRes);
       taosFreeQitem(qRes);
       return NULL;
     }
@@ -130,7 +130,6 @@ static SArray* streamExecForQall(SStreamTask* pTask, SArray* pRes) {
   }
 
   streamFreeQitem(data);
-  }
   return pRes;
 }
 
@@ -155,7 +154,7 @@ int32_t streamExec(SStreamTask* pTask, SMsgCb* pMsgCb) {
       pRes = streamExecForQall(pTask, pRes);
       if (pRes == NULL) goto FAIL;
 
-      taosArrayDestroyEx(pRes, (FDelete)tDeleteSSDataBlock);
+      taosArrayDestroyEx(pRes, (FDelete)blockDataFreeRes);
       atomic_store_8(&pTask->execStatus, TASK_EXEC_STATUS__IDLE);
       qDebug("stream exec, return result");
       return 0;
@@ -163,7 +162,7 @@ int32_t streamExec(SStreamTask* pTask, SMsgCb* pMsgCb) {
       continue;
     } else if (execStatus == TASK_EXEC_STATUS__EXECUTING) {
       ASSERT(taosArrayGetSize(pRes) == 0);
-      taosArrayDestroyEx(pRes, (FDelete)tDeleteSSDataBlock);
+      taosArrayDestroyEx(pRes, (FDelete)blockDataFreeRes);
       return 0;
     } else {
       ASSERT(0);
@@ -171,6 +170,11 @@ int32_t streamExec(SStreamTask* pTask, SMsgCb* pMsgCb) {
   }
 FAIL:
   if (pRes) taosArrayDestroy(pRes);
+  if (pTask->taskStatus == TASK_STATUS__DROPPING) {
+    tFreeSStreamTask(pTask);
+    return 0;
+  } else {
     atomic_store_8(&pTask->execStatus, TASK_EXEC_STATUS__IDLE);
     return -1;
   }
+}

source/libs/stream/src/streamTask.c

@@ -163,6 +163,6 @@ void tFreeSStreamTask(SStreamTask* pTask) {
   streamQueueClose(pTask->inputQueue);
   streamQueueClose(pTask->outputQueue);
   if (pTask->exec.qmsg) taosMemoryFree(pTask->exec.qmsg);
-  qDestroyTask(pTask->exec.executor);
+  if (pTask->exec.executor) qDestroyTask(pTask->exec.executor);
   taosMemoryFree(pTask);
 }

source/libs/stream/src/streamUpdate.c

@@ -17,7 +17,7 @@
 #include "ttime.h"
 
 #define DEFAULT_FALSE_POSITIVE 0.01
-#define DEFAULT_BUCKET_SIZE    1024
+#define DEFAULT_BUCKET_SIZE    131072
 #define ROWS_PER_MILLISECOND   1
 #define MAX_NUM_SCALABLE_BF    100000
 #define MIN_NUM_SCALABLE_BF    10

tests/parallel_test/run_case.sh

@@ -65,6 +65,7 @@ ulimit -c unlimited
 
 $TIMEOUT_CMD $cmd
 RET=$?
+echo "cmd exit code: $RET"
 
 if [ $RET -ne 0 ]; then
     pwd

tests/pytest/util/dnodes.py

@@ -382,7 +382,7 @@ class TDDnode:
 
         if self.valgrind == 0:
             if platform.system().lower() == 'windows':
-                cmd = "mintty -h never -w hide %s -c %s" % (
+                cmd = "mintty -h never %s -c %s" % (
                     binPath, self.cfgDir)
             else:
                 cmd = "nohup %s -c %s > /dev/null 2>&1 & " % (
@@ -391,7 +391,7 @@ class TDDnode:
             valgrindCmdline = "valgrind --log-file=\"%s/../log/valgrind.log\"  --tool=memcheck --leak-check=full --show-reachable=no --track-origins=yes --show-leak-kinds=all -v --workaround-gcc296-bugs=yes"%self.cfgDir
 
             if platform.system().lower() == 'windows':
-                cmd = "mintty -h never -w hide %s %s -c %s" % (
+                cmd = "mintty -h never %s %s -c %s" % (
                     valgrindCmdline, binPath, self.cfgDir)
             else:
                 cmd = "nohup %s %s -c %s 2>&1 & " % (
@@ -518,7 +518,7 @@ class TDDnode:
 
         if self.running != 0:
             if platform.system().lower() == 'windows':
-                os.system("wmic process where \"name='taosd.exe' and CommandLine like '%%dnode%d%%'\" get processId | xargs echo | awk '{print $2}' | xargs taskkill -f -pid"%self.index)
+                psCmd = "for /f %a in ('wmic process where \"name='taosd.exe' and CommandLine like '%%dnode%d%%'\" get processId ^| xargs echo ^| awk ^'{print $2}^'') do @(ps | grep %a | awk '{print $1}' | xargs kill -INT )" % (self.index)
             else:
                 psCmd = "ps -ef|grep -w %s| grep dnode%d|grep -v grep | awk '{print $2}'" % (toBeKilled,self.index)
             processID = subprocess.check_output(

tests/script/general/connection/connection.sim

@@ -1,21 +0,0 @@
-system sh/stop_dnodes.sh
-system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c wallevel -v 0
-system sh/exec.sh -n dnode1 -s start
-sleep 2000
-sql connect
-
-print ============= step1
-sql close
-print close1
-sql connect
-
-print ============= step2
-sql close
-sql connect
-
-print ============= step3
-sql close
-sql connect
-
-system sh/exec.sh -n dnode1 -s stop -x SIGINT

tests/script/general/connection/mqtt.sim

@@ -1,19 +0,0 @@
-system sh/stop_dnodes.sh
-
-system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 2
-system sh/cfg.sh -n dnode1 -c numOfMnodes -v 1
-system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4
-system sh/cfg.sh -n dnode1 -c maxTablesPerVnode -v 100000
-system sh/cfg.sh -n dnode1 -c http -v 1
-system sh/cfg.sh -n dnode1 -c mqtt -v 1
-
-system sh/exec.sh -n dnode1 -s start
-
-sleep 2000
-sql connect
-sql create database mqttdb;
-sql create table mqttdb.devices(ts timestamp, value double) tags(name binary(32), model binary(32), serial binary(16), param binary(16), unit binary(16));
-
-sleep 1000
-system sh/exec.sh -n dnode1 -s stop -x SIGINT

tests/script/general/connection/test_old_data.sim

@@ -1,32 +0,0 @@
-system sh/stop_dnodes.sh
-system sh/mv_old_data.sh
-
-print ============== deploy
-
-system sh/exec.sh -n dnode1 -s start 
-system sh/exec.sh -n dnode2 -s start
-system sh/exec.sh -n dnode3 -s start 
-
-print  =============== step1
-
-sql use test
-sql select * from m1
-
-print $rows points data are retrieved
-if $rows != 7 then 
-  return -1
-endi
-
-print =============== step 2
-
-sql select * from t1
-
-print $rows points data are retrieved
-if $rows != 7 then 
-  return -1
-endi
-
-
-system sh/exec.sh -n dnode1 -s stop  -x SIGINT
-system sh/exec.sh -n dnode2 -s stop  -x SIGINT
-system sh/exec.sh -n dnode3 -s stop  -x SIGINT

tests/script/general/db/alter_option.sim

@@ -1,263 +0,0 @@
-system sh/stop_dnodes.sh
-system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c wallevel -v 0
-system sh/cfg.sh -n dnode1 -c maxTablesPerVnode -v 1000
-
-system sh/exec.sh -n dnode1 -s start
-
-sleep 2000
-sql connect
-
-print ============= create database
-sql create database db cache 2 blocks 4 duration 10 keep 20 minRows 300 maxRows 400 ctime 120 precision 'ms' comp 2 wal 1 replica 1
-sql show databases
-if $data00 != db then 
-  return -1
-endi
-if $data02 != 0 then 
-  return -1
-endi
-if $data03 != 0 then 
-  return -1
-endi
-if $data04 != 1 then 
-  return -1
-endi
-if $data06 != 10 then 
-  return -1
-endi
-if $data07 != 20,20,20 then 
-  return -1
-endi
-if $data08 != 2 then 
-  return -1
-endi
-if $data09 != 4 then 
-  return -1
-endi
-
-print ============== step name
-sql_error alter database db name d1
-sql_error alter database db name d2
-
-print ============== step ntables
-sql_error alter database db ntables -1
-sql_error alter database db ntables 0
-sql_error alter database db ntables 1
-sql_error alter database db ntables 10
-
-print ============== step vgroups
-sql_error alter database db vgroups -1
-sql_error alter database db vgroups 0
-sql_error alter database db vgroups 1
-sql_error alter database db vgroups 10
-
-print ============== step replica
-sql_error alter database db replica 2
-sql_error alter database db replica 3
-sql_error alter database db replica 0
-
-sql alter database db replica 1
-sql show databases
-print replica $data4_db
-if $data4_db != 1 then 
-  return -1
-endi
-
-print ============== step quorum
-sql show databases
-print quorum $data5_db
-if $data5_db != 1 then 
-  return -1
-endi
-
-sql alter database db quorum 1
-sql show databases
-print quorum $data5_db
-if $data5_db != 1 then 
-  return -1
-endi
-
-sql_error alter database db quorum 2
-
-sql_error alter database db quorum 3
-
-sql_error alter database db quorum 0
-sql_error alter database db quorum 4
-sql_error alter database db quorum 5
-sql_error alter database db quorum -1
-
-print ============== step duration
-sql_error alter database db duration 0
-sql_error alter database db duration 1
-sql_error alter database db duration 2
-sql_error alter database db duration 10
-sql_error alter database db duration 50
-sql_error alter database db duration 100
-
-print ============== step keep
-sql show databases
-print keep $data7_db
-if $data7_db != 20,20,20 then 
-  return -1
-endi
-
-sql alter database db keep 20
-sql show databases
-print keep $data7_db
-if $data7_db != 20,20,20 then
-  return -1
-endi
-
-sql alter database db keep 30
-sql show databases
-print keep $data7_db
-if $data7_db != 30,30,30 then
-  return -1
-endi
-
-sql alter database db keep 40
-sql show databases
-print keep $data7_db
-if $data7_db != 40,40,40 then
-  return -1
-endi
-
-sql alter database db keep 40,50
-sql alter database db keep 30,31
-sql alter database db keep 20
-sql_error alter database db keep 10.0
-sql_error alter database db keep 9
-sql_error alter database db keep 1
-sql_error alter database db keep 0
-sql_error alter database db keep -1
-sql_error alter database db keep 365001
-
-print ============== step cache
-sql_error alter database db cache 60
-sql_error alter database db cache 50
-sql_error alter database db cache 20
-sql_error alter database db cache 3
-sql_error alter database db cache 129
-sql_error alter database db cache 300
-sql_error alter database db cache 0
-sql_error alter database db cache -1
-
-print ============== step blocks
-sql show databases
-print blocks $data9_db
-if $data9_db != 4 then 
-  return -1
-endi
-
-sql alter database db blocks 10
-sql show databases
-print blocks $data9_db
-if $data9_db != 10 then 
-  return -1
-endi
-
-sql alter database db blocks 20
-sql show databases
-print blocks $data9_db
-if $data9_db != 20 then 
-  return -1
-endi
-
-sql alter database db blocks 30
-sql show databases
-print blocks $data9_db
-if $data9_db != 30 then 
-  return -1
-endi
-
-sql alter database db blocks 40
-sql alter database db blocks 30
-sql alter database db blocks 20
-sql alter database db blocks 10
-sql_error alter database db blocks 2
-sql_error alter database db blocks 1
-sql_error alter database db blocks 0
-sql_error alter database db blocks -1
-sql_error alter database db blocks 10001
-
-print ============== step minrows
-sql_error alter database db minrows 1
-sql_error alter database db minrows 100
-sql_error alter database db minrows 1000
-
-print ============== step maxrows
-sql_error alter database db maxrows 1
-sql_error alter database db maxrows 100
-sql_error alter database db maxrows 1000
-
-print ============== step wallevel
-sql show databases
-print wallevel $data12_db
-if $data12_db != 1 then 
-  return -1
-endi
-
-sql_error alter database db wal 1
-
-
-sql_error alter database db wal 1
-sql_error alter database db wal 2
-sql_error alter database db wal 1
-sql_error alter database db wal 2
-sql_error alter database db wal 0
-sql_error alter database db wal 3
-sql_error alter database db wal 4
-sql_error alter database db wal -1
-sql_error alter database db wal 1000
-
-print ============== step fsync
-sql_error alter database db fsync 0
-sql_error alter database db fsync 1
-sql_error alter database db fsync 3600
-sql_error alter database db fsync 18000
-sql_error alter database db fsync 180000
-sql_error alter database db fsync 180001
-sql_error alter database db fsync -1
-
-print ============== step comp
-sql show databases
-print comp $data14_db
-if $data14_db != 2 then 
-  return -1
-endi
-
-sql alter database db comp 1
-sql show databases
-print comp $data14_db
-if $data14_db != 1 then 
-  return -1
-endi
-
-sql alter database db comp 2
-sql show databases
-print comp $data14_db
-if $data14_db != 2 then 
-  return -1
-endi
-
-sql alter database db comp 0
-sql show databases
-print comp $data14_db
-if $data14_db != 0 then 
-  return -1
-endi
-
-sql_error alter database db comp 3
-sql_error alter database db comp 4
-sql_error alter database db comp 5
-sql_error alter database db comp -1
-
-
-print ============== step precision
-sql_error alter database db prec 'us'
-
-print ============== step status
-sql_error alter database db status 'delete'
-
-system sh/exec.sh -n dnode1 -s stop -x SIGINT

tests/script/general/db/back_insert.sim

@@ -1,9 +0,0 @@
-sql connect
-$x = 1
-begin:
-  sql reset query cache
-  sleep 1000 
-  sql insert into db.tb values(now, $x ) -x begin  
-  #print ===> insert successed $x 
-  $x = $x + 1   
-goto begin

tests/script/general/insert/testSuite.sim

@@ -1,9 +0,0 @@
-run general/insert/basic.sim
-run general/insert/insert_drop.sim
-run general/insert/query_block1_memory.sim
-run general/insert/query_block2_memory.sim
-run general/insert/query_block1_file.sim
-run general/insert/query_block2_file.sim
-run general/insert/query_file_memory.sim
-run general/insert/query_multi_file.sim
-run general/insert/tcp.sim

tests/script/general/parser/testSuite.sim

@@ -1,68 +0,0 @@
-run general/parser/alter.sim
-run general/parser/alter1.sim
-run general/parser/alter_stable.sim
-run general/parser/auto_create_tb.sim
-run general/parser/auto_create_tb_drop_tb.sim
-run general/parser/col_arithmetic_operation.sim
-run general/parser/columnValue.sim
-run general/parser/commit.sim
-run general/parser/create_db.sim
-run general/parser/create_mt.sim
-run general/parser/create_tb.sim
-run general/parser/dbtbnameValidate.sim
-run general/parser/fill.sim
-run general/parser/fill_stb.sim
-#run general/parser/fill_us.sim               #
-run general/parser/first_last.sim
-run general/parser/import_commit1.sim
-run general/parser/import_commit2.sim
-run general/parser/import_commit3.sim
-run general/parser/import_file.sim
-run general/parser/insert_tb.sim
-run general/parser/tags_dynamically_specifiy.sim
-run general/parser/interp.sim
-run general/parser/lastrow.sim
-run general/parser/limit.sim
-run general/parser/limit1.sim
-run general/parser/limit1_tblocks100.sim
-run general/parser/limit2.sim
-run general/parser/mixed_blocks.sim
-run general/parser/nchar.sim
-run general/parser/null_char.sim
-run general/parser/selectResNum.sim
-run general/parser/select_across_vnodes.sim
-run general/parser/select_from_cache_disk.sim
-run general/parser/set_tag_vals.sim
-run general/parser/single_row_in_tb.sim
-run general/parser/slimit.sim
-run general/parser/slimit1.sim
-run general/parser/slimit_alter_tags.sim
-run general/parser/tbnameIn.sim
-run general/parser/join.sim
-run general/parser/join_multivnode.sim
-run general/parser/join_manyblocks.sim
-run general/parser/projection_limit_offset.sim
-run general/parser/select_with_tags.sim
-run general/parser/select_distinct_tag.sim
-run general/parser/groupby.sim
-run general/parser/tags_filter.sim
-run general/parser/topbot.sim
-run general/parser/union.sim
-run general/parser/constCol.sim
-run general/parser/where.sim
-run general/parser/timestamp.sim
-run general/parser/sliding.sim
-run general/parser/function.sim
-run general/parser/stableOp.sim
-run general/parser/having.sim
-run general/parser/having_child.sim
-run general/parser/slimit_alter_tags.sim
-run general/parser/binary_escapeCharacter.sim
-run general/parser/between_and.sim
-run general/parser/last_cache.sim
-run general/parser/slimit_alter_tags.sim
-run general/parser/udf.sim
-run general/parser/udf_dll.sim
-run general/parser/udf_dll_stable.sim
-run general/parser/nestquery.sim
-run general/parser/precision_ns.sim

tests/script/general/rm_bak/tag/testSuite.sim

@@ -1,25 +0,0 @@
-run general/tag/3.sim
-run general/tag/4.sim
-run general/tag/5.sim
-run general/tag/6.sim
-run general/tag/add.sim
-run general/tag/bigint.sim
-run general/tag/binary_binary.sim
-run general/tag/binary.sim
-run general/tag/bool_binary.sim
-run general/tag/bool_int.sim
-run general/tag/bool.sim
-run general/tag/change.sim
-run general/tag/column.sim
-run general/tag/commit.sim
-run general/tag/create.sim
-run general/tag/delete.sim
-run general/tag/double.sim
-run general/tag/filter.sim
-run general/tag/float.sim
-run general/tag/int_binary.sim
-run general/tag/int_float.sim
-run general/tag/int.sim
-run general/tag/set.sim
-run general/tag/smallint.sim
-run general/tag/tinyint.sim

tests/script/general/table/testSuite.sim

@@ -1,27 +0,0 @@
-run general/table/autocreate.sim
-run general/table/basic1.sim
-run general/table/basic2.sim
-run general/table/basic3.sim
-run general/table/bigint.sim
-run general/table/binary.sim
-run general/table/bool.sim
-run general/table/column_name.sim
-run general/table/column_num.sim
-run general/table/column_value.sim
-run general/table/column2.sim
-run general/table/date.sim
-run general/table/db.table.sim
-run general/table/delete_reuse1.sim
-run general/table/delete_reuse2.sim
-run general/table/delete_writing.sim
-run general/table/describe.sim
-run general/table/double.sim
-run general/table/fill.sim
-run general/table/float.sim
-run general/table/int.sim
-run general/table/limit.sim
-run general/table/smallint.sim
-run general/table/table_len.sim
-run general/table/table.sim
-run general/table/tinyint.sim
-run general/table/vgroup.sim

tests/script/jenkins/basic.txt

@@ -11,17 +11,41 @@
 ./test.sh -f tsim/db/alter_option.sim
 # ./test.sh -f tsim/db/alter_replica_13.sim
 # ./test.sh -f tsim/db/alter_replica_31.sim
+#./test.sh -f tsim/db/alter_tables_d2.sim
+#./test.sh -f tsim/db/alter_tables_v1.sim
+#./test.sh -f tsim/db/alter_tables_v4.sim
+#./test.sh -f tsim/db/alter_vgroups.sim
 ./test.sh -f tsim/db/basic1.sim
 ./test.sh -f tsim/db/basic2.sim
 ./test.sh -f tsim/db/basic3.sim
+#./test.sh -f tsim/db/basic4.sim
+#./test.sh -f tsim/db/basic5.sim
 ./test.sh -f tsim/db/basic6.sim
 ./test.sh -f tsim/db/basic7.sim
 #./test.sh -f tsim/db/commit.sim
 ./test.sh -f tsim/db/create_all_options.sim
 #./test.sh -f tsim/db/delete_part.sim
+#./test.sh -f tsim/db/delete_reuse1.sim
+#./test.sh -f tsim/db/delete_reuse2.sim
+#./test.sh -f tsim/db/delete_reusevnode.sim
+#./test.sh -f tsim/db/delete_reusevnode2.sim
+#./test.sh -f tsim/db/delete_writing1.sim
+#./test.sh -f tsim/db/delete_writing2.sim
 #./test.sh -f tsim/db/delete.sim
+#./test.sh -f tsim/db/delete2.sim
+#./test.sh -f tsim/db/dropvnodes.sim
 ./test.sh -f tsim/db/error1.sim
+#./test.sh -f tsim/db/keep.sim
+#./test.sh -f tsim/db/len.sim
+#./test.sh -f tsim/db/nosuchfile.sim
+#./test.sh -f tsim/db/repeat.sim
+#./test.sh -f tsim/db/show_create_db.sim
+#./test.sh -f tsim/db/show_create_table.sim
+#./test.sh -f tsim/db/tables.sim
 ./test.sh -f tsim/db/taosdlog.sim
+#./test.sh -f tsim/db/topic1.sim
+#./test.sh -f tsim/db/topic2.sim
+#./test.sh -f tsim/db/vnodes.sim
 
 # ---- dnode
 # ./test.sh -f tsim/dnode/balance_replica1.sim
@@ -52,17 +76,132 @@
 ./test.sh -f tsim/import/replica1.sim
 
 # ---- insert
+./test.sh -f tsim/insert/backquote.sim
+./test.sh -f tsim/insert/basic.sim
 ./test.sh -f tsim/insert/basic0.sim
 ./test.sh -f tsim/insert/basic1.sim
-./test.sh -f tsim/insert/backquote.sim
-./test.sh -f tsim/insert/null.sim
-./test.sh -f tsim/insert/update0.sim
 ./test.sh -f tsim/insert/commit-merge0.sim
+./test.sh -f tsim/insert/insert_drop.sim
 ./test.sh -f tsim/insert/insert_select.sim
+./test.sh -f tsim/insert/null.sim
+./test.sh -f tsim/insert/query_block1_file.sim
+./test.sh -f tsim/insert/query_block1_memory.sim
+./test.sh -f tsim/insert/query_block2_file.sim
+./test.sh -f tsim/insert/query_block2_memory.sim
+./test.sh -f tsim/insert/query_file_memory.sim
+./test.sh -f tsim/insert/query_multi_file.sim
+#./test.sh -f tsim/insert/tcp.sim
+./test.sh -f tsim/insert/update0.sim
 
 # ---- parser
-./test.sh -f tsim/parser/groupby-basic.sim
+# ./test.sh -f tsim/parser/alter.sim
+# ./test.sh -f tsim/parser/alter1.sim
+## ./test.sh -f tsim/parser/alter__for_community_version.sim
+## ./test.sh -f tsim/parser/alter_column.sim
+# ./test.sh -f tsim/parser/alter_stable.sim
+# ./test.sh -f tsim/parser/auto_create_tb.sim
+# ./test.sh -f tsim/parser/auto_create_tb_drop_tb.sim
+# ./test.sh -f tsim/parser/between_and.sim
+# ./test.sh -f tsim/parser/binary_escapeCharacter.sim
+# ./test.sh -f tsim/parser/col_arithmetic_operation.sim                                                                                                                            
+## ./test.sh -f tsim/parser/col_arithmetic_query.sim
+## ./test.sh -f tsim/parser/columnValue.sim
+## ./test.sh -f tsim/parser/columnValue_bigint.sim
+## ./test.sh -f tsim/parser/columnValue_bool.sim
+## ./test.sh -f tsim/parser/columnValue_double.sim
+## ./test.sh -f tsim/parser/columnValue_float.sim
+## ./test.sh -f tsim/parser/columnValue_int.sim
+## ./test.sh -f tsim/parser/columnValue_smallint.sim
+## ./test.sh -f tsim/parser/columnValue_tinyint.sim
+## ./test.sh -f tsim/parser/columnValue_unsign.sim
+## ./test.sh -f tsim/parser/commit.sim
+## ./test.sh -f tsim/parser/condition.sim
+## ./test.sh -f tsim/parser/condition_query.sim
+## ./test.sh -f tsim/parser/constCol.sim
+# ./test.sh -f tsim/parser/create_db.sim
+## ./test.sh -f tsim/parser/create_db__for_community_version.sim
+# ./test.sh -f tsim/parser/create_mt.sim
+# ./test.sh -f tsim/parser/create_tb.sim
+## ./test.sh -f tsim/parser/create_tb_with_tag_name.sim
+# ./test.sh -f tsim/parser/dbtbnameValidate.sim
+##./test.sh -f tsim/parser/distinct.sim
+# ./test.sh -f tsim/parser/fill.sim
+# ./test.sh -f tsim/parser/fill_stb.sim
+## ./test.sh -f tsim/parser/fill_us.sim
+# ./test.sh -f tsim/parser/first_last.sim
+## ./test.sh -f tsim/parser/first_last_query.sim
 ./test.sh -f tsim/parser/fourArithmetic-basic.sim
+## ./test.sh -f tsim/parser/function.sim
+./test.sh -f tsim/parser/groupby-basic.sim
+# ./test.sh -f tsim/parser/groupby.sim
+## ./test.sh -f tsim/parser/having.sim
+# ./test.sh -f tsim/parser/having_child.sim
+## ./test.sh -f tsim/parser/import.sim
+# ./test.sh -f tsim/parser/import_commit1.sim
+# ./test.sh -f tsim/parser/import_commit2.sim
+# ./test.sh -f tsim/parser/import_commit3.sim
+## ./test.sh -f tsim/parser/import_file.sim
+## ./test.sh -f tsim/parser/insert_multiTbl.sim
+# ./test.sh -f tsim/parser/insert_tb.sim
+## ./test.sh -f tsim/parser/interp.sim
+## ./test.sh -f tsim/parser/interp_test.sim
+# ./test.sh -f tsim/parser/join.sim
+# ./test.sh -f tsim/parser/join_manyblocks.sim
+## ./test.sh -f tsim/parser/join_multitables.sim
+# ./test.sh -f tsim/parser/join_multivnode.sim
+# ./test.sh -f tsim/parser/last_cache.sim
+## ./test.sh -f tsim/parser/last_cache_query.sim
+## ./test.sh -f tsim/parser/last_groupby.sim
+# ./test.sh -f tsim/parser/lastrow.sim
+## ./test.sh -f tsim/parser/lastrow_query.sim
+## ./test.sh -f tsim/parser/like.sim
+# ./test.sh -f tsim/parser/limit.sim
+# ./test.sh -f tsim/parser/limit1.sim
+## ./test.sh -f tsim/parser/limit1_stb.sim
+## ./test.sh -f tsim/parser/limit1_tb.sim
+# ./test.sh -f tsim/parser/limit1_tblocks100.sim
+## ./test.sh -f tsim/parser/limit2.sim
+## ./test.sh -f tsim/parser/limit2_query.sim
+## ./test.sh -f tsim/parser/limit2_tblocks100.sim
+## ./test.sh -f tsim/parser/limit_stb.sim
+## ./test.sh -f tsim/parser/limit_tb.sim
+## ./test.sh -f tsim/parser/line_insert.sim
+# ./test.sh -f tsim/parser/mixed_blocks.sim
+# ./test.sh -f tsim/parser/nchar.sim
+# ./test.sh -f tsim/parser/nestquery.sim
+# ./test.sh -f tsim/parser/null_char.sim
+## ./test.sh -f tsim/parser/precision_ns.sim
+# ./test.sh -f tsim/parser/projection_limit_offset.sim
+## ./test.sh -f tsim/parser/regex.sim
+# ./test.sh -f tsim/parser/repeatAlter.sim
+# ./test.sh -f tsim/parser/selectResNum.sim
+# ./test.sh -f tsim/parser/select_across_vnodes.sim
+# ./test.sh -f tsim/parser/select_distinct_tag.sim
+# ./test.sh -f tsim/parser/select_from_cache_disk.sim
+# ./test.sh -f tsim/parser/select_with_tags.sim
+# ./test.sh -f tsim/parser/set_tag_vals.sim
+# ./test.sh -f tsim/parser/single_row_in_tb.sim
+## ./test.sh -f tsim/parser/single_row_in_tb_query.sim
+# ./test.sh -f tsim/parser/sliding.sim
+# ./test.sh -f tsim/parser/slimit.sim
+# ./test.sh -f tsim/parser/slimit1.sim
+## ./test.sh -f tsim/parser/slimit1_query.sim
+# ./test.sh -f tsim/parser/slimit_alter_tags.sim
+## ./test.sh -f tsim/parser/slimit_query.sim
+# ./test.sh -f tsim/parser/stableOp.sim
+# ./test.sh -f tsim/parser/tags_dynamically_specifiy.sim
+# ./test.sh -f tsim/parser/tags_filter.sim
+# ./test.sh -f tsim/parser/tbnameIn.sim
+## ./test.sh -f tsim/parser/tbnameIn_query.sim
+# ./test.sh -f tsim/parser/timestamp.sim
+## ./test.sh -f tsim/parser/timestamp_query.sim
+## ./test.sh -f tsim/parser/top_groupby.sim
+# ./test.sh -f tsim/parser/topbot.sim
+# ./test.sh -f tsim/parser/udf.sim
+# ./test.sh -f tsim/parser/udf_dll.sim
+# ./test.sh -f tsim/parser/udf_dll_stable.sim
+# ./test.sh -f tsim/parser/union.sim
+# ./test.sh -f tsim/parser/where.sim
 
 # ---- query
 ./test.sh -f tsim/query/interval.sim
@@ -94,7 +233,33 @@
 ./test.sh -f tsim/show/basic.sim
 
 # ---- table
+./test.sh -f tsim/table/autocreate.sim
 ./test.sh -f tsim/table/basic1.sim
+./test.sh -f tsim/table/basic2.sim
+./test.sh -f tsim/table/basic3.sim
+./test.sh -f tsim/table/bigint.sim
+./test.sh -f tsim/table/binary.sim
+./test.sh -f tsim/table/bool.sim
+./test.sh -f tsim/table/column_name.sim
+./test.sh -f tsim/table/column_num.sim
+./test.sh -f tsim/table/column_value.sim
+./test.sh -f tsim/table/column2.sim
+./test.sh -f tsim/table/createmulti.sim
+./test.sh -f tsim/table/date.sim
+./test.sh -f tsim/table/db.table.sim
+# ./test.sh -f tsim/table/delete_reuse1.sim
+# ./test.sh -f tsim/table/delete_reuse2.sim
+# ./test.sh -f tsim/table/delete_writing.sim
+./test.sh -f tsim/table/describe.sim
+./test.sh -f tsim/table/double.sim
+./test.sh -f tsim/table/float.sim
+./test.sh -f tsim/table/int.sim
+./test.sh -f tsim/table/limit.sim
+./test.sh -f tsim/table/smallint.sim
+./test.sh -f tsim/table/table_len.sim
+./test.sh -f tsim/table/table.sim
+./test.sh -f tsim/table/tinyint.sim
+./test.sh -f tsim/table/vgroup.sim
 
 # ---- stream
 ./test.sh -f tsim/stream/basic0.sim
@@ -114,6 +279,7 @@
 # ./test.sh -f tsim/stream/schedSnode.sim
 ./test.sh -f tsim/stream/windowClose.sim
 ./test.sh -f tsim/stream/ignoreExpiredData.sim
+./test.sh -f tsim/stream/sliding.sim
 
 # ---- transaction
  ./test.sh -f tsim/trans/lossdata1.sim
@@ -160,7 +326,7 @@
 ./test.sh -f tsim/db/basic3.sim -m
 ./test.sh -f tsim/db/error1.sim -m
 ./test.sh -f tsim/insert/backquote.sim -m
-./test.sh -f tsim/parser/fourArithmetic-basic.sim -m
+# ./test.sh -f tsim/parser/fourArithmetic-basic.sim -m
 ./test.sh -f tsim/query/interval-offset.sim -m
 ./test.sh -f tsim/tmq/basic3.sim -m
 ./test.sh -f tsim/stable/vnode3.sim -m
@@ -208,7 +374,7 @@
 # ---- alter
 ./test.sh -f tsim/alter/cached_schema_after_alter.sim
 ./test.sh -f tsim/alter/dnode.sim
-#./test.sh -f tsim/alter/table.sim
+./test.sh -f tsim/alter/table.sim
 
 # ---- cache
 ./test.sh -f tsim/cache/new_metrics.sim
@@ -227,23 +393,23 @@
 ./test.sh -f tsim/compress/uncompress.sim
 
 # ---- compute
-#./test.sh -f tsim/compute/avg.sim
+./test.sh -f tsim/compute/avg.sim
 #./test.sh -f tsim/compute/block_dist.sim
-#./test.sh -f tsim/compute/bottom.sim
+./test.sh -f tsim/compute/bottom.sim
-#./test.sh -f tsim/compute/count.sim
+./test.sh -f tsim/compute/count.sim
-#./test.sh -f tsim/compute/diff.sim
+./test.sh -f tsim/compute/diff.sim
-#./test.sh -f tsim/compute/diff2.sim
+./test.sh -f tsim/compute/diff2.sim
-#./test.sh -f tsim/compute/first.sim
+./test.sh -f tsim/compute/first.sim
-#./test.sh -f tsim/compute/interval.sim
+./test.sh -f tsim/compute/interval.sim
 #./test.sh -f tsim/compute/last_row.sim
-#./test.sh -f tsim/compute/last.sim
+./test.sh -f tsim/compute/last.sim
-#./test.sh -f tsim/compute/leastsquare.sim
+./test.sh -f tsim/compute/leastsquare.sim
-#./test.sh -f tsim/compute/max.sim
+./test.sh -f tsim/compute/max.sim
-#./test.sh -f tsim/compute/min.sim
+./test.sh -f tsim/compute/min.sim
 #./test.sh -f tsim/compute/null.sim
 ./test.sh -f tsim/compute/percentile.sim
 ./test.sh -f tsim/compute/stddev.sim
-#./test.sh -f tsim/compute/sum.sim
+./test.sh -f tsim/compute/sum.sim
 ./test.sh -f tsim/compute/top.sim
 
 # ---- field
@@ -279,4 +445,38 @@
 # ---- wal
 ./test.sh -f tsim/wal/kill.sim
 
+# ---- issue
+#./test.sh -f tsim/issue/TD-2677.sim
+#./test.sh -f tsim/issue/TD-2680.sim
+#./test.sh -f tsim/issue/TD-2713.sim
+#./test.sh -f tsim/issue/TD-3300.sim
+
+# ---- tag
+./test.sh -f tsim/tag/3.sim
+./test.sh -f tsim/tag/4.sim
+./test.sh -f tsim/tag/5.sim
+#./test.sh -f tsim/tag/6.sim
+#./test.sh -f tsim/tag/add.sim
+./test.sh -f tsim/tag/bigint.sim
+./test.sh -f tsim/tag/binary_binary.sim
+./test.sh -f tsim/tag/binary.sim
+./test.sh -f tsim/tag/bool_binary.sim
+./test.sh -f tsim/tag/bool_int.sim
+./test.sh -f tsim/tag/bool.sim
+#./test.sh -f tsim/tag/change.sim
+#./test.sh -f tsim/tag/column.sim
+#./test.sh -f tsim/tag/commit.sim
+#./test.sh -f tsim/tag/create.sim
+#./test.sh -f tsim/tag/delete.sim
+#./test.sh -f tsim/tag/double.sim
+#./test.sh -f tsim/tag/filter.sim
+#./test.sh -f tsim/tag/float.sim
+./test.sh -f tsim/tag/int_binary.sim
+./test.sh -f tsim/tag/int_float.sim
+./test.sh -f tsim/tag/int.sim
+#./test.sh -f tsim/tag/set.sim
+./test.sh -f tsim/tag/smallint.sim
+./test.sh -f tsim/tag/tinyint.sim
+
+
 #======================b1-end===============

tests/script/sh/deploy.sh

@@ -127,8 +127,8 @@ echo "dataDir                $DATA_DIR"          >> $TAOS_CFG
 echo "logDir                 $LOG_DIR"           >> $TAOS_CFG
 echo "debugFlag              0"                  >> $TAOS_CFG
 echo "tmrDebugFlag           131"                >> $TAOS_CFG
-echo "uDebugFlag             131"                >> $TAOS_CFG
+echo "uDebugFlag             143"                >> $TAOS_CFG
-echo "rpcDebugFlag           131"                >> $TAOS_CFG
+echo "rpcDebugFlag           143"                >> $TAOS_CFG
 echo "jniDebugFlag           143"                >> $TAOS_CFG
 echo "qDebugFlag             143"                >> $TAOS_CFG
 echo "cDebugFlag             143"                >> $TAOS_CFG

tests/script/sh/exec.bat

@@ -77,7 +77,10 @@ goto :eof
 :check_offline
 sleep 1
 for /f "tokens=2" %%C in ('wmic process where "name='taosd.exe' and CommandLine like '%%%NODE_NAME%%%'" get processId ^| xargs echo') do (
-  echo check taosd offline
+  for /f "tokens=1" %%D in ('ps ^| grep %%C') do (
+    echo kill -INT %%D
+    echo check taosd offline %NODE_NAME% %%C %%D
     goto :check_offline
   )
+)
 goto :eof

tests/script/test-all.bat

@@ -24,7 +24,7 @@ for /F "usebackq tokens=*" %%i in (!caseFile!) do (
         )
     )
 )
-exit !exitNum!
+exit /b !exitNum!
 
 :colorEcho
 set timeNow=%time%

tests/script/tsim/alter/table.sim

@@ -660,7 +660,7 @@ endi
 print ======= over
 sql drop database d1
 sql show databases
-if $rows != 0 then 
+if $rows != 2 then
   return -1
 endi
 

tests/script/tsim/cache/new_metrics.sim

@@ -83,10 +83,6 @@ while $i < 10
   $i = $i + 1
 endw 
 
-print ==> sleep 1 seconds to renew cache
-sql reset query cache
-sleep 1000
-
 print =============== step5
 sql select * from $tb order by  ts desc
 print ===>rows $rows, data $data01

tests/script/tsim/cache/restart_metrics.sim

@@ -48,9 +48,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/exec.sh -n dnode1 -s start
 
 print =============== step3
-print ==> sleep 1 seconds to renew cache
 sql reset query cache
-sleep 1000
 
 print =============== step4
 sql create database $db

tests/script/tsim/cache/restart_table.sim

@@ -32,9 +32,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/exec.sh -n dnode1 -s start
 
 print =============== step3
-print ==> sleep 1 seconds to renew cache
 sql reset query cache
-sleep 1000
 
 print =============== step4
 sql create database $db

tests/script/tsim/compress/commitlog.sim

@@ -57,15 +57,7 @@ $tb = $tbPrefix . $i
 
 sql create database $db
 sql use $db
-
+sql create table $tb (ts timestamp, b bool, t tinyint, s smallint, i int, big bigint, f float, d double, str binary(256))
-$x = 0
-step3: 
-	$x = $x + 1
-	sleep 1000
-	if $x == 20 then 
-	  return -1
-	endi
-sql create table $tb (ts timestamp, b bool, t tinyint, s smallint, i int, big bigint, f float, d double, str binary(256)) -x step3
 
 $count = 0
 while $count < $N

tests/script/tsim/compute/avg.sim

@@ -38,8 +38,6 @@ while $i < $tbNum
   $i = $i + 1
 endw 
 
-sleep 100
-
 print =============== step2
 $i = 1
 $tb = $tbPrefix . $i
@@ -69,13 +67,13 @@ endi
 print =============== step5
 sql select avg(tbcol) as b from $tb interval(1m)
 print ===> $data01
-if $data11 != 1.000000000 then 
+if $data10 != 1.000000000 then 
   return -1
 endi
 
 sql select avg(tbcol) as b from $tb interval(1d)
 print ===> $data01
-if $data01 != 9.500000000 then 
+if $data00 != 9.500000000 then 
   return -1
 endi
 
@@ -84,7 +82,7 @@ $cc = 4 * 60000
 $ms = 1601481600000 + $cc
 sql select avg(tbcol) as b from $tb where ts <= $ms interval(1m)
 print ===> $data01
-if $data41 != 4.000000000 then 
+if $data40 != 4.000000000 then 
   return -1
 endi
 if $rows != 5 then 
@@ -123,14 +121,14 @@ endi
 
 print =============== step9
 sql select avg(tbcol) as b from $mt interval(1m)
-print ===> $data11
+print ===> $data10
-if $data11 != 1.000000000 then 
+if $data10 != 1.000000000 then 
   return -1
 endi
 
 sql select avg(tbcol) as b from $mt interval(1d)
 print ===> $data01
-if $data01 != 9.500000000 then 
+if $data00 != 9.500000000 then 
   return -1
 endi
 
@@ -148,9 +146,9 @@ endi
 print =============== step11
 $cc = 4 * 60000
 $ms = 1601481600000 + $cc
-sql select avg(tbcol) as b from $mt  where ts <= $ms interval(1m) group by tgcol
+sql select avg(tbcol) as b from $mt  where ts <= $ms partition by tgcol interval(1m)
-print ===> $data11
+print ===> $data10
-if $data11 != 1.000000000 then 
+if $data10 != 1.000000000 then 
   return -1
 endi
 if $rows != 50 then 

tests/script/tsim/compute/block_dist.sim

@@ -47,26 +47,30 @@ while $x < $rowNum
     $x = $x + 1  
 endw
 
-sleep 100
+sql flush database $db
 
 print =============== step2
 $i = 0
 $tb = $tbPrefix . $i
 
-sql select _block_dist() from $tb
+#sql select _block_dist() from $tb
+print show table distributed $tb
+sql show table distributed $tb
 
-if $rows != 1 then
+print $rows
-  print expect 1, actual:$rows
+if $rows == 0 then
   return -1
 endi
 
 print =============== step3
 $i = 0
 $mt = $mtPrefix . $i
-sql select _block_dist() from $mt
+#sql select _block_dist() from $mt
 
-if $rows != 1 then
+print show table distributed $mt
-  print expect 1, actual:$rows
+sql show table distributed $mt
+
+if $rows == 0 then
   return -1
 endi
 
@@ -74,10 +78,11 @@ print =============== step4
 $i = 0
 $nt = $ntPrefix . $i
 
-sql select _block_dist() from $nt
+#sql select _block_dist() from $nt
+print show table distributed $nt
+sql show table distributed $nt
 
-if $rows != 1 then
+if $rows == 0 then
-  print expect 1, actual:$rows
   return -1
 endi
 

tests/script/tsim/compute/bottom.sim

@@ -38,15 +38,13 @@ while $i < $tbNum
   $i = $i + 1
 endw 
 
-sleep 100
-
 print =============== step2
 $i = 1
 $tb = $tbPrefix . $i
 
 sql select bottom(tbcol, 1) from $tb
-print ===> $data01
+print ===> $data00
-if $data01 != 0 then 
+if $data00 != 0 then 
   return -1
 endi
 
@@ -54,25 +52,25 @@ print =============== step3
 $cc = 4 * 60000
 $ms = 1601481600000 + $cc
 sql select bottom(tbcol, 1) from $tb where ts > $ms
-print ===> $data01
+print ===> $data00
-if $data01 != 5 then 
+if $data00 != 5 then 
   return -1
 endi
 
 print =============== step4
 sql select bottom(tbcol, 1) as b from $tb
-print ===> $data01
+print ===> $data00
-if $data01 != 0 then 
+if $data00 != 0 then 
   return -1
 endi
 
 print =============== step5
 sql select bottom(tbcol, 2) as b from $tb 
-print ===> $data01  $data11
+print ===> $data00  $data10
-if $data01 != 0 then 
+if $data00 != 1 then 
   return -1
 endi
-if $data11 != 1 then 
+if $data10 != 0 then 
   return -1
 endi
 
@@ -80,11 +78,11 @@ print =============== step6
 $cc = 4 * 60000
 $ms = 1601481600000 + $cc
 sql select bottom(tbcol, 2) as b from $tb where ts > $ms
-print ===> $data01  $data11
+print ===> $data00  $data10
-if $data01 != 5 then 
+if $data00 != 6 then 
   return -1
 endi
-if $data11 != 6 then 
+if $data10 != 5 then 
   return -1
 endi
 

tests/script/tsim/compute/count.sim

@@ -38,13 +38,10 @@ while $i < $tbNum
   $i = $i + 1
 endw 
 
-sleep 100
-
 print =============== step2
 $i = 1
 $tb = $tbPrefix . $i
 
-
 sql select count(*) from $tb
 print ===> select count(*) from $tb => $data00
 if $data00 != $rowNum then 
@@ -81,14 +78,14 @@ endi
 
 print =============== step5
 sql select count(tbcol) as b from $tb interval(1m)
-print ===> $data01
+print ===> $data00
-if $data01 != 1 then 
+if $data00 != 1 then 
   return -1
 endi
 
 sql select count(tbcol) as b from $tb interval(1d)
-print ===> $data01
+print ===> $data00
-if $data01 != $rowNum then 
+if $data00 != $rowNum then 
   return -1
 endi
 
@@ -96,8 +93,8 @@ print =============== step6
 $cc = 4 * 60000
 $ms = 1601481600000 + $cc
 sql select count(tbcol) as b from $tb where ts <= $ms interval(1m)
-print ===> $data01
+print ===> $data00
-if $data01 != 1 then 
+if $data00 != 1 then 
   return -1
 endi
 if $rows != 5 then 
@@ -149,17 +146,17 @@ endi
 
 print =============== step9
 sql select count(tbcol) as b from $mt interval(1m)
-print ===> $data01
+print ===> $data00
-if $data01 != 10 then 
+if $data00 != 10 then 
   return -1
 endi
-if $data11 != 10 then 
+if $data10 != 10 then 
   return -1
 endi
 
 sql select count(tbcol) as b from $mt interval(1d)
-print ===> $data01
+print ===> $data00
-if $data01 != 200 then 
+if $data00 != 200 then 
   return -1
 endi
 
@@ -177,9 +174,9 @@ endi
 print =============== step11
 $cc = 4 * 60000
 $ms = 1601481600000 + $cc
-sql select count(tbcol) as b from $mt  where ts <= $ms interval(1m) group by tgcol
+sql select count(tbcol) as b from $mt  where ts <= $ms partition by tgcol interval(1m)
 print ===> $data01
-if $data01 != 1 then 
+if $data00 != 1 then 
   return -1
 endi
 if $rows != 50 then 

tests/script/tsim/compute/diff.sim

@@ -37,15 +37,13 @@ while $i < $tbNum
   $i = $i + 1
 endw 
 
-sleep 100
-
 print =============== step2
 $i = 1
 $tb = $tbPrefix . $i
 
 sql select diff(tbcol) from $tb
-print ===> $data11
+print ===> $data10
-if $data11 != 1 then 
+if $data10 != 1 then 
   return -1
 endi
 
@@ -53,23 +51,23 @@ print =============== step3
 $cc = 4 * 60000
 $ms = 1601481600000 + $cc
 sql select diff(tbcol) from $tb where ts > $ms
-print ===> $data11
+print ===> $data10
-if $data11 != 1 then 
+if $data10 != 1 then 
   return -1
 endi
 
 $cc = 4 * 60000
 $ms = 1601481600000 + $cc
 sql select diff(tbcol) from $tb where ts <= $ms
-print ===> $data11
+print ===> $data10
-if $data11 != 1 then 
+if $data10 != 1 then 
   return -1
 endi
 
 print =============== step4
 sql select diff(tbcol) as b from $tb
-print ===> $data11
+print ===> $data10
-if $data11 != 1 then 
+if $data10 != 1 then 
   return -1
 endi
 

tests/script/tsim/compute/diff2.sim

@@ -1,5 +1,6 @@
 system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
+system sh/cfg.sh -n dnode1 -c debugflag -v 131
 system sh/exec.sh -n dnode1 -s start
 sql connect
 
@@ -39,91 +40,90 @@ while $i < $tbNum
   $i = $i + 1
 endw 
 
-sleep 100
-
 print =============== step2
 $i = 1
 $tb = $tbPrefix . $i
 
 sql select diff(c1) from $tb
-print ===> $data11
+print ===> $data10
-if $data11 != 1 then 
+if $data10 != 1 then 
   return -1
 endi
 sql select diff(c2) from $tb
-print ===> $data11
+print ===> $data10
-if $data11 != 1.00000 then
+if $data10 != 1.000000000 then
   return -1
 endi
 sql select diff(c3) from $tb
-print ===> $data11
+print ===> $data10
-if $data11 != 1 then 
+if $data10 != 1 then 
   return -1
 endi
 sql select diff(c4) from $tb
-print ===> $data11
+print ===> $data10
-if $data11 != 1 then 
+if $data10 != 1 then 
   return -1
 endi
 sql select diff(c5) from $tb
-print ===> $data11
+print ===> $data10
-if $data11 != 0 then 
+if $data10 != 0 then 
   return -1
 endi
 sql select diff(c6) from $tb
-print ===> $data11
+print ===> $data10
-if $data11 != 1.000000000 then 
+if $data10 != 1.000000000 then 
   return -1
 endi
-sql_error select diff(c7) from $tb
+
+sql select diff(c7) from $tb
 sql_error select diff(c8) from $tb
 sql_error select diff(c9) from $tb
 sql_error select diff(ts) from $tb
 sql_error select diff(c1), diff(c2) from $tb
-#sql_error select 2+diff(c1) from $tb
+
-sql_error select diff(c1+2) from $tb
+sql select 2+diff(c1) from $tb
+sql select diff(c1+2) from $tb
 sql_error select diff(c1) from $tb where ts > 0 and ts < now + 100m interval(10m)
-sql_error select diff(c1) from $mt
+sql select diff(c1) from $mt
 sql_error select diff(diff(c1)) from $tb
 sql_error select diff(c1) from m_di_tb1 where c2 like '2%'
 
-
 print =============== step3
 sql select diff(c1) from $tb where c1 > 5
-print ===> $data11
+print ===> $data10
-if $data11 != 1 then 
+if $data10 != 1 then 
   return -1
 endi
 sql select diff(c2) from $tb where c2 > 5
-print ===> $data11
+print ===> $data10
-if $data11 != 1.00000 then
+if $data10 != 1.000000000 then
   return -1
 endi
 sql select diff(c3) from $tb where c3 > 5
-print ===> $data11
+print ===> $data10
-if $data11 != 1 then 
+if $data10 != 1 then 
   return -1
 endi
 sql select diff(c4) from $tb where c4 > 5
-print ===> $data11
+print ===> $data10
-if $data11 != 1 then 
+if $data10 != 1 then 
   return -1
 endi
 sql select diff(c5) from $tb where c5 > 5
-print ===> $data11
+print ===> $data10
-if $data11 != 0 then 
+if $data10 != 0 then 
   return -1
 endi
 sql select diff(c6) from $tb where c6 > 5
-print ===> $data11
+print ===> $data10
-if $data11 != 1.000000000 then 
+if $data10 != 1.000000000 then 
   return -1
 endi
 
 print =============== step4
 sql select diff(c1) from $tb where c1 > 5 and c2 < $rowNum
-print ===> $data11
+print ===> $data10
-if $data11 != 1 then 
+if $data10 != 1 then 
   return -1
 endi
 
@@ -131,8 +131,8 @@ sql select diff(c1) from $tb where c9 like '%9' and c1 <= 20
 if $rows != 1 then 
   return -1
 endi
-print ===> $data11
+print ===> $data10
-if $data01 != 10 then 
+if $data00 != 10 then 
   return -1
 endi
 

tests/script/tsim/compute/first.sim

@@ -38,8 +38,6 @@ while $i < $tbNum
   $i = $i + 1
 endw 
 
-sleep 100
-
 print =============== step2
 $i = 1
 $tb = $tbPrefix . $i
@@ -68,14 +66,14 @@ endi
 
 print =============== step5
 sql select first(tbcol) as b from $tb interval(1m)
-print ===> $data01
+print ===> $data00
-if $data01 != 0 then 
+if $data00 != 0 then 
   return -1
 endi
 
 sql select first(tbcol) as b from $tb interval(1d)
-print ===> $data01
+print ===> $data00
-if $data01 != 0 then 
+if $data00 != 0 then 
   return -1
 endi
 
@@ -83,8 +81,8 @@ print =============== step6
 $cc = 4 * 60000
 $ms = 1601481600000 + $cc
 sql select first(tbcol) as b from $tb where ts <= $ms interval(1m)
-print ===> $data01
+print ===> $data00
-if $data41 != 4 then 
+if $data40 != 4 then 
   return -1
 endi
 if $rows != 5 then 
@@ -124,14 +122,14 @@ endi
 print =============== step9
 sql select first(tbcol) as b from $mt interval(1m)
 print select first(tbcol) as b from $mt interval(1m)
-print ===> $data11
+print ===> $data10
-if $data11 != 1 then 
+if $data10 != 1 then 
   return -1
 endi
 
 sql select first(tbcol) as b from $mt interval(1d)
-print ===> $data01
+print ===> $data00
-if $data01 != 0 then 
+if $data00 != 0 then 
   return -1
 endi
 
@@ -149,9 +147,9 @@ endi
 print =============== step11
 $cc = 4 * 60000
 $ms = 1601481600000 + $cc
-sql select first(tbcol) as b from $mt  where ts <= $ms interval(1m) group by tgcol
+sql select first(tbcol) as b from $mt  where ts <= $ms partition by tgcol interval(1m)
-print ===> $data11
+print ===> $data10
-if $data11 != 1 then 
+if $data10 != 1 then 
   return -1
 endi
 print ===> $rows

tests/script/tsim/compute/interval.sim

@@ -47,10 +47,10 @@ print ===> $rows
 if $rows < $rowNum then 
   return -1
 endi
-if $data01 != 1 then 
+if $data00 != 1 then 
   return -1
 endi
-if $data05 != 1 then 
+if $data04 != 1 then 
   return -1
 endi
 
@@ -65,10 +65,10 @@ endi
 if $rows < 3 then 
   return -1
 endi
-if $data01 != 1 then 
+if $data00 != 1 then 
   return -1
 endi
-if $data05 != 1 then 
+if $data04 != 1 then 
   return -1
 endi
 
@@ -87,10 +87,10 @@ endi
 if $rows > 22 then 
   return -1
 endi
-if $data01 != 1 then 
+if $data00 != 1 then 
   return -1
 endi
-if $data05 != 1 then 
+if $data04 != 1 then 
   return -1
 endi
 
@@ -109,10 +109,10 @@ endi
 if $rows > 50 then 
   return -1
 endi
-if $data21 != 1 then 
+if $data20 != 1 then 
   return -1
 endi
-if $data25 != 1 then 
+if $data24 != 1 then 
   return -1
 endi
 
@@ -125,10 +125,10 @@ endi
 if $rows > 22 then 
   return -1
 endi
-if $data11 > 15 then 
+if $data10 > 15 then 
   return -1
 endi
-if $data11 < 5 then 
+if $data10 < 5 then 
   return -1
 endi
 
@@ -143,10 +143,10 @@ endi
 if $rows > 7 then 
   return -1
 endi
-if $data11 > 15 then 
+if $data10 > 15 then 
   return -1
 endi
-if $data11 < 5 then 
+if $data10 < 5 then 
   return -1
 endi
 
@@ -165,10 +165,10 @@ endi
 if $rows > 22 then 
   return -1
 endi
-if $data11 > 15 then 
+if $data10 > 15 then 
   return -1
 endi
-if $data11 < 5 then 
+if $data10 < 5 then 
   return -1
 endi
 
@@ -186,10 +186,10 @@ endi
 if $rows > 50 then 
   return -1
 endi
-if $data11 > 15 then 
+if $data10 > 15 then 
   return -1
 endi
-if $data11 < 5 then 
+if $data10 < 5 then 
   return -1
 endi
 

tests/script/tsim/compute/last.sim

@@ -38,8 +38,6 @@ while $i < $tbNum
   $i = $i + 1
 endw 
 
-sleep 100
-
 print =============== step2
 $i = 1
 $tb = $tbPrefix . $i
@@ -69,14 +67,14 @@ endi
 
 print =============== step5
 sql select last(tbcol) as b from $tb interval(1m)
-print ===> $data11
+print ===> $data10
-if $data11 != 1 then 
+if $data10 != 1 then 
   return -1
 endi
 
 sql select last(tbcol) as b from $tb interval(1d)
-print ===> $data01
+print ===> $data00
-if $data01 != 19 then 
+if $data00 != 19 then 
   return -1
 endi
 
@@ -85,8 +83,8 @@ $cc = 4 * 60000
 $ms = 1601481600000 + $cc
 
 sql select last(tbcol) as b from $tb where ts <= $ms interval(1m)
-print ===> $data11
+print ===> $data10
-if $data11 != 1 then 
+if $data10 != 1 then 
   return -1
 endi
 if $rows != 5 then 
@@ -127,14 +125,14 @@ endi
 
 print =============== step9
 sql select last(tbcol) as b from $mt interval(1m)
-print ===> $data11
+print ===> $data10
-if $data11 != 1 then 
+if $data10 != 1 then 
   return -1
 endi
 
 sql select last(tbcol) as b from $mt interval(1d)
-print ===> $data01
+print ===> $data00
-if $data01 != 19 then 
+if $data00 != 19 then 
   return -1
 endi
 
@@ -153,9 +151,9 @@ print =============== step11
 $cc = 4 * 60000
 $ms = 1601481600000 + $cc
 
-sql select last(tbcol) as b from $mt  where ts <= $ms interval(1m) group by tgcol
+sql select last(tbcol) as b from $mt  where ts <= $ms partition by tgcol interval(1m)
-print ===> $data11
+print ===> $data10
-if $data11 != 1 then 
+if $data10 != 1 then 
   return -1
 endi
 print ===> $rows

tests/script/tsim/compute/last_row.sim

@@ -38,8 +38,6 @@ while $i < $tbNum
   $i = $i + 1
 endw 
 
-sleep 100
-
 print =============== step2
 $i = 1
 $tb = $tbPrefix . $i
@@ -53,6 +51,7 @@ endi
 print =============== step3
 $cc = 4 * 60000
 $ms = 1601481600000 + $cc
+print select last_row(tbcol) from $tb where ts <= $ms
 sql select last_row(tbcol) from $tb where ts <= $ms
 print ===> $data00
 if $data00 != 4 then 
@@ -98,8 +97,6 @@ if $data00 != 4 then
   return -1
 endi
 
-
-
 print =============== step10
 sql select last_row(tbcol) as b from $mt group by tgcol
 print ===> $data00

tests/script/tsim/compute/leastsquare.sim

@@ -37,8 +37,6 @@ while $i < $tbNum
   $i = $i + 1
 endw 
 
-sleep 100
-
 print =============== step2
 $i = 1
 $tb = $tbPrefix . $i
@@ -65,21 +63,21 @@ endi
 
 print =============== step5
 sql select leastsquares(tbcol, 1, 1) as b from $tb interval(1m)
-print ===> $data01 
+print ===> $data00 
-if $data01 != @{slop:1.000000, intercept:1.000000}@ then
+if $data00 != @{slop:1.000000, intercept:1.000000}@ then
   return -1
 endi
 
 sql select leastsquares(tbcol, 1, 1) as b from $tb interval(1d)
-print ===> $data01
+print ===> $data00
-if $data01 != @{slop:1.000000, intercept:1.000000}@ then
+if $data00 != @{slop:1.000000, intercept:1.000000}@ then
   return -1
 endi
 
 print =============== step6
 sql select leastsquares(tbcol, 1, 1) as b from $tb where ts < now + 4m interval(1m)
-print ===> $data01
+print ===> $data00
-if $data01 != @{slop:1.000000, intercept:1.000000}@ then
+if $data00 != @{slop:1.000000, intercept:1.000000}@ then
   return -1
 endi
 print ===> $rows

tests/script/tsim/compute/max.sim

@@ -38,8 +38,6 @@ while $i < $tbNum
   $i = $i + 1
 endw 
 
-sleep 100
-
 print =============== step2
 $i = 1
 $tb = $tbPrefix . $i
@@ -69,14 +67,14 @@ endi
 
 print =============== step5
 sql select max(tbcol) as b from $tb interval(1m)
-print ===> $data11
+print ===> $data10
-if $data11 != 1 then 
+if $data10 != 1 then 
   return -1
 endi
 
 sql select max(tbcol) as b from $tb interval(1d)
-print ===> $data01
+print ===> $data00
-if $data01 != 19 then 
+if $data00 != 19 then 
   return -1
 endi
 
@@ -85,8 +83,8 @@ $cc = 4 * 60000
 $ms = 1601481600000 + $cc
 
 sql select max(tbcol) as b from $tb where ts <= $ms interval(1m)
-print ===> $data11
+print ===> $data10
-if $data11 != 1 then 
+if $data10 != 1 then 
   return -1
 endi
 if $rows != 5 then 
@@ -127,14 +125,14 @@ endi
 
 print =============== step9
 sql select max(tbcol) as b from $mt interval(1m)
-print ===> $data11
+print ===> $data10
-if $data11 != 1 then 
+if $data10 != 1 then 
   return -1
 endi
 
 sql select max(tbcol) as b from $mt interval(1d)
-print ===> $data01
+print ===> $data00
-if $data01 != 19 then 
+if $data00 != 19 then 
   return -1
 endi
 
@@ -153,9 +151,9 @@ print =============== step11
 $cc = 4 * 60000
 $ms = 1601481600000 + $cc
 
-sql select max(tbcol) as b from $mt  where ts <= $ms interval(1m) group by tgcol
+sql select max(tbcol) as b from $mt  where ts <= $ms partition by tgcol interval(1m)
-print ===> $data11
+print ===> $data10
-if $data11 != 1 then 
+if $data10 != 1 then 
   return -1
 endi
 print ===> $rows

tests/script/tsim/compute/min.sim

@@ -38,8 +38,6 @@ while $i < $tbNum
   $i = $i + 1
 endw 
 
-sleep 100
-
 print =============== step2
 $i = 1
 $tb = $tbPrefix . $i

tests/script/tsim/compute/null.sim

@@ -100,9 +100,10 @@ if $rows != 1 then
   return -1
 endi
 
-sql_error select * from $tb  where tbcol = NULL 
+sql select * from $tb  where tbcol = NULL 
-
+if $rows != 0 then 
-return
+  return -1
+endi
 
 print =============== step5
 sql create table tt using $mt tags( NULL )

tests/script/tsim/compute/percentile.sim

@@ -38,8 +38,6 @@ while $i < $tbNum
   $i = $i + 1
 endw 
 
-sleep 100
-
 print =============== step2
 $i = 1
 $tb = $tbPrefix . $i

tests/script/tsim/compute/stddev.sim

@@ -38,8 +38,6 @@ while $i < $tbNum
   $i = $i + 1
 endw 
 
-sleep 100
-
 print =============== step2
 $i = 1
 $tb = $tbPrefix . $i

tests/script/tsim/compute/sum.sim

@@ -38,8 +38,6 @@ while $i < $tbNum
   $i = $i + 1
 endw 
 
-sleep 100
-
 print =============== step2
 $i = 1
 $tb = $tbPrefix . $i

tests/script/tsim/compute/top.sim

@@ -38,8 +38,6 @@ while $i < $tbNum
   $i = $i + 1
 endw 
 
-sleep 100
-
 print =============== step2
 $i = 1
 $tb = $tbPrefix . $i

tests/script/tsim/db/alter_option.sim

@@ -6,63 +6,35 @@ system sh/exec.sh -n dnode1 -s start
 system sh/exec.sh -n dnode2 -s start
 system sh/exec.sh -n dnode3 -s start
 
-$loop_cnt = 0
-check_dnode_ready:
-	$loop_cnt = $loop_cnt + 1
-	sleep 200
-	if $loop_cnt == 10 then
-	  print ====> dnode not ready!
-		return -1
-	endi
-sql show dnodes
-print ===> $rows $data00 $data01 $data02 $data03 $data04 $data05
-if $data00 != 1 then
-  return -1
-endi
-if $data04 != ready then
-  goto check_dnode_ready
-endi
-
 sql connect
 sql create dnode $hostname port 7200
 sql create dnode $hostname port 7300
 
-$loop_cnt = 0
+$x = 0
-check_dnode_ready_1:
+step1:
-	$loop_cnt = $loop_cnt + 1
+	$x = $x + 1
-	sleep 200
+	sleep 1000
-	if $loop_cnt == 10 then
+	if $x == 10 then
 	  print ====> dnode not ready!
 		return -1
 	endi
 sql show dnodes
-print ===> rows: $rows 
 print ===> $data00 $data01 $data02 $data03 $data04 $data05
 print ===> $data10 $data11 $data12 $data13 $data14 $data15
 print ===> $data20 $data21 $data22 $data23 $data24 $data25
-if $data00 != 1 then
+if $rows != 3 then
   return -1
 endi
-system_content printf %OS%
+if $data(1)[4] != ready then
-if $system_content == Windows_NT then
+  goto step1
-  system_content printf %COMPUTERNAME%:7100
-  if $data01 != $system_content then
-    return -1
 endi
-else
+if $data(2)[4] != ready then
-  if $data01 != localhost:7100 then
+  goto step1
-    return -1
 endi
+if $data(3)[4] != ready then
+  goto step1
 endi
-if $data04 != ready then
+
-  goto check_dnode_ready_1
-endi
-if $data14 != ready then
-  goto check_dnode_ready_1
-endi
-if $data24 != ready then
-  goto check_dnode_ready_1
-endi
 
 print ============= create database
 #database_option: {
@@ -137,7 +109,6 @@ if $data17_db != ns then  # precision
   return -1
 endi
 
-sleep 3000
 #sql show db.vgroups
 #if $data[0][4] == leader then
 #  if $data[0][6] != follower then

tests/script/tsim/db/back_insert.sim

@@ -1,6 +1,8 @@
 sql connect
 $x = 1
 begin:
+  sql reset query cache
+  sleep 1000 
   sql insert into db.tb values(now, $x ) -x begin  
   #print ===> insert successed $x 
   $x = $x + 1