Merge branch '3.0' of https://github.com/taosdata/TDengine into feat/tsdb_snapshot

cmake/cmake.options

@@ -83,12 +83,6 @@ option(
     OFF
     )
 
-option(
-    TDENGINE_3
-    "TDengine 3.x"
-    ON
-    )
-
 option(
     BUILD_ADDR2LINE
     "If build addr2line"

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/nodes/plannodes.h

@@ -275,7 +275,12 @@ typedef struct SScanPhysiNode {
 
 typedef SScanPhysiNode STagScanPhysiNode;
 typedef SScanPhysiNode SBlockDistScanPhysiNode;
-typedef SScanPhysiNode SLastRowScanPhysiNode;
+
+typedef struct SLastRowScanPhysiNode {
+  SScanPhysiNode scan;
+  SNodeList*     pGroupTags;
+  bool           groupSort;
+} SLastRowScanPhysiNode;
 
 typedef struct SSystemTableScanPhysiNode {
   SScanPhysiNode scan;

include/libs/scalar/scalar.h

@@ -96,6 +96,12 @@ 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);
+
 #ifdef __cplusplus
 }
 #endif

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;
 }

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/mndStream.c

@@ -235,7 +235,8 @@ static int32_t mndStreamGetPlanString(const char *ast, int8_t triggerType, int64
 }
 
 static int32_t mndBuildStreamObjFromCreateReq(SMnode *pMnode, SStreamObj *pObj, SCMCreateStreamReq *pCreate) {
-  SNode *pAst = NULL;
+  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/mnode/sdb/inc/sdb.h

@@ -163,7 +163,6 @@ typedef struct SSdbRow {
   ESdbType   type;
   ESdbStatus status;
   int32_t    refCount;
-  int64_t    forAlign;
   char       pObj[];
 } SSdbRow;
 

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
@@ -382,4 +383,4 @@ int32_t tdCheckAndInitSmaEnv(SSma *pSma, int8_t smaType) {
   tdUnLockSma(pSma);
 
   return TSDB_CODE_SUCCESS;
-};
+};

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;
 }
 
@@ -404,7 +392,7 @@ int32_t tdProcessRSmaCreate(SSma *pSma, SVCreateStbReq *pReq) {
  * @param pReq
  * @return int32_t
  */
-int32_t tdProcessRSmaDrop(SSma *pSma,  SVDropStbReq *pReq) { 
+int32_t tdProcessRSmaDrop(SSma *pSma, SVDropStbReq *pReq) {
   SVnode *pVnode = pSma->pVnode;
   if (!VND_IS_RSMA(pVnode)) {
     smaTrace("vgId:%d, not create rsma for stable %s %" PRIi64 " since vnd is not rsma", TD_VID(pVnode), pReq->name,
@@ -412,11 +400,9 @@ 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;
- }
+}
 
 /**
  * @brief store suid/[uids], prefer to use array and then hash

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);
@@ -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) {
+    streamProcessRunReq(pTask);
     return 0;
+  } else {
+    return -1;
   }
-  streamProcessRunReq(pTask);
-  return 0;
 }
 
 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) {
+    SRpcMsg rsp = {
+        .info = pMsg->info,
+        .code = 0,
+    };
+    streamProcessDispatchReq(pTask, &req, &rsp);
     return 0;
+  } else {
+    return -1;
   }
-  SRpcMsg rsp = {
-      .info = pMsg->info,
-      .code = 0,
-  };
-  streamProcessDispatchReq(pTask, &req, &rsp);
-  return 0;
 }
 
 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) {
+    streamProcessRecoverReq(pTask, pReq, pMsg);
     return 0;
+  } else {
+    return -1;
   }
-  streamProcessRecoverReq(pTask, pReq, pMsg);
-  return 0;
 }
 
 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) {
+    streamProcessDispatchRsp(pTask, pRsp);
     return 0;
+  } else {
+    return -1;
   }
-  streamProcessDispatchRsp(pTask, pRsp);
-  return 0;
 }
 
 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) {
+    streamProcessRecoverRsp(pTask, pRsp);
     return 0;
+  } else {
+    return -1;
   }
-  streamProcessRecoverRsp(pTask, pRsp);
-  return 0;
 }
 
 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));
-  atomic_store_8(&pTask->taskStatus, TASK_STATUS__DROPPING);
+  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);
 }
 

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

@@ -147,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/libs/command/src/explain.c

@@ -206,7 +206,7 @@ int32_t qExplainGenerateResChildren(SPhysiNode *pNode, SExplainGroup *group, SNo
     }
     case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN: {
       SLastRowScanPhysiNode *lastRowPhysiNode = (SLastRowScanPhysiNode *)pNode;
-      pPhysiChildren = lastRowPhysiNode->node.pChildren;
+      pPhysiChildren = lastRowPhysiNode->scan.node.pChildren;
       break;
     }
     case QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT: {
@@ -1209,19 +1209,19 @@ int32_t qExplainResNodeToRowsImpl(SExplainResNode *pResNode, SExplainCtx *ctx, i
     }
     case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN: {
       SLastRowScanPhysiNode *pLastRowNode = (SLastRowScanPhysiNode *)pNode;
-      EXPLAIN_ROW_NEW(level, EXPLAIN_LASTROW_SCAN_FORMAT, pLastRowNode->tableName.tname);
+      EXPLAIN_ROW_NEW(level, EXPLAIN_LASTROW_SCAN_FORMAT, pLastRowNode->scan.tableName.tname);
       EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);
       if (pResNode->pExecInfo) {
         QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));
         EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
       }
-      EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT, pLastRowNode->pScanCols->length);
+      EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT, pLastRowNode->scan.pScanCols->length);
       EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
-      if (pLastRowNode->pScanPseudoCols) {
+      if (pLastRowNode->scan.pScanPseudoCols) {
-        EXPLAIN_ROW_APPEND(EXPLAIN_PSEUDO_COLUMNS_FORMAT, pLastRowNode->pScanPseudoCols->length);
+        EXPLAIN_ROW_APPEND(EXPLAIN_PSEUDO_COLUMNS_FORMAT, pLastRowNode->scan.pScanPseudoCols->length);
         EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
       }
-      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pLastRowNode->node.pOutputDataBlockDesc->totalRowSize);
+      EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pLastRowNode->scan.node.pOutputDataBlockDesc->totalRowSize);
       EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
       EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);
       EXPLAIN_ROW_END();
@@ -1230,15 +1230,15 @@ int32_t qExplainResNodeToRowsImpl(SExplainResNode *pResNode, SExplainCtx *ctx, i
       if (verbose) {
         EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);
         EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,
-                           nodesGetOutputNumFromSlotList(pLastRowNode->node.pOutputDataBlockDesc->pSlots));
+                           nodesGetOutputNumFromSlotList(pLastRowNode->scan.node.pOutputDataBlockDesc->pSlots));
         EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
-        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pLastRowNode->node.pOutputDataBlockDesc->outputRowSize);
+        EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pLastRowNode->scan.node.pOutputDataBlockDesc->outputRowSize);
         EXPLAIN_ROW_END();
         QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));
 
-        if (pLastRowNode->node.pConditions) {
+        if (pLastRowNode->scan.node.pConditions) {
           EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);
-          QRY_ERR_RET(nodesNodeToSQL(pLastRowNode->node.pConditions, tbuf + VARSTR_HEADER_SIZE,
+          QRY_ERR_RET(nodesNodeToSQL(pLastRowNode->scan.node.pConditions, tbuf + VARSTR_HEADER_SIZE,
                                      TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen));
           EXPLAIN_ROW_END();
           QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

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/cachescanoperator.c

@@ -40,10 +40,10 @@ SOperatorInfo* createLastrowScanOperator(SLastRowScanPhysiNode* pScanNode, SRead
 
   pInfo->pTableList = pTableList;
   pInfo->readHandle = *readHandle;
-  pInfo->pRes = createResDataBlock(pScanNode->node.pOutputDataBlockDesc);
+  pInfo->pRes = createResDataBlock(pScanNode->scan.node.pOutputDataBlockDesc);
 
   int32_t numOfCols = 0;
-  pInfo->pColMatchInfo = extractColMatchInfo(pScanNode->pScanCols, pScanNode->node.pOutputDataBlockDesc, &numOfCols,
+  pInfo->pColMatchInfo = extractColMatchInfo(pScanNode->scan.pScanCols, pScanNode->scan.node.pOutputDataBlockDesc, &numOfCols,
                                              COL_MATCH_FROM_COL_ID);
   int32_t code = extractTargetSlotId(pInfo->pColMatchInfo, pTaskInfo, &pInfo->pSlotIds);
   if (code != TSDB_CODE_SUCCESS) {
@@ -53,10 +53,10 @@ SOperatorInfo* createLastrowScanOperator(SLastRowScanPhysiNode* pScanNode, SRead
   tsdbLastRowReaderOpen(readHandle->vnode, LASTROW_RETRIEVE_TYPE_SINGLE, pTableList, taosArrayGetSize(pInfo->pColMatchInfo),
                         &pInfo->pLastrowReader);
 
-  if (pScanNode->pScanPseudoCols != NULL) {
+  if (pScanNode->scan.pScanPseudoCols != NULL) {
     SExprSupp* pPseudoExpr = &pInfo->pseudoExprSup;
 
-    pPseudoExpr->pExprInfo = createExprInfo(pScanNode->pScanPseudoCols, NULL, &pPseudoExpr->numOfExprs);
+    pPseudoExpr->pExprInfo = createExprInfo(pScanNode->scan.pScanPseudoCols, NULL, &pPseudoExpr->numOfExprs);
     pPseudoExpr->pCtx = createSqlFunctionCtx(pPseudoExpr->pExprInfo, pPseudoExpr->numOfExprs, &pPseudoExpr->rowEntryInfoOffset);
   }
 

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,31 +3380,29 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) {
   SOperatorInfo* pDownstream = pOperator->pDownstream[0];
   while (1) {
     SSDataBlock* pBlock = pDownstream->fpSet.getNextFn(pDownstream);
-    if (*newgroup) {
+    if (pBlock == NULL) {
-      assert(pBlock != NULL);
+      if (pInfo->totalInputRows == 0) {
-    }
+        pOperator->status = OP_EXEC_DONE;
+        return 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) {
+      blockDataUpdateTsWindow(pBlock, pInfo->primaryTsCol);
-        if (pInfo->totalInputRows == 0) {
+
-          pOperator->status = OP_EXEC_DONE;
+      if (pInfo->curGroupId == 0 || pInfo->curGroupId == pBlock->info.groupId) {
-          return NULL;
+        pInfo->curGroupId = pBlock->info.groupId;   // the first data block
-        }
 
-        taosFillSetStartInfo(pInfo->pFillInfo, 0, pInfo->win.ekey);
-      } else {
         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;
       }
@@ -4444,21 +4438,21 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
       //        return NULL;
       //      }
 
-      int32_t code = extractTableSchemaInfo(pHandle, pScanNode->uid, pTaskInfo);
+      int32_t code = extractTableSchemaInfo(pHandle, pScanNode->scan.uid, pTaskInfo);
       if (code != TSDB_CODE_SUCCESS) {
         pTaskInfo->code = code;
         return NULL;
       }
 
       pTableListInfo->pTableList = taosArrayInit(4, sizeof(STableKeyInfo));
-      if (pScanNode->tableType == TSDB_SUPER_TABLE) {
+      if (pScanNode->scan.tableType == TSDB_SUPER_TABLE) {
-        code = vnodeGetAllTableList(pHandle->vnode, pScanNode->uid, pTableListInfo->pTableList);
+        code = vnodeGetAllTableList(pHandle->vnode, pScanNode->scan.uid, pTableListInfo->pTableList);
         if (code != TSDB_CODE_SUCCESS) {
           pTaskInfo->code = terrno;
           return NULL;
         }
       } else {  // Create one table group.
-        STableKeyInfo info = {.lastKey = 0, .uid = pScanNode->uid, .groupId = 0};
+        STableKeyInfo info = {.lastKey = 0, .uid = pScanNode->scan.uid, .groupId = 0};
         taosArrayPush(pTableListInfo->pTableList, &info);
       }
 

source/libs/executor/src/scanoperator.c

@@ -39,7 +39,7 @@ static int32_t buildSysDbTableInfo(const SSysTableScanInfo* pInfo, int32_t capac
 static int32_t buildDbTableInfoBlock(const SSDataBlock* p, const SSysTableMeta* pSysDbTableMeta, size_t size,
                                      const char* dbName);
 
-static bool    processBlockWithProbability(const SSampleExecInfo* pInfo);
+static bool processBlockWithProbability(const SSampleExecInfo* pInfo);
 
 bool processBlockWithProbability(const SSampleExecInfo* pInfo) {
 #if 0
@@ -874,22 +874,22 @@ 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,
-  SResultRowInfo   dumyInfo;
+                                    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);
     } while (tsCol[(*pRowIndex) - 1] >= endWin.skey);
     endWin = preWin;
-    if (win.ekey == endWin.ekey || (*pRowIndex) == pDataBlockInfo->rows ) {
+    if (win.ekey == endWin.ekey || (*pRowIndex) == pDataBlockInfo->rows) {
       win.ekey = endWin.ekey;
       return win;
     }
@@ -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,10 +1178,9 @@ 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);
+        //        taosArraySet(pInfo->pRes->pDataBlock, pColMatchInfo->targetSlotId, pResCol);
         colExists = true;
         break;
       }
@@ -1200,14 +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);
+      blockDataFreeRes((SSDataBlock*)pBlock);
       longjmp(pTaskInfo->env, code);
     }
   }
 
   doFilter(pInfo->pCondition, pInfo->pRes);
   blockDataUpdateTsWindow(pInfo->pRes, pInfo->primaryTsIndex);
-  blockDataFreeRes((SSDataBlock*) pBlock);
+  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;
 

source/libs/executor/src/tfill.c

@@ -72,7 +72,7 @@ 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;
 
   // set the other values
   if (pFillInfo->type == TSDB_FILL_PREV) {
@@ -191,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++;
 }
 
@@ -273,6 +274,7 @@ 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) {
         int32_t nextRowIndex = pFillInfo->index + 1;
@@ -296,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);
           }
         }
       }
@@ -324,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

@@ -1340,13 +1340,13 @@ static int32_t closeIntervalWindow(SHashObj* pHashMap, STimeWindowAggSupp* pSup,
     void*    key = taosHashGetKey(pIte, &keyLen);
     uint64_t groupId = *(uint64_t*)key;
     ASSERT(keyLen == GET_RES_WINDOW_KEY_LEN(sizeof(TSKEY)));
-    TSKEY          ts = *(int64_t*)((char*)key + sizeof(uint64_t));
+    TSKEY       ts = *(int64_t*)((char*)key + sizeof(uint64_t));
     STimeWindow win;
     win.skey = ts;
     win.ekey = taosTimeAdd(win.skey, pInterval->interval, pInterval->intervalUnit, pInterval->precision) - 1;
-    SWinRes     winRe = {
+    SWinRes winRe = {
-            .ts = win.skey,
+        .ts = win.skey,
-            .groupId = groupId,
+        .groupId = groupId,
     };
     void* chIds = taosHashGet(pPullDataMap, &winRe, sizeof(SWinRes));
     if (isCloseWindow(&win, pSup)) {
@@ -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",

source/libs/function/src/builtinsimpl.c

@@ -80,7 +80,7 @@ typedef struct STopBotRes {
 } STopBotRes;
 
 typedef struct SFirstLastRes {
-  bool    hasResult;
+  bool hasResult;
   // used for last_row function only, isNullRes in SResultRowEntry can not be passed to downstream.So,
   // this attribute is required
   bool    isNull;
@@ -402,7 +402,6 @@ typedef struct SGroupKeyInfo {
     (x) += step;                           \
   } while (0)
 
-
 #define STATE_COMP(_op, _lval, _param) STATE_COMP_IMPL(_op, _lval, GET_STATE_VAL(_param))
 
 #define GET_STATE_VAL(param) ((param.nType == TSDB_DATA_TYPE_BIGINT) ? (param.i) : (param.d))
@@ -986,8 +985,8 @@ int32_t avgFunctionMerge(SqlFunctionCtx* pCtx) {
 
   int32_t start = pInput->startRowIndex;
 
-  for(int32_t i = start; i < start + pInput->numOfRows; ++i) {
+  for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
-    char* data = colDataGetData(pCol, i);
+    char*    data = colDataGetData(pCol, i);
     SAvgRes* pInputInfo = (SAvgRes*)varDataVal(data);
     avgTransferInfo(pInputInfo, pInfo);
   }
@@ -2559,8 +2558,8 @@ int32_t apercentileFunctionMerge(SqlFunctionCtx* pCtx) {
 
   int32_t start = pInput->startRowIndex;
 
-  for(int32_t i = start; i < start + pInput->numOfRows; ++i) {
+  for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
-    char* data = colDataGetData(pCol, i);
+    char*             data = colDataGetData(pCol, i);
     SAPercentileInfo* pInputInfo = (SAPercentileInfo*)varDataVal(data);
     apercentileTransferInfo(pInputInfo, pInfo);
   }
@@ -2925,8 +2924,8 @@ static int32_t firstLastFunctionMergeImpl(SqlFunctionCtx* pCtx, bool isFirstQuer
   int32_t start = pInput->startRowIndex;
   int32_t numOfElems = 0;
 
-  for(int32_t i = start; i < start + pInput->numOfRows; ++i) {
+  for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
-    char* data = colDataGetData(pCol, i);
+    char*          data = colDataGetData(pCol, i);
     SFirstLastRes* pInputInfo = (SFirstLastRes*)varDataVal(data);
     firstLastTransferInfo(pCtx, pInputInfo, pInfo, isFirstQuery);
     if (!numOfElems) {
@@ -2951,7 +2950,7 @@ int32_t firstLastFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
   pResInfo->isNullRes = (pResInfo->numOfRes == 0) ? 1 : 0;
 
   SFirstLastRes* pRes = GET_ROWCELL_INTERBUF(pResInfo);
-  colDataAppend(pCol, pBlock->info.rows, pRes->buf, pRes->isNull||pResInfo->isNullRes);
+  colDataAppend(pCol, pBlock->info.rows, pRes->buf, pRes->isNull || pResInfo->isNullRes);
 
   // handle selectivity
   STuplePos* pTuplePos = (STuplePos*)(pRes->buf + pRes->bytes + sizeof(TSKEY));
@@ -3763,8 +3762,8 @@ int32_t spreadFunctionMerge(SqlFunctionCtx* pCtx) {
 
   int32_t start = pInput->startRowIndex;
 
-  for(int32_t i = start; i < start + pInput->numOfRows; ++i) {
+  for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
-    char* data = colDataGetData(pCol, i);
+    char*        data = colDataGetData(pCol, i);
     SSpreadInfo* pInputInfo = (SSpreadInfo*)varDataVal(data);
     spreadTransferInfo(pInputInfo, pInfo);
   }
@@ -3935,8 +3934,8 @@ int32_t elapsedFunctionMerge(SqlFunctionCtx* pCtx) {
 
   int32_t start = pInput->startRowIndex;
 
-  for(int32_t i = start; i < start + pInput->numOfRows; ++i) {
+  for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
-    char* data = colDataGetData(pCol, i);
+    char*         data = colDataGetData(pCol, i);
     SElapsedInfo* pInputInfo = (SElapsedInfo*)varDataVal(data);
     elapsedTransferInfo(pInputInfo, pInfo);
   }
@@ -4200,13 +4199,9 @@ static int32_t histogramFunctionImpl(SqlFunctionCtx* pCtx, bool isPartial) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t histogramFunction(SqlFunctionCtx* pCtx) {
+int32_t histogramFunction(SqlFunctionCtx* pCtx) { return histogramFunctionImpl(pCtx, false); }
-  return histogramFunctionImpl(pCtx, false);
-}
 
-int32_t histogramFunctionPartial(SqlFunctionCtx* pCtx) {
+int32_t histogramFunctionPartial(SqlFunctionCtx* pCtx) { return histogramFunctionImpl(pCtx, true); }
-  return histogramFunctionImpl(pCtx, true);
-}
 
 static void histogramTransferInfo(SHistoFuncInfo* pInput, SHistoFuncInfo* pOutput) {
   pOutput->normalized = pInput->normalized;
@@ -4228,8 +4223,8 @@ int32_t histogramFunctionMerge(SqlFunctionCtx* pCtx) {
 
   int32_t start = pInput->startRowIndex;
 
-  for(int32_t i = start; i < start + pInput->numOfRows; ++i) {
+  for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
-    char* data = colDataGetData(pCol, i);
+    char*           data = colDataGetData(pCol, i);
     SHistoFuncInfo* pInputInfo = (SHistoFuncInfo*)varDataVal(data);
     histogramTransferInfo(pInputInfo, pInfo);
   }
@@ -4276,9 +4271,9 @@ int32_t histogramFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
 
 int32_t histogramPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
   SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
-  SHistoFuncInfo* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
+  SHistoFuncInfo*      pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
-  int32_t         resultBytes = getHistogramInfoSize();
+  int32_t              resultBytes = getHistogramInfoSize();
-  char*           res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
+  char*                res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
 
   memcpy(varDataVal(res), pInfo, resultBytes);
   varDataSetLen(res, resultBytes);
@@ -4449,8 +4444,8 @@ int32_t hllFunctionMerge(SqlFunctionCtx* pCtx) {
 
   int32_t start = pInput->startRowIndex;
 
-  for(int32_t i = start; i < start + pInput->numOfRows; ++i) {
+  for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
-    char* data = colDataGetData(pCol, i);
+    char*     data = colDataGetData(pCol, i);
     SHLLInfo* pInputInfo = (SHLLInfo*)varDataVal(data);
     hllTransferInfo(pInputInfo, pInfo);
   }
@@ -6007,7 +6002,7 @@ int32_t lastrowFunction(SqlFunctionCtx* pCtx) {
   SInputColumnInfoData* pInput = &pCtx->input;
   SColumnInfoData*      pInputCol = pInput->pData[0];
 
-  int32_t type  = pInputCol->info.type;
+  int32_t type = pInputCol->info.type;
   int32_t bytes = pInputCol->info.bytes;
 
   pInfo->bytes = bytes;
@@ -6019,7 +6014,6 @@ int32_t lastrowFunction(SqlFunctionCtx* pCtx) {
     char* data = colDataGetData(pInputCol, i);
     TSKEY cts = getRowPTs(pInput->pPTS, i);
     if (pResInfo->numOfRes == 0 || pInfo->ts < cts) {
-
       if (colDataIsNull_s(pInputCol, i)) {
         pInfo->isNull = true;
       } else {
@@ -6032,9 +6026,6 @@ int32_t lastrowFunction(SqlFunctionCtx* pCtx) {
       }
 
       pInfo->ts = cts;
-      pInfo->hasResult = true;
-      pResInfo->numOfRes = 1;
-
       if (pCtx->subsidiaries.num > 0) {
         STuplePos* pTuplePos = (STuplePos*)(pInfo->buf + bytes + sizeof(TSKEY));
         if (!pInfo->hasResult) {
@@ -6043,6 +6034,8 @@ int32_t lastrowFunction(SqlFunctionCtx* pCtx) {
           copyTupleData(pCtx, i, pCtx->pSrcBlock, pTuplePos);
         }
       }
+
+      pInfo->hasResult = true;
     }
   }
 

source/libs/nodes/src/nodesCodeFuncs.c

@@ -1470,9 +1470,36 @@ static int32_t jsonToPhysiScanNode(const SJson* pJson, void* pObj) {
   return code;
 }
 
-static int32_t physiTagScanNodeToJson(const void* pObj, SJson* pJson) { return physiScanNodeToJson(pObj, pJson); }
+static const char* jkLastRowScanPhysiPlanGroupTags = "GroupTags";
+static const char* jkLastRowScanPhysiPlanGroupSort = "GroupSort";
 
-static int32_t jsonToPhysiTagScanNode(const SJson* pJson, void* pObj) { return jsonToPhysiScanNode(pJson, pObj); }
+static int32_t physiLastRowScanNodeToJson(const void* pObj, SJson* pJson) {
+  const SLastRowScanPhysiNode* pNode = (const SLastRowScanPhysiNode*)pObj;
+
+  int32_t code = physiScanNodeToJson(pObj, pJson);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = nodeListToJson(pJson, jkLastRowScanPhysiPlanGroupTags, pNode->pGroupTags);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonAddBoolToObject(pJson, jkLastRowScanPhysiPlanGroupSort, pNode->groupSort);
+  }
+
+  return code;
+}
+
+static int32_t jsonToPhysiLastRowScanNode(const SJson* pJson, void* pObj) {
+  SLastRowScanPhysiNode* pNode = (SLastRowScanPhysiNode*)pObj;
+
+  int32_t code = jsonToPhysiScanNode(pJson, pObj);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = jsonToNodeList(pJson, jkLastRowScanPhysiPlanGroupTags, &pNode->pGroupTags);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonGetBoolValue(pJson, jkLastRowScanPhysiPlanGroupSort, &pNode->groupSort);
+  }
+
+  return code;
+}
 
 static const char* jkTableScanPhysiPlanScanCount = "ScanCount";
 static const char* jkTableScanPhysiPlanReverseScanCount = "ReverseScanCount";
@@ -4317,8 +4344,9 @@ static int32_t specificNodeToJson(const void* pObj, SJson* pJson) {
       return logicPlanToJson(pObj, pJson);
     case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN:
     case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN:
+      return physiScanNodeToJson(pObj, pJson);
     case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN:
-      return physiTagScanNodeToJson(pObj, pJson);
+      return physiLastRowScanNodeToJson(pObj, pJson);
     case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN:
     case QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN:
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN:
@@ -4463,8 +4491,10 @@ static int32_t jsonToSpecificNode(const SJson* pJson, void* pObj) {
       return jsonToLogicPlan(pJson, pObj);
     case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN:
     case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN:
+      return jsonToPhysiScanNode(pJson, pObj);
     case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN:
-      return jsonToPhysiTagScanNode(pJson, pObj);
+
+      return jsonToPhysiLastRowScanNode(pJson, pObj);
     case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN:
     case QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN:
     case QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN:

source/libs/parser/src/parInsert.c

@@ -1178,6 +1178,13 @@ static int parseOneRow(SInsertParseContext* pCxt, STableDataBlocks* pDataBlocks,
       TSKEY tsKey = TD_ROW_KEY(row);
       checkTimestamp(pDataBlocks, (const char*)&tsKey);
     }
+
+    if (i < spd->numOfBound - 1) {
+      NEXT_VALID_TOKEN(pCxt->pSql, sToken);
+      if (TK_NK_COMMA != sToken.type) {
+        return buildSyntaxErrMsg(&pCxt->msg, ", expected", sToken.z);
+      }
+    }
   }
 
   if (!isParseBindParam) {

source/libs/planner/src/planPhysiCreater.c

@@ -481,8 +481,6 @@ static ENodeType getScanOperatorType(EScanType scanType) {
       return QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN;
     case SCAN_TYPE_BLOCK_INFO:
       return QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN;
-    case SCAN_TYPE_LAST_ROW:
-      return QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN;
     default:
       break;
   }
@@ -502,6 +500,24 @@ static int32_t createSimpleScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* pSub
   return createScanPhysiNodeFinalize(pCxt, pSubplan, pScanLogicNode, pScan, pPhyNode);
 }
 
+static int32_t createLastRowScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* pSubplan, SScanLogicNode* pScanLogicNode,
+                                          SPhysiNode** pPhyNode) {
+  SLastRowScanPhysiNode* pScan =
+      (SLastRowScanPhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pScanLogicNode, QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN);
+  if (NULL == pScan) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  pScan->pGroupTags = nodesCloneList(pScanLogicNode->pGroupTags);
+  if (NULL != pScanLogicNode->pGroupTags && NULL == pScan->pGroupTags) {
+    nodesDestroyNode((SNode*)pScan);
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+  pScan->groupSort = pScanLogicNode->groupSort;
+
+  return createScanPhysiNodeFinalize(pCxt, pSubplan, pScanLogicNode, (SScanPhysiNode*)pScan, pPhyNode);
+}
+
 static int32_t createTableScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* pSubplan, SScanLogicNode* pScanLogicNode,
                                         SPhysiNode** pPhyNode) {
   STableScanPhysiNode* pTableScan = (STableScanPhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pScanLogicNode,
@@ -583,8 +599,9 @@ static int32_t createScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* pSubplan,
   switch (pScanLogicNode->scanType) {
     case SCAN_TYPE_TAG:
     case SCAN_TYPE_BLOCK_INFO:
-    case SCAN_TYPE_LAST_ROW:
       return createSimpleScanPhysiNode(pCxt, pSubplan, pScanLogicNode, pPhyNode);
+    case SCAN_TYPE_LAST_ROW:
+      return createLastRowScanPhysiNode(pCxt, pSubplan, pScanLogicNode, pPhyNode);
     case SCAN_TYPE_TABLE:
       return createTableScanPhysiNode(pCxt, pSubplan, pScanLogicNode, pPhyNode);
     case SCAN_TYPE_SYSTEM_TABLE:

source/libs/planner/src/planSpliter.c

@@ -364,6 +364,8 @@ static int32_t stbSplCreatePartWindowNode(SWindowLogicNode* pMergeWindow, SLogic
   pMergeWindow->node.pTargets = NULL;
   SNodeList* pChildren = pMergeWindow->node.pChildren;
   pMergeWindow->node.pChildren = NULL;
+  SNode* pConditions = pMergeWindow->node.pConditions;
+  pMergeWindow->node.pConditions = NULL;
 
   int32_t           code = TSDB_CODE_SUCCESS;
   SWindowLogicNode* pPartWin = (SWindowLogicNode*)nodesCloneNode((SNode*)pMergeWindow);
@@ -373,6 +375,7 @@ static int32_t stbSplCreatePartWindowNode(SWindowLogicNode* pMergeWindow, SLogic
 
   if (TSDB_CODE_SUCCESS == code) {
     pMergeWindow->node.pTargets = pTargets;
+    pMergeWindow->node.pConditions = pConditions;
     pPartWin->node.pChildren = pChildren;
     splSetParent((SLogicNode*)pPartWin);
     code = stbSplRewriteFuns(pFunc, &pPartWin->pFuncs, &pMergeWindow->pFuncs);

source/libs/planner/test/planBasicTest.cpp

@@ -108,6 +108,8 @@ TEST_F(PlanBasicTest, lastRowFunc) {
 
   run("SELECT LAST_ROW(c1) FROM st1");
 
+  run("SELECT LAST_ROW(c1) FROM st1 PARTITION BY TBNAME");
+
   run("SELECT LAST_ROW(c1), SUM(c3) FROM t1");
 }
 

source/libs/planner/test/planSubqueryTest.cpp

@@ -36,6 +36,8 @@ TEST_F(PlanSubqeuryTest, basic) {
   run("SELECT * FROM (SELECT NOW() FROM t1)");
 
   run("SELECT NOW() FROM (SELECT * FROM t1) ORDER BY ts");
+
+  run("SELECT * FROM (SELECT AVG(c1) a FROM st1 INTERVAL(10s)) WHERE a > 1");
 }
 
 TEST_F(PlanSubqeuryTest, doubleGroupBy) {

source/libs/scalar/src/scalar.c

@@ -11,7 +11,7 @@
 #include "ttime.h"
 
 int32_t scalarGetOperatorParamNum(EOperatorType type) {
-  if (OP_TYPE_IS_NULL == type || OP_TYPE_IS_NOT_NULL == type || OP_TYPE_IS_TRUE == type || OP_TYPE_IS_NOT_TRUE == type 
+  if (OP_TYPE_IS_NULL == type || OP_TYPE_IS_NOT_NULL == type || OP_TYPE_IS_TRUE == type || OP_TYPE_IS_NOT_TRUE == type
    || OP_TYPE_IS_FALSE == type || OP_TYPE_IS_NOT_FALSE == type || OP_TYPE_IS_UNKNOWN == type || OP_TYPE_IS_NOT_UNKNOWN == type
    || OP_TYPE_MINUS == type) {
     return 1;
@@ -28,7 +28,7 @@ int32_t sclConvertToTsValueNode(int8_t precision, SValueNode* valueNode) {
   }
   taosMemoryFree(timeStr);
   valueNode->typeData = valueNode->datum.i;
-  
+
   valueNode->node.resType.type = TSDB_DATA_TYPE_TIMESTAMP;
   valueNode->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_TIMESTAMP].bytes;
 
@@ -82,7 +82,7 @@ int32_t scalarGenerateSetFromList(void **data, void *pNode, uint32_t type) {
     SCL_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
   }
 
-  taosHashSetEqualFp(pObj, taosGetDefaultEqualFunction(type)); 
+  taosHashSetEqualFp(pObj, taosGetDefaultEqualFunction(type));
 
   int32_t code = 0;
   SNodeListNode *nodeList = (SNodeListNode *)pNode;
@@ -91,10 +91,10 @@ int32_t scalarGenerateSetFromList(void **data, void *pNode, uint32_t type) {
 
   int32_t len = 0;
   void *buf = NULL;
-  
+
   for (int32_t i = 0; i < nodeList->pNodeList->length; ++i) {
     SValueNode *valueNode = (SValueNode *)cell->pNode;
-    
+
     if (valueNode->node.resType.type != type) {
       out.columnData->info.type = type;
       if (IS_VAR_DATA_TYPE(type)) {
@@ -134,7 +134,7 @@ int32_t scalarGenerateSetFromList(void **data, void *pNode, uint32_t type) {
         len = valueNode->node.resType.bytes;
       }
     }
-    
+
     if (taosHashPut(pObj, buf, (size_t)len, NULL, 0)) {
       sclError("taosHashPut to set failed");
       SCL_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY);
@@ -180,7 +180,7 @@ int32_t sclCopyValueNodeValue(SValueNode *pNode, void **res) {
   if (TSDB_DATA_TYPE_NULL == pNode->node.resType.type) {
     return TSDB_CODE_SUCCESS;
   }
-  
+
   *res = taosMemoryMalloc(pNode->node.resType.bytes);
   if (NULL == (*res)) {
     sclError("malloc %d failed", pNode->node.resType.bytes);
@@ -222,14 +222,14 @@ int32_t sclInitParam(SNode* node, SScalarParam *param, SScalarCtx *ctx, int32_t
       if (type == 0) {
         type = nodeList->dataType.type;
       }
-      
+
       SCL_ERR_RET(scalarGenerateSetFromList((void **)&param->pHashFilter, node, type));
       param->hashValueType = type;
       if (taosHashPut(ctx->pRes, &node, POINTER_BYTES, param, sizeof(*param))) {
         taosHashCleanup(param->pHashFilter);
         sclError("taosHashPut nodeList failed, size:%d", (int32_t)sizeof(*param));
         return TSDB_CODE_QRY_OUT_OF_MEMORY;
-      }   
+      }
       break;
     }
     case QUERY_NODE_COLUMN: {
@@ -237,7 +237,7 @@ int32_t sclInitParam(SNode* node, SScalarParam *param, SScalarCtx *ctx, int32_t
         sclError("invalid node type for constant calculating, type:%d, src:%p", nodeType(node), ctx->pBlockList);
         SCL_ERR_RET(TSDB_CODE_QRY_APP_ERROR);
       }
-      
+
       SColumnNode *ref = (SColumnNode *)node;
 
       int32_t index = -1;
@@ -285,7 +285,7 @@ int32_t sclInitParam(SNode* node, SScalarParam *param, SScalarCtx *ctx, int32_t
       sclError("different row nums, rowNum:%d, newRowNum:%d", *rowNum, param->numOfRows);
       SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
     }
-    
+
     *rowNum = param->numOfRows;
   }
 
@@ -293,7 +293,7 @@ int32_t sclInitParam(SNode* node, SScalarParam *param, SScalarCtx *ctx, int32_t
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t sclInitParamList(SScalarParam **pParams, SNodeList* pParamList, SScalarCtx *ctx, int32_t *paramNum, int32_t *rowNum) {  
+int32_t sclInitParamList(SScalarParam **pParams, SNodeList* pParamList, SScalarCtx *ctx, int32_t *paramNum, int32_t *rowNum) {
   int32_t code = 0;
   if (NULL == pParamList) {
     if (ctx->pBlockList) {
@@ -318,18 +318,18 @@ int32_t sclInitParamList(SScalarParam **pParams, SNodeList* pParamList, SScalarC
     SNode *tnode = NULL;
     int32_t i = 0;
     if (SCL_IS_CONST_CALC(ctx)) {
-      WHERE_EACH (tnode, pParamList) { 
+      WHERE_EACH (tnode, pParamList) {
         if (!SCL_IS_CONST_NODE(tnode)) {
           WHERE_NEXT;
         } else {
           SCL_ERR_JRET(sclInitParam(tnode, &paramList[i], ctx, rowNum));
           ERASE_NODE(pParamList);
         }
-        
+
         ++i;
       }
     } else {
-      FOREACH(tnode, pParamList) { 
+      FOREACH(tnode, pParamList) {
         SCL_ERR_JRET(sclInitParam(tnode, &paramList[i], ctx, rowNum));
         ++i;
       }
@@ -339,7 +339,7 @@ int32_t sclInitParamList(SScalarParam **pParams, SNodeList* pParamList, SScalarC
   }
 
   if (0 == *rowNum) {
-    taosMemoryFreeClear(paramList);    
+    taosMemoryFreeClear(paramList);
   }
 
   *pParams = paramList;
@@ -354,7 +354,7 @@ int32_t sclGetNodeType(SNode *pNode, SScalarCtx *ctx) {
   if (NULL == pNode) {
     return -1;
   }
-  
+
   switch ((int)nodeType(pNode)) {
     case QUERY_NODE_VALUE: {
       SValueNode *valueNode = (SValueNode *)pNode;
@@ -397,7 +397,7 @@ int32_t sclInitOperatorParams(SScalarParam **pParams, SOperatorNode *node, SScal
     sclError("invalid operation node, left:%p, right:%p", node->pLeft, node->pRight);
     SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
   }
-  
+
   SScalarParam *paramList = taosMemoryCalloc(paramNum, sizeof(SScalarParam));
   if (NULL == paramList) {
     sclError("calloc %d failed", (int32_t)(paramNum * sizeof(SScalarParam)));
@@ -440,7 +440,7 @@ int32_t sclExecFunction(SFunctionNode *node, SScalarCtx *ctx, SScalarParam *outp
       sclError("fmGetFuncExecFuncs failed, funcId:%d, code:%s", node->funcId, tstrerror(code));
       SCL_ERR_JRET(code);
     }
-  
+
     code = sclCreateColumnInfoData(&node->node.resType, rowNum, output);
     if (code != TSDB_CODE_SUCCESS) {
       SCL_ERR_JRET(code);
@@ -588,27 +588,27 @@ EDealRes sclRewriteNullInOptr(SNode** pNode, SScalarCtx *ctx, EOperatorType opTy
   if (opType <= OP_TYPE_CALC_MAX) {
     SValueNode *res = (SValueNode *)nodesMakeNode(QUERY_NODE_VALUE);
     if (NULL == res) {
-      sclError("make value node failed");    
+      sclError("make value node failed");
       ctx->code = TSDB_CODE_QRY_OUT_OF_MEMORY;
       return DEAL_RES_ERROR;
     }
-    
+
     res->node.resType.type = TSDB_DATA_TYPE_NULL;
-    
+
     nodesDestroyNode(*pNode);
     *pNode = (SNode*)res;
   } else {
     SValueNode *res = (SValueNode *)nodesMakeNode(QUERY_NODE_VALUE);
     if (NULL == res) {
-      sclError("make value node failed");    
+      sclError("make value node failed");
       ctx->code = TSDB_CODE_QRY_OUT_OF_MEMORY;
       return DEAL_RES_ERROR;
     }
-    
+
     res->node.resType.type = TSDB_DATA_TYPE_BOOL;
     res->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes;
     res->datum.b = false;
-    
+
     nodesDestroyNode(*pNode);
     *pNode = (SNode*)res;
   }
@@ -641,12 +641,12 @@ EDealRes sclRewriteNonConstOperator(SNode** pNode, SScalarCtx *ctx) {
 
   if (node->pLeft && (QUERY_NODE_VALUE == nodeType(node->pLeft))) {
     SValueNode *valueNode = (SValueNode *)node->pLeft;
-    if (SCL_IS_NULL_VALUE_NODE(valueNode) && (node->opType != OP_TYPE_IS_NULL && node->opType != OP_TYPE_IS_NOT_NULL) 
+    if (SCL_IS_NULL_VALUE_NODE(valueNode) && (node->opType != OP_TYPE_IS_NULL && node->opType != OP_TYPE_IS_NOT_NULL)
         && (!sclContainsAggFuncNode(node->pRight))) {
       return sclRewriteNullInOptr(pNode, ctx, node->opType);
     }
 
-    if (IS_STR_DATA_TYPE(valueNode->node.resType.type) && node->pRight && nodesIsExprNode(node->pRight) 
+    if (IS_STR_DATA_TYPE(valueNode->node.resType.type) && node->pRight && nodesIsExprNode(node->pRight)
       && ((SExprNode*)node->pRight)->resType.type == TSDB_DATA_TYPE_TIMESTAMP) {
       code = sclConvertToTsValueNode(((SExprNode*)node->pRight)->resType.precision, valueNode);
       if (code) {
@@ -663,7 +663,7 @@ EDealRes sclRewriteNonConstOperator(SNode** pNode, SScalarCtx *ctx) {
       return sclRewriteNullInOptr(pNode, ctx, node->opType);
     }
 
-    if (IS_STR_DATA_TYPE(valueNode->node.resType.type) && node->pLeft && nodesIsExprNode(node->pLeft) 
+    if (IS_STR_DATA_TYPE(valueNode->node.resType.type) && node->pLeft && nodesIsExprNode(node->pLeft)
       && ((SExprNode*)node->pLeft)->resType.type == TSDB_DATA_TYPE_TIMESTAMP) {
       code = sclConvertToTsValueNode(((SExprNode*)node->pLeft)->resType.precision, valueNode);
       if (code) {
@@ -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;
@@ -832,7 +833,7 @@ EDealRes sclRewriteOperator(SNode** pNode, SScalarCtx *ctx) {
       res->datum.p = output.columnData->pData;
       output.columnData->pData = NULL;
     } else {
-      nodesSetValueNodeValue(res, output.columnData->pData);    
+      nodesSetValueNodeValue(res, output.columnData->pData);
     }
   }
 
@@ -899,7 +900,7 @@ EDealRes sclWalkLogic(SNode* pNode, SScalarCtx *ctx) {
 EDealRes sclWalkOperator(SNode* pNode, SScalarCtx *ctx) {
   SOperatorNode *node = (SOperatorNode *)pNode;
   SScalarParam output = {0};
-  
+
   ctx->code = sclExecOperator(node, ctx, &output);
   if (ctx->code) {
     return DEAL_RES_ERROR;
@@ -1023,7 +1024,7 @@ int32_t sclCalcConstants(SNode *pNode, bool dual, SNode **pRes) {
     sclError("taosHashInit failed, num:%d", SCL_DEFAULT_OP_NUM);
     SCL_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
   }
-  
+
   nodesRewriteExprPostOrder(&pNode, sclConstantsRewriter, (void *)&ctx);
   SCL_ERR_JRET(ctx.code);
   *pRes = pNode;
@@ -1125,7 +1126,7 @@ int32_t scalarCalculate(SNode *pNode, SArray *pBlockList, SScalarParam *pDst) {
     sclError("taosHashInit failed, num:%d", SCL_DEFAULT_OP_NUM);
     SCL_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
   }
-  
+
   nodesWalkExprPostOrder(pNode, sclCalcWalker, (void *)&ctx);
   SCL_ERR_JRET(ctx.code);
 

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,168 @@ 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;
+  *out = 0;
+  for (int32_t i = 0; i < pInput->numOfRows; ++i) {
+    if (colDataIsNull_s(pInputData, i)) {
+      colDataAppendNULL(pOutputData, i);
+      break;
+    }
+    (*out)++;
+  }
+
+  pOutput->numOfRows = pInput->numOfRows;
+  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);
+  for (int32_t i = 0; i < pInput->numOfRows; ++i) {
+    if (colDataIsNull_s(pInputData, i)) {
+      colDataAppendNULL(pOutputData, i);
+      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];
+    }
+  }
+
+  pOutput->numOfRows = pInput->numOfRows;
+  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);
+
+  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)) {
+      colDataAppendNULL(pOutputData, i);
+      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;
+      }
+    }
+  }
+
+  pOutput->numOfRows = pInput->numOfRows;
+  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);
+}

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/streamExec.c

@@ -74,63 +74,62 @@ static int32_t streamTaskExecImpl(SStreamTask* pTask, void* data, SArray* pRes)
 }
 
 static SArray* streamExecForQall(SStreamTask* pTask, SArray* pRes) {
+  int32_t cnt = 0;
+  void*   data = NULL;
   while (1) {
-    int32_t cnt = 0;
+    SStreamQueueItem* qItem = streamQueueNextItem(pTask->inputQueue);
-    void*   data = NULL;
+    if (qItem == NULL) {
-    while (1) {
+      qDebug("stream exec over, queue empty");
-      SStreamQueueItem* qItem = streamQueueNextItem(pTask->inputQueue);
+      break;
-      if (qItem == NULL) {
+    }
-        qDebug("stream exec over, queue empty");
+    if (data == NULL) {
+      data = qItem;
+      streamQueueProcessSuccess(pTask->inputQueue);
+      continue;
+    } else {
+      if (streamAppendQueueItem(data, qItem) < 0) {
+        streamQueueProcessFail(pTask->inputQueue);
         break;
-      }
-      if (data == NULL) {
-        data = qItem;
-        streamQueueProcessSuccess(pTask->inputQueue);
-        continue;
       } else {
-        if (streamAppendQueueItem(data, qItem) < 0) {
+        cnt++;
-          streamQueueProcessFail(pTask->inputQueue);
+        streamQueueProcessSuccess(pTask->inputQueue);
-          break;
+        taosArrayDestroy(((SStreamDataBlock*)qItem)->blocks);
-        } else {
+        taosFreeQitem(qItem);
-          cnt++;
-          streamQueueProcessSuccess(pTask->inputQueue);
-          taosArrayDestroy(((SStreamDataBlock*)qItem)->blocks);
-          taosFreeQitem(qItem);
-        }
       }
     }
-    if (data == NULL) break;
+  }
+  if (pTask->taskStatus == TASK_STATUS__DROPPING) {
+    if (data) streamFreeQitem(data);
+    taosArrayDestroyEx(pRes, (FDelete)blockDataFreeRes);
+    return NULL;
+  }
 
-    qDebug("stream task %d exec begin, batch msg: %d", pTask->taskId, cnt);
+  if (data == NULL) return pRes;
-    streamTaskExecImpl(pTask, data, pRes);
-    qDebug("stream task %d exec end", pTask->taskId);
 
-    if (pTask->taskStatus == TASK_STATUS__DROPPING) {
+  qDebug("stream task %d exec begin, msg batch: %d", pTask->taskId, cnt);
-      taosArrayDestroyEx(pRes, (FDelete)blockDataFreeRes);
+  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) {
+      streamQueueProcessFail(pTask->inputQueue);
+      taosArrayDestroy(pRes);
       return NULL;
     }
-
+    qRes->type = STREAM_INPUT__DATA_BLOCK;
-    if (taosArrayGetSize(pRes) != 0) {
+    qRes->blocks = pRes;
-      SStreamDataBlock* qRes = taosAllocateQitem(sizeof(SStreamDataBlock), DEF_QITEM);
+    if (streamTaskOutput(pTask, qRes) < 0) {
-      if (qRes == NULL) {
+      /*streamQueueProcessFail(pTask->inputQueue);*/
-        streamQueueProcessFail(pTask->inputQueue);
+      taosArrayDestroyEx(pRes, (FDelete)blockDataFreeRes);
-        taosArrayDestroy(pRes);
+      taosFreeQitem(qRes);
-        return NULL;
+      return NULL;
-      }
-      qRes->type = STREAM_INPUT__DATA_BLOCK;
-      qRes->blocks = pRes;
-      if (streamTaskOutput(pTask, qRes) < 0) {
-        /*streamQueueProcessFail(pTask->inputQueue);*/
-        taosArrayDestroyEx(pRes, (FDelete)blockDataFreeRes);
-        taosFreeQitem(qRes);
-        return NULL;
-      }
-      /*streamQueueProcessSuccess(pTask->inputQueue);*/
-      pRes = taosArrayInit(0, sizeof(SSDataBlock));
     }
-
+    /*streamQueueProcessSuccess(pTask->inputQueue);*/
-    streamFreeQitem(data);
+    pRes = taosArrayInit(0, sizeof(SSDataBlock));
   }
+
+  streamFreeQitem(data);
   return pRes;
 }
 
@@ -171,6 +170,11 @@ int32_t streamExec(SStreamTask* pTask, SMsgCb* pMsgCb) {
   }
 FAIL:
   if (pRes) taosArrayDestroy(pRes);
-  atomic_store_8(&pTask->execStatus, TASK_EXEC_STATUS__IDLE);
+  if (pTask->taskStatus == TASK_STATUS__DROPPING) {
-  return -1;
+    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);
 }

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/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
@@ -161,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
@@ -209,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
@@ -228,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
@@ -280,6 +445,12 @@
 # ---- 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

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,8 +47,6 @@ while $x < $rowNum
     $x = $x + 1  
 endw
 
-sleep 100
-
 print =============== step2
 $i = 0
 $tb = $tbPrefix . $i

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,64 +6,36 @@ 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 $data01 != localhost:7100 then
-    return -1
-  endi
 endi
-if $data04 != ready then
+if $data(2)[4] != ready then
-  goto check_dnode_ready_1
+  goto step1
 endi
-if $data14 != ready then
+if $data(3)[4] != ready then
-  goto check_dnode_ready_1
+  goto step1
-endi
-if $data24 != ready then
-  goto check_dnode_ready_1
 endi
 
+
 print ============= create database
 #database_option: {
 #  | BUFFER value       [3~16384, default: 96]
@@ -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   

tests/script/tsim/insert/backquote.sim

@@ -1,9 +1,9 @@
 system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
 system sh/exec.sh -n dnode1 -s start
-sleep 50
 sql connect
 
+
 print =============== create database
 sql create database `database`
 sql create database `DataBase`
@@ -184,23 +184,6 @@ print =============== stop and restart taosd
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
 system sh/exec.sh -n dnode1 -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 show databases
 print rows: $rows 
 print $data00  $data01

tests/script/tsim/insert/basic.sim

@@ -1,10 +1,6 @@
 system sh/stop_dnodes.sh
-
 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start
-
-sleep 2000
 sql connect
 
 $i = 0

tests/script/tsim/insert/basic0.sim

@@ -271,23 +271,6 @@ print =============== stop and restart taosd, then again do query above
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
 system sh/exec.sh -n dnode1 -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
-
 print =============== query data from child table
 sql select * from ct1
 print rows: $rows 

tests/script/tsim/insert/basic1.sim

@@ -2,6 +2,7 @@ system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
 system sh/exec.sh -n dnode1 -s start
 sql connect
+
 print =============== create database
 sql create database d1
 sql show databases

tests/script/tsim/insert/commit-merge0.sim

@@ -1,7 +1,6 @@
 system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
 system sh/exec.sh -n dnode1 -s start
-sleep 50
 sql connect
 
 print =============== create database
@@ -64,23 +63,6 @@ reboot_and_check:
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
 system sh/exec.sh -n dnode1 -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
-
 print =============== insert duplicated records to memory - loop $reboot_max - $reboot_cnt 
 sql use db
 sql insert into ct1 values ('2022-05-01 18:30:27.001', 0.0);

tests/script/tsim/insert/insert_drop.sim

@@ -1,10 +1,6 @@
 system sh/stop_dnodes.sh
-
 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start
-
-sleep 2000
 sql connect
 
 $tbNum = 10
@@ -19,7 +15,7 @@ $stb = stb
 
 sql drop database $db -x step1
 step1:
-sql create database $db ctime 30
+sql create database $db
 print ====== create tables
 sql use $db
 sql create table $stb (ts timestamp, c1 int) tags(t1 int)
@@ -43,13 +39,9 @@ print ====== tables created
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 3000
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 
-sql reset query cache
-sleep 1000
-
 sql use $db
 sql drop table tb5
 $i = 0
@@ -69,13 +61,9 @@ endw
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 3000
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 
-sql reset query cache
-sleep 1000
-
 sql use $db
 
 sql create table tb5 using $stb tags(5)

tests/script/tsim/insert/null.sim

@@ -1,7 +1,6 @@
 system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
 system sh/exec.sh -n dnode1 -s start
-sleep 50
 sql connect
 
 print =============== create database
@@ -211,66 +210,48 @@ endi
 #===================================================================
 
 #print =============== query data from stb
-#sql select * from stb
+sql select * from stb
-#print ===> 
+print ===> 
-#print ===> rows: $rows
+print ===> rows: $rows
-#print ===> rows0: $data00 $data01 $data02 $data03 $data04
+print ===> rows0: $data00 $data01 $data02 $data03 $data04
-#if $rows != 4 then 
+if $rows != 12 then 
-#  return -1
+  return -1
-#endi
+endi
+
 #print =============== select count(*) from supter table
-#sql select count(*) from stb
+sql select count(*) from stb
-#print $data00 $data01 $data02
+print $data00 $data01 $data02
-#if $rows != 1 then 
+if $rows != 1 then 
-#  return -1
+  return -1
-#endi
+endi
-#if $data00 != 12 then 
+if $data00 != 12 then 
-#  return -1
+  return -1
-#endi
+endi
 
 #print =============== select count(column) from supter table
-#sql select count(ts), count(c1), count(c2), count(c3) from stb
+sql select count(ts), count(c1), count(c2), count(c3) from stb
-#print $data00 $data01 $data02  $data03
+print $data00 $data01 $data02  $data03
-#if $data00 != 12 then 
+if $data00 != 12 then 
-#  return -1
+  return -1
-#endi
+endi
-#if $data01 != 8 then 
+if $data01 != 8 then 
-#  return -1
+  return -1
-#endi
+endi
-#if $data02 != 8 then 
+if $data02 != 8 then 
-#  return -1
+  return -1
-#endi
+endi
-#if $data03 != 8 then 
+if $data03 != 8 then 
-#  return -1
+  return -1
-#endi
+endi
 
-#===================================================================
 #===================================================================
 
 print =============== stop and restart taosd, then again do query above
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
 system sh/exec.sh -n dnode1 -s start
 
-print ===> waiting dnode ready
+#===================================================================
-$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
 
-#===================================================================
-#===================================================================
 print =============== query data from child table
 sql select * from ct1
 print ===> select * from ct1
@@ -292,15 +273,15 @@ endi
 if $data03 != 3.000000000 then 
   return -1
 endi
-#if $data41 != -14 then 
+if $data41 != 12 then 
-#  return -1
+  return -1
-#endi
+endi
-#if $data42 != -2.40000 then 
+if $data42 != 2.20000 then 
-#  return -1
+  return -1
-#endi
+endi
-#if $data43 != -3.400000000 then 
+if $data43 != NULL then 
-#  return -1
+  return -1
-#endi
+endi
 
 print =============== select count(*) from child table
 sql select count(*) from ct1
@@ -435,40 +416,39 @@ if $data92 != 3.600000000 then
   return -1
 endi
 #===================================================================
-#===================================================================
 
-#print =============== query data from stb
+print =============== query data from stb
-#sql select * from stb
+sql select * from stb
-#print ===> 
+print ===> 
-#print ===> rows: $rows
+print ===> rows: $rows
-#print ===> rows0: $data00 $data01 $data02 $data03 $data04
+print ===> rows0: $data00 $data01 $data02 $data03 $data04
-#if $rows != 4 then 
+if $rows != 12 then 
-#  return -1
+  return -1
-#endi
+endi
-#print =============== select count(*) from supter table
+print =============== select count(*) from supter table
-#sql select count(*) from stb
+sql select count(*) from stb
-#print $data00 $data01 $data02
+print $data00 $data01 $data02
-#if $rows != 1 then 
+if $rows != 1 then 
-#  return -1
+  return -1
-#endi
+endi
-#if $data00 != 12 then 
+if $data00 != 12 then 
-#  return -1
+  return -1
-#endi
+endi
 
-#print =============== select count(column) from supter table
+print =============== select count(column) from supter table
-#sql select count(ts), count(c1), count(c2), count(c3) from stb
+sql select count(ts), count(c1), count(c2), count(c3) from stb
-#print $data00 $data01 $data02  $data03
+print $data00 $data01 $data02  $data03
-#if $data00 != 12 then 
+if $data00 != 12 then 
-#  return -1
+  return -1
-#endi
+endi
-#if $data01 != 8 then 
+if $data01 != 8 then 
-#  return -1
+  return -1
-#endi
+endi
-#if $data02 != 8 then 
+if $data02 != 8 then 
-#  return -1
+  return -1
-#endi
+endi
-#if $data03 != 8 then 
+if $data03 != 8 then 
-#  return -1
+  return -1
-#endi
+endi
 
 system sh/exec.sh -n dnode1 -s stop -x SIGINT

tests/script/tsim/insert/query_block1_file.sim

@@ -1,11 +1,6 @@
 system sh/stop_dnodes.sh
-
-
 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start
-
-sleep 2000
 sql connect
 
 $i = 0
@@ -190,7 +185,7 @@ clear:
 
 sql drop database $db
 sql show databases
-if $rows != 0 then 
+if $rows != 2 then 
   return -1
 endi
 

tests/script/tsim/insert/query_block1_memory.sim

@@ -1,11 +1,6 @@
 system sh/stop_dnodes.sh
-
-
 system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start
-
-sleep 2000
 sql connect
 
 $i = 0
@@ -175,7 +170,7 @@ clear:
 
 sql drop database $db
 sql show databases
-if $rows != 0 then 
+if $rows != 2 then 
   return -1
 endi