Merge branch '3.0' into test/bug_fix_update

docs/zh/12-taos-sql/12-interval.md

@@ -3,9 +3,9 @@ sidebar_label: 时序数据特色查询
 title: 时序数据特色查询
 ---
 
-TDengine是专为时序数据而研发的大数据平台，存储和计算都针对时序数据的特定进行了量身定制，在支持标准SQL的基础之上，还提供了一系列贴合时序业务场景的特色查询语法，极大的方便时序场景的应用开发。
+TDengine 是专为时序数据而研发的大数据平台，存储和计算都针对时序数据的特定进行了量身定制，在支持标准 SQL 的基础之上，还提供了一系列贴合时序业务场景的特色查询语法，极大的方便时序场景的应用开发。
 
-TDengine提供的特色查询包括标签切分查询和窗口切分查询。
+TDengine 提供的特色查询包括标签切分查询和窗口切分查询。
 
 ## 标签切分查询
 
@@ -14,13 +14,14 @@ TDengine提供的特色查询包括标签切分查询和窗口切分查询。
 ```sql
 PARTITION BY tag_list
 ```
-其中 `tag_list` 是标签列的列表，还可以包括tbname伪列。
 
-TDengine按如下方式处理标签切分子句：
+其中 `tag_list` 是标签列的列表，还可以包括 tbname 伪列。
+
+TDengine 按如下方式处理标签切分子句：
 
 标签切分子句位于 `WHERE` 子句之后，且不能和 `JOIN` 子句一起使用。
 标签切分子句将超级表数据按指定的标签组合进行切分，然后对每个切分的分片进行指定的计算。计算由之后的子句定义（窗口子句、`GROUP BY` 子句或`SELECT` 子句）。
-标签切分子句可以和窗口切分子句（或 `GROUP BY` 子句）一起使用，此时后面的子句作用在每个切分的分片上。例如，下面的示例将数据按标签 `location` 进行分组，并对每个组按10分钟进行降采样，取其最大值。
+标签切分子句可以和窗口切分子句（或 `GROUP BY` 子句）一起使用，此时后面的子句作用在每个切分的分片上。例如，下面的示例将数据按标签 `location` 进行分组，并对每个组按 10 分钟进行降采样，取其最大值。
 
 ```sql
 select max(current) from meters partition by location interval(10m)
@@ -42,27 +43,31 @@ SELECT function_list FROM tb_name
 在上述语法中的具体限制如下
 
 ### 窗口切分查询中使用函数的限制
+
 - 在聚合查询中，function_list 位置允许使用聚合和选择函数，并要求每个函数仅输出单个结果（例如：COUNT、AVG、SUM、STDDEV、LEASTSQUARES、PERCENTILE、MIN、MAX、FIRST、LAST），而不能使用具有多行输出结果的函数（例如：DIFF 以及四则运算）。
 - 此外 LAST_ROW 查询也不能与窗口聚合同时出现。
 - 标量函数（如：CEIL/FLOOR 等）也不能使用在窗口聚合查询中。
 
 ### 窗口子句的规则
-- 窗口子句位于标签切分子句之后，GROUP BY子句之前，且不可以和GROUP BY子句一起使用。
-- 窗口子句将数据按窗口进行切分，对每个窗口进行SELECT列表中的表达式的计算，SELECT列表中的表达式只能包含：
+
+- 窗口子句位于标签切分子句之后，GROUP BY 子句之前，且不可以和 GROUP BY 子句一起使用。
+- 窗口子句将数据按窗口进行切分，对每个窗口进行 SELECT 列表中的表达式的计算，SELECT 列表中的表达式只能包含：
   - 常量。
   - 聚集函数。
   - 包含上面表达式的表达式。
-- 窗口子句不可以和GROUP BY子句一起使用。
+- 窗口子句不可以和 GROUP BY 子句一起使用。
 - WHERE 语句可以指定查询的起止时间和其他过滤条件。
 
 ### FILL 子句
- FILL 语句指定某一窗口区间数据缺失的情况下的填充模式。填充模式包括以下几种：
-  1. 不进行填充：NONE（默认填充模式）。
-  2. VALUE 填充：固定值填充，此时需要指定填充的数值。例如：FILL(VALUE, 1.23)。这里需要注意，最终填充的值受由相应列的类型决定，如FILL(VALUE, 1.23)，相应列为INT类型，则填充值为1。
-  3. PREV 填充：使用前一个非 NULL 值填充数据。例如：FILL(PREV)。
-  4. NULL 填充：使用 NULL 填充数据。例如：FILL(NULL)。
-  5. LINEAR 填充：根据前后距离最近的非 NULL 值做线性插值填充。例如：FILL(LINEAR)。
-  6. NEXT 填充：使用下一个非 NULL 值填充数据。例如：FILL(NEXT)。
+
+FILL 语句指定某一窗口区间数据缺失的情况下的填充模式。填充模式包括以下几种：
+
+1. 不进行填充：NONE（默认填充模式）。
+2. VALUE 填充：固定值填充，此时需要指定填充的数值。例如：FILL(VALUE, 1.23)。这里需要注意，最终填充的值受由相应列的类型决定，如 FILL(VALUE, 1.23)，相应列为 INT 类型，则填充值为 1。
+3. PREV 填充：使用前一个非 NULL 值填充数据。例如：FILL(PREV)。
+4. NULL 填充：使用 NULL 填充数据。例如：FILL(NULL)。
+5. LINEAR 填充：根据前后距离最近的非 NULL 值做线性插值填充。例如：FILL(LINEAR)。
+6. NEXT 填充：使用下一个非 NULL 值填充数据。例如：FILL(NEXT)。
 
 :::info
 
@@ -93,6 +98,7 @@ SELECT COUNT(*) FROM temp_tb_1 INTERVAL(1m) SLIDING(2m);
 ```
 
 使用时间窗口需要注意：
+
 - 聚合时间段的窗口宽度由关键词 INTERVAL 指定，最短时间间隔 10 毫秒（10a）；并且支持偏移 offset（偏移必须小于间隔），也即时间窗口划分与“UTC 时刻 0”相比的偏移量。SLIDING 语句用于指定聚合时间段的前向增量，也即每次窗口向前滑动的时长。
 - 使用 INTERVAL 语句时，除非极特殊的情况，都要求把客户端和服务端的 taos.cfg 配置文件中的 timezone 参数配置为相同的取值，以避免时间处理函数频繁进行跨时区转换而导致的严重性能影响。
 - 返回的结果中时间序列严格单调递增。

docs/zh/12-taos-sql/22-information.md

+---
+sidebar_label: Information内置数据库
+title: Information内置数据库
+---
+

include/common/tcommon.h

@@ -80,8 +80,6 @@ typedef struct {
   SArray*   pTableList;
   SHashObj* map;  // speedup acquire the tableQueryInfo by table uid
   bool      needSortTableByGroupId;
-  void*     pTagCond;
-  void*     pTagIndexCond;
   uint64_t  suid;
 } STableListInfo;
 

include/libs/scalar/scalar.h

@@ -117,6 +117,12 @@ int32_t diffScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam
 int32_t stateCountScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 int32_t stateDurationScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 int32_t histogramScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t topBotScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t firstLastScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t sampleScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t tailScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t uniqueScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t modeScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 
 #ifdef __cplusplus
 }

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

@@ -298,7 +298,8 @@ static int32_t mndDoRebalance(SMnode *pMnode, const SMqRebInputObj *pInput, SMqR
                 .pVgEp = pVgEp,
             };
             taosHashPut(pHash, &pVgEp->vgId, sizeof(int32_t), &outputVg, sizeof(SMqRebOutputVg));
-            mInfo("mq rebalance: remove vgId:%d from consumer:%" PRId64 ",(first scan)", pVgEp->vgId, pConsumerEp->consumerId);
+            mInfo("mq rebalance: remove vgId:%d from consumer:%" PRId64 ",(first scan)", pVgEp->vgId,
+                  pConsumerEp->consumerId);
           }
           imbCnt++;
         }
@@ -312,7 +313,8 @@ static int32_t mndDoRebalance(SMnode *pMnode, const SMqRebInputObj *pInput, SMqR
               .pVgEp = pVgEp,
           };
           taosHashPut(pHash, &pVgEp->vgId, sizeof(int32_t), &outputVg, sizeof(SMqRebOutputVg));
-          mInfo("mq rebalance: remove vgId:%d from consumer:%" PRId64 ",(first scan)", pVgEp->vgId, pConsumerEp->consumerId);
+          mInfo("mq rebalance: remove vgId:%d from consumer:%" PRId64 ",(first scan)", pVgEp->vgId,
+                pConsumerEp->consumerId);
         }
       }
     }
@@ -354,7 +356,8 @@ static int32_t mndDoRebalance(SMnode *pMnode, const SMqRebInputObj *pInput, SMqR
       taosArrayPush(pConsumerEp->vgs, &pRebVg->pVgEp);
       pRebVg->newConsumerId = pConsumerEp->consumerId;
       taosArrayPush(pOutput->rebVgs, pRebVg);
-      mInfo("mq rebalance: add vgId:%d to consumer:%" PRId64 ",(second scan)", pRebVg->pVgEp->vgId, pConsumerEp->consumerId);
+      mInfo("mq rebalance: add vgId:%d to consumer:%" PRId64 ",(second scan)", pRebVg->pVgEp->vgId,
+            pConsumerEp->consumerId);
     }
   }
 
@@ -371,8 +374,14 @@ static int32_t mndDoRebalance(SMnode *pMnode, const SMqRebInputObj *pInput, SMqR
       ASSERT(pConsumerEp->consumerId > 0);
       taosArrayPush(pConsumerEp->vgs, &pRebVg->pVgEp);
       pRebVg->newConsumerId = pConsumerEp->consumerId;
+      if (pRebVg->newConsumerId == pRebVg->oldConsumerId) {
+        mInfo("mq rebalance: skip vg %d for same consumer:%" PRId64 ",(second scan)", pRebVg->pVgEp->vgId,
+              pConsumerEp->consumerId);
+        continue;
+      }
       taosArrayPush(pOutput->rebVgs, pRebVg);
-      mInfo("mq rebalance: add vgId:%d to consumer:%" PRId64 ",(second scan)", pRebVg->pVgEp->vgId, pConsumerEp->consumerId);
+      mInfo("mq rebalance: add vgId:%d to consumer:%" PRId64 ",(second scan)", pRebVg->pVgEp->vgId,
+            pConsumerEp->consumerId);
     }
   } else {
     // if all consumer is removed, put all vg into unassigned

source/libs/executor/inc/executil.h

@@ -15,6 +15,7 @@
 #ifndef TDENGINE_QUERYUTIL_H
 #define TDENGINE_QUERYUTIL_H
 
+#include "vnode.h"
 #include "function.h"
 #include "nodes.h"
 #include "plannodes.h"
@@ -106,7 +107,7 @@ int32_t getNumOfTotalRes(SGroupResInfo* pGroupResInfo);
 SSDataBlock* createResDataBlock(SDataBlockDescNode* pNode);
 
 EDealRes doTranslateTagExpr(SNode** pNode, void* pContext);
-int32_t  getTableList(void* metaHandle, void* vnode, SScanPhysiNode* pScanNode, STableListInfo* pListInfo);
+int32_t getTableList(void* metaHandle, void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, SNode* pTagIndexCond, STableListInfo* pListInfo);
 SArray*  createSortInfo(SNodeList* pNodeList);
 SArray*  extractPartitionColInfo(SNodeList* pNodeList);
 SArray*  extractColMatchInfo(SNodeList* pNodeList, SDataBlockDescNode* pOutputNodeList, int32_t* numOfOutputCols,
@@ -128,4 +129,6 @@ int32_t convertFillType(int32_t mode);
 
 int32_t resultrowComparAsc(const void* p1, const void* p2);
 
+int32_t isTableOk(STableKeyInfo* info, SNode* pTagCond, void* metaHandle, bool* pQualified);
+
 #endif  // TDENGINE_QUERYUTIL_H

source/libs/executor/inc/executorimpl.h

@@ -311,19 +311,10 @@ typedef struct STableScanInfo {
   int32_t         dataBlockLoadFlag;
   SInterval       interval;     // if the upstream is an interval operator, the interval info is also kept here to get the time window to check if current data block needs to be loaded.
   SSampleExecInfo sample;       // sample execution info
-
   int32_t         currentGroupId;
   int32_t         currentTable;
-
-#if 0
-  struct {
-    uint64_t uid;
-    int64_t ts;
-  } lastStatus;
-#endif
-
-  int8_t scanMode;
-  int8_t noTable;
+  int8_t          scanMode;
+  int8_t          noTable;
 } STableScanInfo;
 
 typedef struct STagScanInfo {
@@ -429,8 +420,9 @@ typedef struct SStreamScanInfo {
 
   // status for tmq
   // SSchemaWrapper schema;
-  STqOffset offset;
-
+  STqOffset              offset;
+  SNode*                 pTagCond;
+  SNode*                 pTagIndexCond;
 } SStreamScanInfo;
 
 typedef struct SSysTableScanInfo {
@@ -874,8 +866,8 @@ SOperatorInfo* createGroupOperatorInfo(SOperatorInfo* downstream, SExprInfo* pEx
 SOperatorInfo* createDataBlockInfoScanOperator(void* dataReader, SReadHandle* readHandle, uint64_t uid, SBlockDistScanPhysiNode* pBlockScanNode,
                                                SExecTaskInfo* pTaskInfo);
 
-SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle,
-    STableScanPhysiNode* pTableScanNode, SExecTaskInfo* pTaskInfo, STimeWindowAggSupp* pTwSup, uint64_t queryId, uint64_t taskId);
+SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode* pTableScanNode, SNode* pTagCond,
+                                            SExecTaskInfo* pTaskInfo, STimeWindowAggSupp* pTwSup);
 
 SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* pPhyFillNode, SExecTaskInfo* pTaskInfo);
 
@@ -966,12 +958,12 @@ int32_t finalizeResultRowIntoResultDataBlock(SDiskbasedBuf* pBuf, SResultRowPosi
                                        SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo);
 
 int32_t createScanTableListInfo(SScanPhysiNode *pScanNode, SNodeList* pGroupTags, bool groupSort, SReadHandle* pHandle,
-                                STableListInfo* pTableListInfo, uint64_t queryId, uint64_t taskId);
+                                STableListInfo* pTableListInfo, SNode* pTagCond, SNode* pTagIndexCond, const char* idstr);
 
 SOperatorInfo* createGroupSortOperatorInfo(SOperatorInfo* downstream, SGroupSortPhysiNode* pSortPhyNode,
                                            SExecTaskInfo* pTaskInfo);
 SOperatorInfo* createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanNode, STableListInfo *pTableListInfo,
-                                                SReadHandle* readHandle, SExecTaskInfo* pTaskInfo, uint64_t queryId, uint64_t taskId);
+                                                SReadHandle* readHandle, SExecTaskInfo* pTaskInfo);
 
 void copyUpdateDataBlock(SSDataBlock* pDest, SSDataBlock* pSource, int32_t tsColIndex);
 

source/libs/executor/src/executil.c

@@ -265,7 +265,7 @@ EDealRes doTranslateTagExpr(SNode** pNode, void* pContext) {
   return DEAL_RES_CONTINUE;
 }
 
-static bool isTableOk(STableKeyInfo* info, SNode* pTagCond, SMeta* metaHandle) {
+int32_t isTableOk(STableKeyInfo* info, SNode* pTagCond, void* metaHandle, bool* pQualified) {
   SMetaReader mr = {0};
   metaReaderInit(&mr, metaHandle, 0);
   metaGetTableEntryByUid(&mr, info->uid);
@@ -280,19 +280,22 @@ static bool isTableOk(STableKeyInfo* info, SNode* pTagCond, SMeta* metaHandle) {
   if (TSDB_CODE_SUCCESS != code) {
     terrno = code;
     nodesDestroyNode(pTagCondTmp);
-    return false;
+    *pQualified = false;
+
+    return code;
   }
 
   ASSERT(nodeType(pNew) == QUERY_NODE_VALUE);
   SValueNode* pValue = (SValueNode*)pNew;
 
   ASSERT(pValue->node.resType.type == TSDB_DATA_TYPE_BOOL);
-  bool result = pValue->datum.b;
+  *pQualified = pValue->datum.b;
+
   nodesDestroyNode(pNew);
-  return result;
+  return TSDB_CODE_SUCCESS;
 }
 
-int32_t getTableList(void* metaHandle, void* pVnode, SScanPhysiNode* pScanNode, STableListInfo* pListInfo) {
+int32_t getTableList(void* metaHandle, void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, SNode* pTagIndexCond, STableListInfo* pListInfo) {
   int32_t code = TSDB_CODE_SUCCESS;
 
   pListInfo->pTableList = taosArrayInit(8, sizeof(STableKeyInfo));
@@ -304,8 +307,6 @@ int32_t getTableList(void* metaHandle, void* pVnode, SScanPhysiNode* pScanNode,
 
   pListInfo->suid = pScanNode->suid;
 
-  SNode* pTagCond = (SNode*)pListInfo->pTagCond;
-  SNode* pTagIndexCond = (SNode*)pListInfo->pTagIndexCond;
   if (pScanNode->tableType == TSDB_SUPER_TABLE) {
     if (pTagIndexCond) {
       SIndexMetaArg metaArg = {
@@ -345,9 +346,14 @@ int32_t getTableList(void* metaHandle, void* pVnode, SScanPhysiNode* pScanNode,
     int32_t i = 0;
     while (i < taosArrayGetSize(pListInfo->pTableList)) {
       STableKeyInfo* info = taosArrayGet(pListInfo->pTableList, i);
-      bool           isOk = isTableOk(info, pTagCond, metaHandle);
-      if (terrno) return terrno;
-      if (!isOk) {
+
+      bool qualified = true;
+      code = isTableOk(info, pTagCond, metaHandle, &qualified);
+      if (code != TSDB_CODE_SUCCESS) {
+        return code;
+      }
+
+      if (!qualified) {
         taosArrayRemove(pListInfo->pTableList, i);
         continue;
       }
@@ -362,7 +368,6 @@ int32_t getTableList(void* metaHandle, void* pVnode, SScanPhysiNode* pScanNode,
 
   // put into list as default group, remove it if grouping sorting is required later
   taosArrayPush(pListInfo->pGroupList, &pListInfo->pTableList);
-
   return code;
 }
 

source/libs/executor/src/executor.c

@@ -153,7 +153,7 @@ qTaskInfo_t qCreateStreamExecTaskInfo(void* msg, SReadHandle* readers) {
   return pTaskInfo;
 }
 
-static SArray* filterQualifiedChildTables(const SStreamScanInfo* pScanInfo, const SArray* tableIdList) {
+static SArray* filterQualifiedChildTables(const SStreamScanInfo* pScanInfo, const SArray* tableIdList, const char* idstr) {
   SArray* qa = taosArrayInit(4, sizeof(tb_uid_t));
 
   // let's discard the tables those are not created according to the queried super table.
@@ -164,7 +164,7 @@ static SArray* filterQualifiedChildTables(const SStreamScanInfo* pScanInfo, cons
 
     int32_t code = metaGetTableEntryByUid(&mr, *id);
     if (code != TSDB_CODE_SUCCESS) {
-      qError("failed to get table meta, uid:%" PRIu64 " code:%s", *id, tstrerror(terrno));
+      qError("failed to get table meta, uid:%" PRIu64 " code:%s, %s", *id, tstrerror(terrno), idstr);
       continue;
     }
 
@@ -172,6 +172,21 @@ static SArray* filterQualifiedChildTables(const SStreamScanInfo* pScanInfo, cons
     if (mr.me.type != TSDB_CHILD_TABLE || mr.me.ctbEntry.suid != pScanInfo->tableUid) {
       continue;
     }
+
+    if (pScanInfo->pTagCond != NULL) {
+      bool          qualified = false;
+      STableKeyInfo info = {.groupId = 0, .uid = mr.me.uid, .lastKey = 0};
+      code = isTableOk(&info, pScanInfo->pTagCond, pScanInfo->readHandle.meta, &qualified);
+      if (code != TSDB_CODE_SUCCESS) {
+        qError("failed to filter new table, uid:0x%" PRIx64 ", %s", info.uid, idstr);
+        continue;
+      }
+
+      if (!qualified) {
+        continue;
+      }
+    }
+
     /*pScanInfo->pStreamScanOp->pTaskInfo->tableqinfoList.*/
     // handle multiple partition
 
@@ -194,7 +209,7 @@ int32_t qUpdateQualifiedTableId(qTaskInfo_t tinfo, const SArray* tableIdList, bo
   int32_t          code = 0;
   SStreamScanInfo* pScanInfo = pInfo->info;
   if (isAdd) {  // add new table id
-    SArray* qa = filterQualifiedChildTables(pScanInfo, tableIdList);
+    SArray* qa = filterQualifiedChildTables(pScanInfo, tableIdList, GET_TASKID(pTaskInfo));
 
     qDebug(" %d qualified child tables added into stream scanner", (int32_t)taosArrayGetSize(qa));
     code = tqReaderAddTbUidList(pScanInfo->tqReader, qa);

source/libs/executor/src/executorimpl.c

@@ -13,7 +13,6 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <executorimpl.h>
 #include "filter.h"
 #include "function.h"
 #include "functionMgt.h"
@@ -4369,8 +4368,7 @@ static int32_t initTableblockDistQueryCond(uint64_t uid, SQueryTableDataCond* pC
 }
 
 SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle,
-                                  uint64_t queryId, uint64_t taskId, STableListInfo* pTableListInfo,
-                                  const char* pUser) {
+                                  STableListInfo* pTableListInfo, SNode* pTagCond, SNode* pTagIndexCond, const char* pUser) {
   int32_t type = nodeType(pPhyNode);
 
   if (pPhyNode->pChildren == NULL || LIST_LENGTH(pPhyNode->pChildren) == 0) {
@@ -4378,7 +4376,7 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
       STableScanPhysiNode* pTableScanNode = (STableScanPhysiNode*)pPhyNode;
 
       int32_t code = createScanTableListInfo(&pTableScanNode->scan, pTableScanNode->pGroupTags,
-                                             pTableScanNode->groupSort, pHandle, pTableListInfo, queryId, taskId);
+                                             pTableScanNode->groupSort, pHandle, pTableListInfo, pTagCond, pTagIndexCond, GET_TASKID(pTaskInfo));
       if (code) {
         pTaskInfo->code = code;
         return NULL;
@@ -4398,7 +4396,7 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
     } else if (QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN == type) {
       STableMergeScanPhysiNode* pTableScanNode = (STableMergeScanPhysiNode*)pPhyNode;
       int32_t code = createScanTableListInfo(&pTableScanNode->scan, pTableScanNode->pGroupTags,
-                                             pTableScanNode->groupSort, pHandle, pTableListInfo, queryId, taskId);
+                                             pTableScanNode->groupSort, pHandle, pTableListInfo, pTagCond, pTagIndexCond, GET_TASKID(pTaskInfo));
       if (code) {
         pTaskInfo->code = code;
         return NULL;
@@ -4411,7 +4409,7 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
       }
 
       SOperatorInfo* pOperator =
-          createTableMergeScanOperatorInfo(pTableScanNode, pTableListInfo, pHandle, pTaskInfo, queryId, taskId);
+          createTableMergeScanOperatorInfo(pTableScanNode, pTableListInfo, pHandle, pTaskInfo);
 
       STableScanInfo* pScanInfo = pOperator->info;
       pTaskInfo->cost.pRecoder = &pScanInfo->readRecorder;
@@ -4428,15 +4426,14 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
       };
       if (pHandle) {
         int32_t code = createScanTableListInfo(&pTableScanNode->scan, pTableScanNode->pGroupTags,
-                                               pTableScanNode->groupSort, pHandle, pTableListInfo, queryId, taskId);
+                                               pTableScanNode->groupSort, pHandle, pTableListInfo, pTagCond, pTagIndexCond, GET_TASKID(pTaskInfo));
         if (code) {
           pTaskInfo->code = code;
           return NULL;
         }
       }
 
-      SOperatorInfo* pOperator =
-          createStreamScanOperatorInfo(pHandle, pTableScanNode, pTaskInfo, &twSup, queryId, taskId);
+      SOperatorInfo* pOperator = createStreamScanOperatorInfo(pHandle, pTableScanNode, pTagCond, pTaskInfo, &twSup);
       return pOperator;
 
     } else if (QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN == type) {
@@ -4445,7 +4442,7 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
     } else if (QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN == type) {
       STagScanPhysiNode* pScanPhyNode = (STagScanPhysiNode*)pPhyNode;
 
-      int32_t code = getTableList(pHandle->meta, pHandle->vnode, pScanPhyNode, pTableListInfo);
+      int32_t code = getTableList(pHandle->meta, pHandle->vnode, pScanPhyNode, pTagCond, pTagIndexCond, pTableListInfo);
       if (code != TSDB_CODE_SUCCESS) {
         pTaskInfo->code = terrno;
         return NULL;
@@ -4481,8 +4478,7 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
     } else if (QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN == type) {
       SLastRowScanPhysiNode* pScanNode = (SLastRowScanPhysiNode*)pPhyNode;
 
-      int32_t code = createScanTableListInfo(&pScanNode->scan, pScanNode->pGroupTags, true, pHandle, pTableListInfo,
-                                             queryId, taskId);
+      int32_t code = createScanTableListInfo(&pScanNode->scan, pScanNode->pGroupTags, true, pHandle, pTableListInfo, pTagCond, pTagIndexCond, GET_TASKID(pTaskInfo));
       if (code != TSDB_CODE_SUCCESS) {
         pTaskInfo->code = code;
         return NULL;
@@ -4506,7 +4502,7 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
   SOperatorInfo** ops = taosMemoryCalloc(size, POINTER_BYTES);
   for (int32_t i = 0; i < size; ++i) {
     SPhysiNode* pChildNode = (SPhysiNode*)nodesListGetNode(pPhyNode->pChildren, i);
-    ops[i] = createOperatorTree(pChildNode, pTaskInfo, pHandle, queryId, taskId, pTableListInfo, pUser);
+    ops[i] = createOperatorTree(pChildNode, pTaskInfo, pHandle, pTableListInfo, pTagCond, pTagIndexCond, pUser);
     if (ops[i] == NULL) {
       return NULL;
     }
@@ -4689,6 +4685,7 @@ SArray* extractColumnInfo(SNodeList* pNodeList) {
   return pList;
 }
 
+#if 0
 STsdbReader* doCreateDataReader(STableScanPhysiNode* pTableScanNode, SReadHandle* pHandle,
                                 STableListInfo* pTableListInfo, const char* idstr) {
   int32_t code = getTableList(pHandle->meta, pHandle->vnode, &pTableScanNode->scan, pTableListInfo);
@@ -4722,6 +4719,7 @@ _error:
   terrno = code;
   return NULL;
 }
+#endif
 
 static int32_t extractTbscanInStreamOpTree(SOperatorInfo* pOperator, STableScanInfo** ppInfo) {
   if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN) {
@@ -4765,6 +4763,7 @@ int32_t extractTableScanNode(SPhysiNode* pNode, STableScanPhysiNode** ppNode) {
   return -1;
 }
 
+#if 0
 int32_t rebuildReader(SOperatorInfo* pOperator, SSubplan* plan, SReadHandle* pHandle, int64_t uid, int64_t ts) {
   STableScanInfo* pTableScanInfo = NULL;
   if (extractTbscanInStreamOpTree(pOperator, &pTableScanInfo) < 0) {
@@ -4788,6 +4787,7 @@ int32_t rebuildReader(SOperatorInfo* pOperator, SSubplan* plan, SReadHandle* pHa
   // TODO: set uid and ts to data reader
   return 0;
 }
+#endif
 
 int32_t encodeOperator(SOperatorInfo* ops, char** result, int32_t* length, int32_t* nOptrWithVal) {
   int32_t code = TDB_CODE_SUCCESS;
@@ -4939,10 +4939,7 @@ int32_t createExecTaskInfoImpl(SSubplan* pPlan, SExecTaskInfo** pTaskInfo, SRead
   }
 
   (*pTaskInfo)->sql = sql;
-  (*pTaskInfo)->tableqinfoList.pTagCond = pPlan->pTagCond;
-  (*pTaskInfo)->tableqinfoList.pTagIndexCond = pPlan->pTagIndexCond;
-  (*pTaskInfo)->pRoot = createOperatorTree(pPlan->pNode, *pTaskInfo, pHandle, queryId, taskId,
-                                           &(*pTaskInfo)->tableqinfoList, pPlan->user);
+  (*pTaskInfo)->pRoot = createOperatorTree(pPlan->pNode, *pTaskInfo, pHandle, &(*pTaskInfo)->tableqinfoList, pPlan->pTagCond, pPlan->pTagIndexCond, pPlan->user);
 
   if (NULL == (*pTaskInfo)->pRoot) {
     code = (*pTaskInfo)->code;

source/libs/executor/src/scanoperator.c

@@ -1497,9 +1497,8 @@ static void destroyStreamScanOperatorInfo(void* param, int32_t numOfOutput) {
   taosMemoryFree(pStreamScan);
 }
 
-SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode* pTableScanNode,
-                                            SExecTaskInfo* pTaskInfo, STimeWindowAggSupp* pTwSup, uint64_t queryId,
-                                            uint64_t taskId) {
+SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode* pTableScanNode, SNode* pTagCond,
+                                            SExecTaskInfo* pTaskInfo, STimeWindowAggSupp* pTwSup) {
   SStreamScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamScanInfo));
   SOperatorInfo*   pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
 
@@ -1512,6 +1511,8 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys
 
   SDataBlockDescNode* pDescNode = pScanPhyNode->node.pOutputDataBlockDesc;
 
+  pInfo->pTagCond = pTagCond;
+
   int32_t numOfCols = 0;
   pInfo->pColMatchInfo = extractColMatchInfo(pScanPhyNode->pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID);
 
@@ -2550,26 +2551,19 @@ typedef struct STableMergeScanInfo {
   int32_t         tableEndIndex;
   bool            hasGroupId;
   uint64_t        groupId;
+  SArray*         dataReaders;  // array of tsdbReaderT*
+  SReadHandle     readHandle;
+  int32_t         bufPageSize;
+  uint32_t        sortBufSize;  // max buffer size for in-memory sort
+  SArray*         pSortInfo;
+  SSortHandle*    pSortHandle;
 
-  SArray*     dataReaders;  // array of tsdbReaderT*
-  SReadHandle readHandle;
-
-  int32_t  bufPageSize;
-  uint32_t sortBufSize;  // max buffer size for in-memory sort
-
-  SArray*      pSortInfo;
-  SSortHandle* pSortHandle;
-
-  SSDataBlock* pSortInputBlock;
-  int64_t      startTs;  // sort start time
-
-  SArray*  sortSourceParams;
-  uint64_t queryId;
-  uint64_t taskId;
+  SSDataBlock*    pSortInputBlock;
+  int64_t         startTs;  // sort start time
+  SArray*         sortSourceParams;
 
   SFileBlockLoadRecorder readRecorder;
-  int64_t                numOfRows;
-  //  int32_t         prevGroupId;  // previous table group id
+  int64_t         numOfRows;
   SScanInfo       scanInfo;
   int32_t         scanTimes;
   SNode*          pFilterNode;  // filter info, which is push down by optimizer
@@ -2584,26 +2578,25 @@ typedef struct STableMergeScanInfo {
   SExprInfo*      pPseudoExpr;
   int32_t         numOfPseudoExpr;
   SqlFunctionCtx* pPseudoCtx;
-  //  int32_t*        rowEntryInfoOffset;
 
   SQueryTableDataCond cond;
-  int32_t             scanFlag;  // table scan flag to denote if it is a repeat/reverse/main scan
-  int32_t             dataBlockLoadFlag;
-  SInterval interval;  // if the upstream is an interval operator, the interval info is also kept here to get the time
-                       // window to check if current data block needs to be loaded.
-
+  int32_t         scanFlag;  // table scan flag to denote if it is a repeat/reverse/main scan
+  int32_t         dataBlockLoadFlag;
+  // if the upstream is an interval operator, the interval info is also kept here to get the time
+  // window to check if current data block needs to be loaded.
+  SInterval       interval;
   SSampleExecInfo sample;  // sample execution info
 } STableMergeScanInfo;
 
 int32_t createScanTableListInfo(SScanPhysiNode* pScanNode, SNodeList* pGroupTags, bool groupSort, SReadHandle* pHandle,
-                                STableListInfo* pTableListInfo, uint64_t queryId, uint64_t taskId) {
-  int32_t code = getTableList(pHandle->meta, pHandle->vnode, pScanNode, pTableListInfo);
+                                STableListInfo* pTableListInfo, SNode* pTagCond, SNode* pTagIndexCond, const char* idStr) {
+  int32_t code = getTableList(pHandle->meta, pHandle->vnode, pScanNode, pTagCond, pTagIndexCond, pTableListInfo);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
 
   if (taosArrayGetSize(pTableListInfo->pTableList) == 0) {
-    qDebug("no table qualified for query, TID:0x%" PRIx64 ", QID:0x%" PRIx64, taskId, queryId);
+    qDebug("no table qualified for query, %s" PRIx64, idStr);
     return TSDB_CODE_SUCCESS;
   }
 
@@ -3027,8 +3020,7 @@ int32_t compareTableKeyInfoByGid(const void* p1, const void* p2) {
 }
 
 SOperatorInfo* createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanNode, STableListInfo* pTableListInfo,
-                                                SReadHandle* readHandle, SExecTaskInfo* pTaskInfo, uint64_t queryId,
-                                                uint64_t taskId) {
+                                                SReadHandle* readHandle, SExecTaskInfo* pTaskInfo) {
   STableMergeScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableMergeScanInfo));
   SOperatorInfo*       pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
   if (pInfo == NULL || pOperator == NULL) {
@@ -3067,9 +3059,6 @@ SOperatorInfo* createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanN
 
   pInfo->pResBlock = createResDataBlock(pDescNode);
   pInfo->dataReaders = taosArrayInit(64, POINTER_BYTES);
-  pInfo->queryId = queryId;
-  pInfo->taskId = taskId;
-
   pInfo->sortSourceParams = taosArrayInit(64, sizeof(STableMergeScanSortSourceParam));
 
   pInfo->pSortInfo = generateSortByTsInfo(pInfo->pColMatchInfo, pInfo->cond.order);

source/libs/function/src/builtins.c

@@ -2086,6 +2086,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .getEnvFunc   = getTopBotFuncEnv,
     .initFunc     = topBotFunctionSetup,
     .processFunc  = topFunction,
+    .sprocessFunc = topBotScalarFunction,
     .finalizeFunc = topBotFinalize,
     .combineFunc  = topCombine,
     .pPartialFunc = "top",
@@ -2100,6 +2101,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .getEnvFunc   = getTopBotFuncEnv,
     .initFunc     = topBotFunctionSetup,
     .processFunc  = bottomFunction,
+    .sprocessFunc = topBotScalarFunction,
     .finalizeFunc = topBotFinalize,
     .combineFunc  = bottomCombine,
     .pPartialFunc = "bottom",
@@ -2229,6 +2231,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .getEnvFunc   = getFirstLastFuncEnv,
     .initFunc     = functionSetup,
     .processFunc  = lastRowFunction,
+    .sprocessFunc = firstLastScalarFunction,
     .finalizeFunc = firstLastFinalize
   },
   {
@@ -2249,6 +2252,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .getEnvFunc   = getFirstLastFuncEnv,
     .initFunc     = functionSetup,
     .processFunc  = firstFunction,
+    .sprocessFunc = firstLastScalarFunction,
     .finalizeFunc = firstLastFinalize,
     .pPartialFunc = "_first_partial",
     .pMergeFunc   = "_first_merge",
@@ -2284,6 +2288,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .getEnvFunc   = getFirstLastFuncEnv,
     .initFunc     = functionSetup,
     .processFunc  = lastFunction,
+    .sprocessFunc = firstLastScalarFunction,
     .finalizeFunc = firstLastFinalize,
     .pPartialFunc = "_last_partial",
     .pMergeFunc   = "_last_merge",
@@ -2464,6 +2469,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .getEnvFunc   = getSampleFuncEnv,
     .initFunc     = sampleFunctionSetup,
     .processFunc  = sampleFunction,
+    .sprocessFunc = sampleScalarFunction,
     .finalizeFunc = sampleFinalize
   },
   {
@@ -2475,6 +2481,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .getEnvFunc   = getTailFuncEnv,
     .initFunc     = tailFunctionSetup,
     .processFunc  = tailFunction,
+    .sprocessFunc = tailScalarFunction,
     .finalizeFunc = NULL
   },
   {
@@ -2486,6 +2493,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .getEnvFunc   = getUniqueFuncEnv,
     .initFunc     = uniqueFunctionSetup,
     .processFunc  = uniqueFunction,
+    .sprocessFunc = uniqueScalarFunction,
     .finalizeFunc = NULL
   },
   {
@@ -2496,6 +2504,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .getEnvFunc   = getModeFuncEnv,
     .initFunc     = modeFunctionSetup,
     .processFunc  = modeFunction,
+    .sprocessFunc = modeScalarFunction,
     .finalizeFunc = modeFinalize,
   },
   {

source/libs/planner/src/planPhysiCreater.c

@@ -255,7 +255,7 @@ static int32_t addDataBlockSlot(SPhysiPlanContext* pCxt, SNode** pNode, SDataBlo
 
 static int32_t addDataBlockSlotsForProject(SPhysiPlanContext* pCxt, const char* pStmtName, SNodeList* pList,
                                            SDataBlockDescNode* pDataBlockDesc) {
-  return addDataBlockSlotsImpl(pCxt, pList, pDataBlockDesc, pStmtName, true, false);
+  return addDataBlockSlotsImpl(pCxt, pList, pDataBlockDesc, pStmtName, false, false);
 }
 
 static int32_t pushdownDataBlockSlots(SPhysiPlanContext* pCxt, SNodeList* pList, SDataBlockDescNode* pDataBlockDesc) {

source/libs/scalar/src/sclfunc.c

@@ -2816,3 +2816,48 @@ int32_t histogramScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarP
   pOutput->numOfRows = numOfBins;
   return TSDB_CODE_SUCCESS;
 }
+
+int32_t selectScalarFunction(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, 0);
+      continue;
+    }
+
+    char* data = colDataGetData(pInputData, i);
+    colDataAppend(pOutputData, i, data, false);
+  }
+
+
+  pOutput->numOfRows = 1;
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t topBotScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
+  return selectScalarFunction(pInput, inputNum, pOutput);
+}
+
+int32_t firstLastScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
+  return selectScalarFunction(pInput, inputNum, pOutput);
+}
+
+int32_t sampleScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
+  return selectScalarFunction(pInput, inputNum, pOutput);
+}
+
+int32_t tailScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
+  return selectScalarFunction(pInput, inputNum, pOutput);
+}
+
+int32_t uniqueScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
+  return selectScalarFunction(pInput, inputNum, pOutput);
+}
+
+int32_t modeScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
+  return selectScalarFunction(pInput, inputNum, pOutput);
+}

source/libs/stream/src/streamExec.c

@@ -143,76 +143,80 @@ int32_t streamPipelineExec(SStreamTask* pTask, int32_t batchNum) {
 }
 
 static SArray* streamExecForQall(SStreamTask* pTask, SArray* pRes) {
-  int32_t cnt = 0;
-  void*   data = NULL;
   while (1) {
-    SStreamQueueItem* qItem = streamQueueNextItem(pTask->inputQueue);
-    if (qItem == NULL) {
-      qDebug("stream exec over, queue empty");
-      break;
-    }
-    if (data == NULL) {
-      data = qItem;
-      if (qItem->type == STREAM_INPUT__DATA_BLOCK) {
-        /*streamUpdateVer(pTask, (SStreamDataBlock*)qItem);*/
-      }
-      streamQueueProcessSuccess(pTask->inputQueue);
-    } else {
-      if (streamAppendQueueItem(data, qItem) < 0) {
-        streamQueueProcessFail(pTask->inputQueue);
+    int32_t cnt = 0;
+    void*   data = NULL;
+    while (1) {
+      SStreamQueueItem* qItem = streamQueueNextItem(pTask->inputQueue);
+      if (qItem == NULL) {
+        qDebug("stream exec over, queue empty");
         break;
-      } else {
-        cnt++;
-        /*streamUpdateVer(pTask, (SStreamDataBlock*)qItem);*/
+      }
+      if (data == NULL) {
+        data = qItem;
         streamQueueProcessSuccess(pTask->inputQueue);
-        taosArrayDestroy(((SStreamDataBlock*)qItem)->blocks);
-        taosFreeQitem(qItem);
+        if (qItem->type == STREAM_INPUT__DATA_BLOCK) {
+          /*streamUpdateVer(pTask, (SStreamDataBlock*)qItem);*/
+        } else {
+          break;
+        }
+      } else {
+        if (streamAppendQueueItem(data, qItem) < 0) {
+          streamQueueProcessFail(pTask->inputQueue);
+          break;
+        } else {
+          cnt++;
+          /*streamUpdateVer(pTask, (SStreamDataBlock*)qItem);*/
+          streamQueueProcessSuccess(pTask->inputQueue);
+          taosArrayDestroy(((SStreamDataBlock*)qItem)->blocks);
+          taosFreeQitem(qItem);
+        }
       }
     }
-  }
-  if (pTask->taskStatus == TASK_STATUS__DROPPING) {
-    if (data) streamFreeQitem(data);
-    taosArrayDestroyEx(pRes, (FDelete)blockDataFreeRes);
-    return NULL;
-  }
+    if (pTask->taskStatus == TASK_STATUS__DROPPING) {
+      if (data) streamFreeQitem(data);
+      taosArrayDestroyEx(pRes, (FDelete)blockDataFreeRes);
+      return NULL;
+    }
 
-  if (data == NULL) return pRes;
+    if (data == NULL) break;
 
-  if (pTask->execType == TASK_EXEC__NONE) {
-    ASSERT(((SStreamQueueItem*)data)->type == STREAM_INPUT__DATA_BLOCK);
-    streamTaskOutput(pTask, data);
-    return pRes;
-  }
+    if (pTask->execType == TASK_EXEC__NONE) {
+      ASSERT(((SStreamQueueItem*)data)->type == STREAM_INPUT__DATA_BLOCK);
+      streamTaskOutput(pTask, data);
+      return pRes;
+    }
 
-  qDebug("stream task %d exec begin, msg batch: %d", pTask->taskId, cnt);
-  streamTaskExecImpl(pTask, data, pRes);
-  qDebug("stream task %d exec end", pTask->taskId);
+    qDebug("stream task %d exec begin, msg batch: %d", pTask->taskId, cnt);
+    streamTaskExecImpl(pTask, data, pRes);
+    qDebug("stream task %d exec end", pTask->taskId);
 
-  if (taosArrayGetSize(pRes) != 0) {
-    SStreamDataBlock* qRes = taosAllocateQitem(sizeof(SStreamDataBlock), DEF_QITEM);
-    if (qRes == NULL) {
-      streamQueueProcessFail(pTask->inputQueue);
-      taosArrayDestroy(pRes);
-      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;
-    }
-    if (((SStreamQueueItem*)data)->type == STREAM_INPUT__DATA_SUBMIT) {
-      SStreamDataSubmit* pSubmit = (SStreamDataSubmit*)data;
-      qRes->childId = pTask->selfChildId;
-      qRes->sourceVer = pSubmit->ver;
+    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;
+      qRes->blocks = pRes;
+      if (streamTaskOutput(pTask, qRes) < 0) {
+        /*streamQueueProcessFail(pTask->inputQueue);*/
+        taosArrayDestroyEx(pRes, (FDelete)blockDataFreeRes);
+        taosFreeQitem(qRes);
+        return NULL;
+      }
+      if (((SStreamQueueItem*)data)->type == STREAM_INPUT__DATA_SUBMIT) {
+        SStreamDataSubmit* pSubmit = (SStreamDataSubmit*)data;
+        qRes->childId = pTask->selfChildId;
+        qRes->sourceVer = pSubmit->ver;
+      }
+      /*streamQueueProcessSuccess(pTask->inputQueue);*/
+      pRes = taosArrayInit(0, sizeof(SSDataBlock));
     }
-    /*streamQueueProcessSuccess(pTask->inputQueue);*/
-    pRes = taosArrayInit(0, sizeof(SSDataBlock));
-  }
 
-  streamFreeQitem(data);
+    streamFreeQitem(data);
+  }
   return pRes;
 }
 

source/libs/wal/src/walRead.c

@@ -483,6 +483,7 @@ int32_t walReadVer(SWalReader *pRead, int64_t ver) {
            pRead->pHead->head.version, ver);
     pRead->curInvalid = 1;
     terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
+    ASSERT(0);
     return -1;
   }
 
@@ -491,6 +492,7 @@ int32_t walReadVer(SWalReader *pRead, int64_t ver) {
     wError("vgId:%d, unexpected wal log index:%" PRId64 ", since body checksum not passed", pRead->pWal->cfg.vgId, ver);
     pRead->curInvalid = 1;
     terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
+    ASSERT(0);
     return -1;
   }
   pRead->curVersion++;

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

@@ -22,15 +22,16 @@ class TDTestCase:
         self.ts = 1434938400000
         self.time_step = 1000
 
-    def insert_datas_and_check_abs(self ,tbnums , rownums , time_step ):
+    def insert_datas_and_check_abs(self ,tbnums , rownums , time_step ,cache_value ):
+        tdSql.execute("drop database if exists test ")
         tdLog.info(" prepare datas for auto check abs function ")
 
-        tdSql.execute(" create database test cachemodel 'last_row' ")
+        tdSql.execute(f" create database test cachemodel {cache_value} ")
         tdSql.execute(" use test ")
-        tdSql.execute(" create stable stb (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint,\
+        tdSql.execute(" create stable test.stb (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint,\
              c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp) tags (t1 int)")
         for tbnum in range(tbnums):
-            tbname = "sub_tb_%d"%tbnum
+            tbname = "test.sub_tb_%d"%tbnum
             tdSql.execute(" create table %s using stb tags(%d) "%(tbname , tbnum))
 
             ts = self.ts
@@ -56,17 +57,19 @@ class TDTestCase:
             coltypes = tdSql.queryResult
             for coltype in coltypes:
                 colname = coltype[0]
-                abs_sql = "select abs({}) from {} order by tbname ".format(colname, tbname)
-                origin_sql = "select {} from {} order by tbname".format(colname, tbname)
+                abs_sql = "select abs({}) from {} order by tbname ".format(colname, 'test.'+tbname)
+                origin_sql = "select {} from {} order by tbname".format(colname, 'test.'+tbname)
                 if coltype[1] in support_types:
                     self.check_result_auto(origin_sql , abs_sql)
                     
+    def prepare_datas(self ,cache_value):
+        tdSql.execute("drop database if exists db ")
+        create_db_sql = f"create database if not exists db keep 3650 duration 1000 cachemodel {cache_value}"
+        tdSql.execute(create_db_sql)
 
-    def prepare_datas(self):
-        tdSql.execute("create database if not exists db keep 3650 duration 1000 cachemodel 'last_row'")
         tdSql.execute("use db")
         tdSql.execute(
-            '''create table stb1
+            '''create table db.stb1
             (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp)
             tags (t1 int)
             '''
@@ -74,38 +77,38 @@ class TDTestCase:
 
         tdSql.execute(
             '''
-            create table t1
+            create table db.t1
             (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp)
             '''
         )
         for i in range(4):
-            tdSql.execute(f'create table ct{i+1} using stb1 tags ( {i+1} )')
+            tdSql.execute(f'create table db.ct{i+1} using stb1 tags ( {i+1} )')
 
         for i in range(9):
             tdSql.execute(
-                f"insert into ct1 values ( now()-{i*10}s, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a )"
+                f"insert into db.ct1 values ( now()-{i*10}s, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a )"
             )
             tdSql.execute(
-                f"insert into ct4 values ( now()-{i*90}d, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a )"
+                f"insert into db.ct4 values ( now()-{i*90}d, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a )"
             )
         tdSql.execute(
-            "insert into ct1 values (now()-45s, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar0', now()+8a )")
+            "insert into db.ct1 values (now()-45s, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar0', now()+8a )")
         tdSql.execute(
-            "insert into ct1 values (now()+10s, 9, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a )")
+            "insert into db.ct1 values (now()+10s, 9, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a )")
         tdSql.execute(
-            "insert into ct1 values (now()+15s, 9, -99999, -999, -99, -9.99, NULL, 1, 'binary9', 'nchar9', now()+9a )")
+            "insert into db.ct1 values (now()+15s, 9, -99999, -999, -99, -9.99, NULL, 1, 'binary9', 'nchar9', now()+9a )")
         tdSql.execute(
-            "insert into ct1 values (now()+20s, 9, -99999, -999, NULL, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a )")
+            "insert into db.ct1 values (now()+20s, 9, -99999, -999, NULL, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a )")
 
         tdSql.execute(
-            "insert into ct4 values (now()-810d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ")
+            "insert into db.ct4 values (now()-810d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ")
         tdSql.execute(
-            "insert into ct4 values (now()-400d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ")
+            "insert into db.ct4 values (now()-400d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ")
         tdSql.execute(
-            "insert into ct4 values (now()+90d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL  ) ")
+            "insert into db.ct4 values (now()+90d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL  ) ")
 
         tdSql.execute(
-            f'''insert into t1 values
+            f'''insert into db.t1 values
             ( '2020-04-21 01:01:01.000', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
             ( '2020-10-21 01:01:01.000', 1, 11111, 111, 11, 1.11, 11.11, 1, "binary1", "nchar1", now()+1a )
             ( '2020-12-31 01:01:01.000', 2, 22222, 222, 22, 2.22, 22.22, 0, "binary2", "nchar2", now()+2a )
@@ -121,51 +124,53 @@ class TDTestCase:
             '''
         )
 
-    def prepare_tag_datas(self):
+    def prepare_tag_datas(self,cache_value):
+
+        tdSql.execute("drop database if exists testdb ")
         # prepare datas
-        tdSql.execute(
-            "create database if not exists testdb keep 3650 duration 1000 cachemodel 'last_row'")
+        tdSql.execute(f"create database if not exists testdb keep 3650 duration 1000 cachemodel {cache_value}")
+
         tdSql.execute(" use testdb ")
 
-        tdSql.execute(f" create stable stb1 (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp , uc1 int unsigned,\
+        tdSql.execute(f" create stable testdb.stb1 (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp , uc1 int unsigned,\
              uc2 bigint unsigned ,uc3 smallint unsigned , uc4 tinyint unsigned ) tags( t1 int , t2 bigint , t3 smallint , t4 tinyint , t5 float , t6 double , t7 bool , t8 binary(36)\
                  , t9 nchar(36) , t10 int unsigned , t11 bigint unsigned ,t12 smallint unsigned , t13 tinyint unsigned ,t14 timestamp  ) ")
 
         tdSql.execute(
             '''
-            create table t1
+            create table testdb.t1
             (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp)
             '''
         )
         for i in range(4):
             tdSql.execute(
-                f'create table ct{i+1} using stb1 tags ( {1*i}, {11111*i}, {111*i}, {1*i}, {1.11*i}, {11.11*i}, {i%2}, "binary{i}", "nchar{i}" ,{111*i}, {1*i},{1*i},{1*i},now())')
+                f'create table testdb.ct{i+1} using stb1 tags ( {1*i}, {11111*i}, {111*i}, {1*i}, {1.11*i}, {11.11*i}, {i%2}, "binary{i}", "nchar{i}" ,{111*i}, {1*i},{1*i},{1*i},now())')
 
         for i in range(9):
             tdSql.execute(
-                f"insert into ct1 values ( now()-{i*10}s, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a ,{111*i},{1111*i},{i},{i} )"
+                f"insert into testdb.ct1 values ( now()-{i*10}s, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a ,{111*i},{1111*i},{i},{i} )"
             )
             tdSql.execute(
-                f"insert into ct4 values ( now()-{i*90}d, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a ,{111*i},{1111*i},{i},{i})"
+                f"insert into testdb.ct4 values ( now()-{i*90}d, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a ,{111*i},{1111*i},{i},{i})"
             )
         tdSql.execute(
-            "insert into ct1 values (now()-45s, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar0', now()+8a ,0,0,0,0)")
+            "insert into testdb.ct1 values (now()-45s, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar0', now()+8a ,0,0,0,0)")
         tdSql.execute(
-            "insert into ct1 values (now()+10s, 9, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a , 999 , 9999 , 9 , 9)")
+            "insert into testdb.ct1 values (now()+10s, 9, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a , 999 , 9999 , 9 , 9)")
         tdSql.execute(
-            "insert into ct1 values (now()+15s, 9, -99999, -999, -99, -9.99, NULL, 1, 'binary9', 'nchar9', now()+9a , 999 , 99999 , 9 , 9)")
+            "insert into testdb.ct1 values (now()+15s, 9, -99999, -999, -99, -9.99, NULL, 1, 'binary9', 'nchar9', now()+9a , 999 , 99999 , 9 , 9)")
         tdSql.execute(
-            "insert into ct1 values (now()+20s, 9, -99999, -999, NULL, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a ,999 , 99999 , 9 , 9)")
+            "insert into testdb.ct1 values (now()+20s, 9, -99999, -999, NULL, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a ,999 , 99999 , 9 , 9)")
 
         tdSql.execute(
-            "insert into ct4 values (now()-810d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL , NULL, NULL, NULL, NULL) ")
+            "insert into testdb.ct4 values (now()-810d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL , NULL, NULL, NULL, NULL) ")
         tdSql.execute(
-            "insert into ct4 values (now()-400d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL , NULL, NULL, NULL, NULL) ")
+            "insert into testdb.ct4 values (now()-400d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL , NULL, NULL, NULL, NULL) ")
         tdSql.execute(
-            "insert into ct4 values (now()+90d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL , NULL, NULL, NULL, NULL ) ")
+            "insert into testdb.ct4 values (now()+90d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL , NULL, NULL, NULL, NULL ) ")
 
         tdSql.execute(
-            f'''insert into t1 values
+            f'''insert into testdb.t1 values
             ( '2020-04-21 01:01:01.000', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
             ( '2020-10-21 01:01:01.000', 1, 11111, 111, 11, 1.11, 11.11, 1, "binary1", "nchar1", now()+1a )
             ( '2020-12-31 01:01:01.000', 2, 22222, 222, 22, 2.22, 22.22, 0, "binary2", "nchar2", now()+2a )
@@ -216,36 +221,24 @@ class TDTestCase:
         tdSql.execute("use testdb")
 
         # bug need fix 
-        # tdSql.query("select last_row(c1 ,NULL) from t1")
+        tdSql.error("select last_row(c1 ,NULL) from testdb.t1")
 
         error_sql_lists = [
-            "select last_row from t1",
-            "select last_row(-+--+c1) from t1",
-            # "select +-last_row(c1) from t1",
-            # "select ++-last_row(c1) from t1",
-            # "select ++--last_row(c1) from t1",
-            # "select - -last_row(c1)*0 from t1",
-            # "select last_row(tbname+1) from t1 ",
-            "select last_row(123--123)==1 from t1",
-            "select last_row(c1) as 'd1' from t1",
-            "select last_row(c1 ,NULL) from t1",
-            "select last_row(,) from t1;",
-            "select last_row(abs(c1) ab from t1)",
-            "select last_row(c1) as int from t1",
-            "select last_row from stb1",
-            # "select last_row(-+--+c1) from stb1",
-            # "select +-last_row(c1) from stb1",
-            # "select ++-last_row(c1) from stb1",
-            # "select ++--last_row(c1) from stb1",
-            # "select - -last_row(c1)*0 from stb1",
-            # "select last_row(tbname+1) from stb1 ",
-            "select last_row(123--123)==1 from stb1",
-            "select last_row(c1) as 'd1' from stb1",
-            # "select last_row(c1 ,c2 ) from stb1",
-            "select last_row(c1 ,NULL) from stb1",
-            "select last_row(,) from stb1;",
-            "select last_row(abs(c1) ab from stb1)",
-            "select last_row(c1) as int from stb1"
+            "select last_row from testdb.t1",
+            "select last_row(-+--+c1) from testdb.t1",
+            "select last_row(123--123)==1 from testdb.t1",
+            "select last_row(c1) as 'd1' from testdb.t1",
+            "select last_row(c1 ,NULL) from testdb.t1",
+            "select last_row(,) from testdb.t1;",
+            "select last_row(abs(c1) ab from testdb.t1)",
+            "select last_row(c1) as int from testdb.t1",
+            "select last_row from testdb.stb1",
+            "select last_row(123--123)==1 from testdb.stb1",
+            "select last_row(c1) as 'd1' from testdb.stb1",
+            "select last_row(c1 ,NULL) from testdb.stb1",
+            "select last_row(,) from testdb.stb1;",
+            "select last_row(abs(c1) ab from testdb.stb1)",
+            "select last_row(c1) as int from testdb.stb1"
         ]
         for error_sql in error_sql_lists:
             tdSql.error(error_sql)
@@ -261,51 +254,51 @@ class TDTestCase:
                 colname = coltype[0]
                 col_note = coltype[-1]
                 if col_note != "TAG":
-                    abs_sql = "select last_row({}) from {}".format(colname, tbname)
+                    abs_sql = "select last_row({}) from {}".format(colname, "testdb."+tbname)
                     tdSql.query(abs_sql)
                 
 
     def basic_abs_function(self):
 
         # basic query
-        tdSql.query("select c1 from ct3")
+        tdSql.query("select c1 from testdb.ct3")
         tdSql.checkRows(0)
-        tdSql.query("select c1 from t1")
+        tdSql.query("select c1 from testdb.t1")
         tdSql.checkRows(12)
-        tdSql.query("select c1 from stb1")
+        tdSql.query("select c1 from testdb.stb1")
         tdSql.checkRows(25)
 
         # used for empty table  , ct3 is empty
-        tdSql.query("select last_row(c1) from ct3")
+        tdSql.query("select last_row(c1) from testdb.ct3")
         tdSql.checkRows(0)
-        tdSql.query("select last_row(c2) from ct3")
+        tdSql.query("select last_row(c2) from testdb.ct3")
         tdSql.checkRows(0)
-        tdSql.query("select last_row(c3) from ct3")
+        tdSql.query("select last_row(c3) from testdb.ct3")
         tdSql.checkRows(0)
-        tdSql.query("select last_row(c4) from ct3")
+        tdSql.query("select last_row(c4) from testdb.ct3")
         tdSql.checkRows(0)
-        tdSql.query("select last_row(c5) from ct3")
+        tdSql.query("select last_row(c5) from testdb.ct3")
         tdSql.checkRows(0)
-        tdSql.query("select last_row(c6) from ct3")
+        tdSql.query("select last_row(c6) from testdb.ct3")
 
         # used for regular table
 
         # bug need fix 
-        tdSql.query("select last_row(c1) from t1")
+        tdSql.query("select last_row(c1) from testdb.t1")
         tdSql.checkData(0, 0, None)
-        tdSql.query("select last_row(c1) from ct4")
+        tdSql.query("select last_row(c1) from testdb.ct4")
         tdSql.checkData(0, 0, None)
-        tdSql.query("select last_row(c1) from stb1")
+        tdSql.query("select last_row(c1) from testdb.stb1")
         tdSql.checkData(0, 0, None)
 
         # # bug need fix 
-        tdSql.query("select last_row(c1), c2, c3 , c4, c5 from t1")
+        tdSql.query("select last_row(c1), c2, c3 , c4, c5 from testdb.t1")
         tdSql.checkData(0, 0, None)
         tdSql.checkData(0, 1, None)
         tdSql.checkData(0, 2, None)
 
         # # bug need fix 
-        tdSql.query("select last_row(c1), c2, c3 , c4, c5 from ct1")
+        tdSql.query("select last_row(c1), c2, c3 , c4, c5 from testdb.ct1")
         tdSql.checkData(0, 0, 9)
         tdSql.checkData(0, 1, -99999)
         tdSql.checkData(0, 2, -999)
@@ -313,187 +306,189 @@ class TDTestCase:
         tdSql.checkData(0, 4,-9.99000)
         
         # bug need fix 
-        # tdSql.query("select last_row(c1), c2, c3 , c4, c5 from stb1 where tbname='ct1'")
-        # tdSql.checkData(0, 0, 9)
-        # tdSql.checkData(0, 1, -99999)
-        # tdSql.checkData(0, 2, -999)
-        # tdSql.checkData(0, 3, None)
-        # tdSql.checkData(0, 4,-9.99000)
+        tdSql.query("select last_row(c1), c2, c3 , c4, c5 from testdb.stb1 where tbname='ct1'")
+        tdSql.checkData(0, 0, 9)
+        tdSql.checkData(0, 1, -99999)
+        tdSql.checkData(0, 2, -999)
+        tdSql.checkData(0, 3, None)
+        tdSql.checkData(0, 4,-9.99000)
 
         # bug fix 
-        tdSql.query("select last_row(abs(c1)) from ct1")
+        tdSql.query("select last_row(abs(c1)) from testdb.ct1")
         tdSql.checkData(0,0,9)
 
         # # bug fix 
-        tdSql.query("select last_row(c1+1) from ct1")
-        tdSql.query("select last_row(c1+1) from stb1") 
-        tdSql.query("select last_row(c1+1) from t1")      
+        tdSql.query("select last_row(c1+1) from testdb.ct1")
+        tdSql.query("select last_row(c1+1) from testdb.stb1") 
+        tdSql.query("select last_row(c1+1) from testdb.t1")      
 
         # used for stable table
-        tdSql.query("select last_row(c1 ,c2 ,c3) ,last_row(c4) from ct1")
+        tdSql.query("select last_row(c1 ,c2 ,c3) ,last_row(c4) from testdb.ct1")
         tdSql.checkData(0,0,9)
         tdSql.checkData(0,1,-99999)
         tdSql.checkData(0,2,-999)
         tdSql.checkData(0,3,None)
 
         # bug need fix 
-        tdSql.query("select last_row(c1 ,c2 ,c3) from stb1 ")
+        tdSql.query("select last_row(c1 ,c2 ,c3) from testdb.stb1 ")
         tdSql.checkData(0,0,None)
         tdSql.checkData(0,1,None)
         tdSql.checkData(0,2,None)
 
-        # tdSql.query("select last_row(c1 ,c2 ,c3) ,last_row(c4) from stb1 where ts <now")
-        # tdSql.checkData(0,0,9)
-        # tdSql.checkData(0,1,-99999)
-        # tdSql.checkData(0,2,-999)
-        # tdSql.checkData(0,3,None)
-
-        # tdSql.query("select last_row(c1 ,c2 ,c3 ,c4) ,last(c4) from stb1 where ts <now")
-        # tdSql.checkData(0,0,9)
-        # tdSql.checkData(0,1,-99999)
-        # tdSql.checkData(0,2,-999)
-        # tdSql.checkData(0,3,None)
-        # tdSql.checkData(0,4,-99)
 
+        tdSql.query('select last_row(c1) from testdb.t1 where ts <"2022-12-31 01:01:36.000"')
+        tdSql.checkData(0,0,8)
         # bug need fix 
-        # tdSql.query("select abs(last_row(c1)-2)+max(c1),ceil(last_row(c4)-2) from stb1 where c4 is not null")
-        # tdSql.checkData(0,0,16.000000000)
-        # tdSql.checkData(0,1,-101.000000000)
+        tdSql.query("select abs(last_row(c1)-2)+max(c1),ceil(last_row(c4)-2) from testdb.stb1 where c4 is not null")
+        tdSql.checkData(0,0,16.000000000)
+        tdSql.checkData(0,1,-101.000000000)
 
-        # tdSql.query("select abs(last_row(c1)-2)+max(c1),ceil(last_row(c4)-2) from ct1 where c4<0")
-        # tdSql.checkData(0,0,16.000000000)
-        # tdSql.checkData(0,1,-101.000000000)
+        tdSql.query("select abs(last_row(c1)-2)+max(c1),ceil(last_row(c4)-2) from testdb.ct1 where c4<0")
+        tdSql.checkData(0,0,16.000000000)
+        tdSql.checkData(0,1,-101.000000000)
 
-        tdSql.query("select last_row(ceil(c1+2)+floor(c1)-10) from stb1")
+        tdSql.query("select last_row(ceil(c1+2)+floor(c1)-10) from testdb.stb1")
         tdSql.checkData(0,0,None)
 
-        tdSql.query("select last_row(ceil(c1+2)+floor(c1)-10) from ct1")
+        tdSql.query("select last_row(ceil(c1+2)+floor(c1)-10) from testdb.ct1")
         tdSql.checkData(0,0,10.000000000)
 
         # filter for last_row
 
-        # bug need fix 
-        # tdSql.query("select last_row(ts ,c1 ) from stb1 where ts < now ")
-        # tdSql.checkData(0,1,9)
-
-        # tdSql.query("select last_row(ts ,c1 ) from ct4 where ts < now ")
-        # tdSql.checkData(0,1,9)
-
         # bug need fix for all function
 
-        # tdSql.query("select last_row(ts ,c1 ) from ct4 where t1 = 1 ")
-        # tdSql.checkRows(0)
+        tdSql.query("select last_row(ts ,c1 ) from testdb.ct4 where t1 = 1 ")
+        tdSql.checkRows(0)
 
-        tdSql.query("select count(c1) from ct4 where t1 = 1 ")
+        tdSql.query("select count(c1) from testdb.ct4 where t1 = 1 ")
         tdSql.checkRows(0)
 
+        tdSql.query("select last_row(c1) ,last(c1)  from testdb.stb1 where  c1 is null")
+        tdSql.checkRows(1)
+        tdSql.checkData(0,0,None)
+        tdSql.checkData(0,1,None)
+
+        tdSql.query("select last_row(c1) ,count(*)  from testdb.stb1 where  c1 is null")
+        tdSql.checkData(0,0,None)
+        tdSql.checkData(0,1,3)
+        
+        tdSql.query("select last_row(c1) ,count(c1)  from testdb.stb1 where  c1 is null")
+        tdSql.checkData(0,0,None)
+        tdSql.checkData(0,1,0)
+
         # bug need fix
-        # tdSql.query("select tbname ,last_row(c1) from stb1")
-        # tdSql.checkData(0,0,'ct4')
-        # tdSql.checkData(0,1,None)
+        tdSql.query("select tbname ,last_row(c1) from testdb.stb1")
+        tdSql.checkData(0,0,'ct4')
+        tdSql.checkData(0,1,None)
         
-        # tdSql.query(" select tbname ,last_row(c1) from stb1 partition by tbname order by tbname ")
-        # tdSql.checkData(0,0,'ct1')
-        # tdSql.checkData(0,1,9)
-        # tdSql.checkData(1,0,'ct4')
-        # tdSql.checkData(1,1,None)
+        tdSql.query(" select tbname ,last_row(c1) from testdb.stb1 partition by tbname order by tbname ")
+        tdSql.checkData(0,0,'ct1')
+        tdSql.checkData(0,1,9)
+        tdSql.checkData(1,0,'ct4')
+        tdSql.checkData(1,1,None)
 
-        tdSql.query(" select tbname ,last_row(c1) from stb1 group by tbname order by tbname ")
+        tdSql.query(" select tbname ,last_row(c1) from testdb.stb1 group by tbname order by tbname ")
         tdSql.checkData(0,0,'ct1')
         tdSql.checkData(0,1,9)
         tdSql.checkData(1,0,'ct4')
         tdSql.checkData(1,1,None)
 
-        tdSql.query(" select t1 ,count(c1) from stb1 partition by t1 ")
+        tdSql.query(" select t1 ,count(c1) from testdb.stb1 partition by t1 ")
         tdSql.checkRows(2)
 
         # filter by tbname 
-        # tdSql.query("select last_row(c1) from stb1 where tbname = 'ct1' ")
-        # tdSql.checkData(0,0,9)
+        tdSql.query("select last_row(c1) from testdb.stb1 where tbname = 'ct1' ")
+        tdSql.checkData(0,0,9)
 
         # bug need fix 
-        # tdSql.query("select tbname ,last_row(c1) from stb1 where tbname = 'ct1' ")
-        # tdSql.checkData(0,0,9)
-        # tdSql.query("select tbname ,last_row(c1) from stb1 partition by tbname order by tbname")
-        # tdSql.checkData(0, 0, 'ct1')
-        # tdSql.checkData(0, 1, 9)
-        # tdSql.checkData(1, 0, 'ct4')
-        # tdSql.checkData(1, 1, None)
-
-        tdSql.query("select tbname ,last_row(c1) from stb1 group by tbname order by tbname")
+        tdSql.query("select tbname ,last_row(c1) from testdb.stb1 where tbname = 'ct1' ")
+        tdSql.checkData(0,1,9)
+        tdSql.query("select tbname ,last_row(c1) from testdb.stb1 partition by tbname order by tbname")
+        tdSql.checkData(0, 0, 'ct1')
+        tdSql.checkData(0, 1, 9)
+        tdSql.checkData(1, 0, 'ct4')
+        tdSql.checkData(1, 1, None)
+
+        tdSql.query("select tbname ,last_row(c1) from testdb.stb1 group by tbname order by tbname")
         tdSql.checkData(0, 0, 'ct1')
         tdSql.checkData(0, 1, 9)
         tdSql.checkData(1, 0, 'ct4')
         tdSql.checkData(1, 1, None)
 
         # last_row for only tag
-        tdSql.query("select last_row(t1 ,t2 ,t3 , t4 ) from stb1")
+        tdSql.query("select last_row(t1 ,t2 ,t3 , t4 ) from testdb.stb1")
         tdSql.checkData(0,0,3)
         tdSql.checkData(0,1,33333)
         tdSql.checkData(0,2,333)
         tdSql.checkData(0,3,3)
 
-        tdSql.query("select last_row(abs(floor(t1)) ,t2 ,ceil(abs(t3)) , abs(ceil(t4)) ) from stb1")
+        tdSql.query("select last_row(abs(floor(t1)) ,t2 ,ceil(abs(t3)) , abs(ceil(t4)) ) from testdb.stb1")
         tdSql.checkData(0,0,3)
         tdSql.checkData(0,1,33333)
         tdSql.checkData(0,2,333)
         tdSql.checkData(0,3,3)
 
-
         # filter by tag 
-        # tdSql.query("select tbname ,last_row(c1) from stb1 where t1 =1 ")
-        # tdSql.checkData(0,0,9)
-        # tdSql.query("select tbname ,last_row(c1) ,t1 from stb1 partition by t1 order by t1")
-        # tdSql.checkData(0, 0, 'ct1')
-        # tdSql.checkData(0, 1, 9)
-        # tdSql.checkData(1, 0, 'ct4')
-        # tdSql.checkData(1, 1, None)
+        tdSql.query("select tbname ,last_row(c1) from testdb.stb1 where t1 =0 ")
+        tdSql.checkData(0,1,9)
+        tdSql.query("select tbname ,last_row(c1) ,t1 from testdb.stb1 partition by t1 order by t1")
+        tdSql.checkData(0, 0, 'ct1')
+        tdSql.checkData(0, 1, 9)
+        tdSql.checkData(1, 0, 'ct4')
+        tdSql.checkData(1, 1, None)
 
         # filter by col 
 
-        # tdSql.query("select tbname ,last_row(c1),abs(c1)from stb1 where c1 =1;")
-        # tdSql.checkData(0, 0, 'ct1')
-        # tdSql.checkData(0, 1, 1)
-        # tdSql.checkData(0, 2, 1)
-        tdSql.query("select last_row(c1) from stb1 where abs(ceil(c1))*c1==1")
+        tdSql.query("select tbname ,last_row(c1),abs(c1)from testdb.stb1 where c1 =1;")
+        tdSql.checkData(0, 0, 'ct1')
+        tdSql.checkData(0, 1, 1)
+        tdSql.checkData(0, 2, 1)
+        tdSql.query("select last_row(c1) from testdb.stb1 where abs(ceil(c1))*c1==1")
         tdSql.checkData(0,0,1)
     
         # mix with common functions
-        tdSql.query("select last_row(*) ,last(*) from stb1  ")
+        tdSql.query("select last_row(*) ,last(*) from testdb.stb1  ")
         tdSql.checkRows(1)
 
-        tdSql.query("select last_row(*) ,last(*) from stb1  ")
+        tdSql.query("select last_row(*) ,last(*) from testdb.stb1  ")
         tdSql.checkRows(1)
 
 
-        tdSql.query("select last_row(c1+abs(c1)) from stb1 partition by tbname order by tbname")
-        tdSql.query("select last(c1), max(c1+abs(c1)),last_row(c1+abs(c1)) from stb1 partition by tbname order by tbname")
+        tdSql.query("select last_row(c1+abs(c1)) from testdb.stb1 partition by tbname order by tbname")
+        tdSql.query("select last(c1), max(c1+abs(c1)),last_row(c1+abs(c1)) from testdb.stb1 partition by tbname order by tbname")
 
         # # bug need fix ,taosd crash 
-        # tdSql.query("select last_row(*) ,last(*) from stb1 partition by tbname order by last(*)")
-        # tdSql.query("select last_row(*) ,last(*) from stb1 partition by tbname order by last_row(*)")
+        tdSql.error("select last_row(*) ,last(*) from testdb.stb1 partition by tbname order by last(*)")
+        tdSql.error("select last_row(*) ,last(*) from testdb.stb1 partition by tbname order by last_row(*)")
 
         # mix with agg functions 
-        tdSql.query("select last(*), last_row(*),last(c1), last_row(c1) from stb1 ")
-        tdSql.query("select last(*), last_row(*),last(c1), last_row(c1) from ct1 ")
-        tdSql.query("select last(*), last_row(*),last(c1+1)*max(c1), last_row(c1+2)/2 from t1 ")
-        tdSql.query("select last_row(*) ,abs(c1/2)+100 from stb1 where tbname =\"ct1\" ")
-        tdSql.query("select c1, last_row(c5) from ct1 ")
-        tdSql.error("select c1, last_row(c5) ,last(c1) from stb1 ")
+        tdSql.query("select last(*), last_row(*),last(c1), last_row(c1) from testdb.stb1 ")
+        tdSql.query("select last(*), last_row(*),last(c1), last_row(c1) from testdb.ct1 ")
+        tdSql.query("select last(*), last_row(*),last(c1+1)*max(c1), last_row(c1+2)/2 from testdb.t1 ")
+        tdSql.query("select last_row(*) ,abs(c1/2)+100 from testdb.stb1 where tbname =\"ct1\" ")
+        tdSql.query("select c1, last_row(c5) from testdb.ct1 ")
+        tdSql.error("select c1, last_row(c5) ,last(c1) from testdb.stb1 ")
 
         # agg functions mix with agg functions
 
-        tdSql.query("select last(c1) , max(c5), count(c5) from stb1")
-        tdSql.query("select last_row(c1) , max(c5), count(c5) from ct1")
+        tdSql.query("select last(c1) , max(c5), count(c5) from testdb.stb1")
+        tdSql.query("select last_row(c1) , max(c5), count(c5) from testdb.ct1")
 
         # bug fix for compute
-        tdSql.query("select  last_row(c1) -0 ,last(c1)-0 ,last(c1)+last_row(c1) from ct4 ")
-        tdSql.query(" select c1, abs(c1) -0 ,last_row(c1-0.1)-0.1 from ct4")
+        tdSql.query("select  last_row(c1) -0 ,last(c1)-0 ,last(c1)+last_row(c1) from testdb.ct4 ")
+        tdSql.checkData(0,0,None)
+        tdSql.checkData(0,1,0.000000000)
+        tdSql.checkData(0,2,None)
+
+        tdSql.query(" select c1, abs(c1) -0 ,last_row(c1-0.1)-0.1 from testdb.ct1")
+        tdSql.checkData(0,0,9)
+        tdSql.checkData(0,1,9.000000000)
+        tdSql.checkData(0,2,8.800000000)
 
     def abs_func_filter(self):
         tdSql.execute("use db")
         tdSql.query(
-            "select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,last_row(log(c1,2)-0.5) from ct4 where c1>5 ")
+            "select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,last_row(log(c1,2)-0.5) from db.ct4 where c1>5 ")
         tdSql.checkData(0, 0, 6)
         tdSql.checkData(0, 1, 6.000000000)
         tdSql.checkData(0, 2, 6.000000000)
@@ -501,19 +496,19 @@ class TDTestCase:
         tdSql.checkData(0, 4, 2.084962501)
 
         tdSql.query(
-            "select last_row(c1,c2,c1+5) from ct4 where c1=5 ")
+            "select last_row(c1,c2,c1+5) from db.ct4 where c1=5 ")
         tdSql.checkData(0, 0, 5)
         tdSql.checkData(0, 1, 55555)
         tdSql.checkData(0, 2, 10.000000000)
 
         tdSql.query(
-            "select last(c1,c2,c1+5) from ct4 where c1=5 ")
+            "select last(c1,c2,c1+5) from db.ct4 where c1=5 ")
         tdSql.checkData(0, 0, 5)
         tdSql.checkData(0, 1, 55555)
         tdSql.checkData(0, 2, 10.000000000)
 
         tdSql.query(
-            "select c1,c2 , abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) from ct4 where c1>log(c1,2) limit 1 ")
+            "select c1,c2 , abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) from db.ct4 where c1>log(c1,2) limit 1 ")
         tdSql.checkRows(1)
         tdSql.checkData(0, 0, 8)
         tdSql.checkData(0, 1, 88888)
@@ -528,39 +523,40 @@ class TDTestCase:
     def check_boundary_values(self):
 
         tdSql.execute("drop database if exists bound_test")
-        tdSql.execute("create database if not exists bound_test cachemodel 'last_value'")
+        tdSql.execute("create database if not exists bound_test cachemodel 'LAST_ROW' ")
+
         time.sleep(3)
         tdSql.execute("use bound_test")
         tdSql.execute(
-            "create table stb_bound (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(32),c9 nchar(32), c10 timestamp) tags (t1 int);"
+            "create table bound_test.stb_bound (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(32),c9 nchar(32), c10 timestamp) tags (t1 int);"
         )
-        tdSql.execute(f'create table sub1_bound using stb_bound tags ( 1 )')
+        tdSql.execute(f'create table bound_test.sub1_bound using stb_bound tags ( 1 )')
         tdSql.execute(
-            f"insert into sub1_bound values ( now()-1s, 2147483647, 9223372036854775807, 32767, 127, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            f"insert into bound_test.sub1_bound values ( now()-1s, 2147483647, 9223372036854775807, 32767, 127, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
         )
         tdSql.execute(
-            f"insert into sub1_bound values ( now()-1s, -2147483647, -9223372036854775807, -32767, -127, -3.40E+38, -1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            f"insert into bound_test.sub1_bound values ( now()-1s, -2147483647, -9223372036854775807, -32767, -127, -3.40E+38, -1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
         )
         tdSql.execute(
-            f"insert into sub1_bound values ( now(), 2147483646, 9223372036854775806, 32766, 126, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            f"insert into bound_test.sub1_bound values ( now(), 2147483646, 9223372036854775806, 32766, 126, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
         )
         tdSql.execute(
-            f"insert into sub1_bound values ( now(), -2147483646, -9223372036854775806, -32766, -126, -3.40E+38, -1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            f"insert into bound_test.sub1_bound values ( now(), -2147483646, -9223372036854775806, -32766, -126, -3.40E+38, -1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
         )
         tdSql.error(
-            f"insert into sub1_bound values ( now()+1s, 2147483648, 9223372036854775808, 32768, 128, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            f"insert into bound_test.sub1_bound values ( now()+1s, 2147483648, 9223372036854775808, 32768, 128, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
         )
 
         # check basic elem for table per row
         tdSql.query(
-            "select last(c1) ,last_row(c2), last_row(c3)+1 , last(c4)+1  from sub1_bound ")
+            "select last(c1) ,last_row(c2), last_row(c3)+1 , last(c4)+1  from bound_test.sub1_bound ")
         tdSql.checkData(0, 0, -2147483646)
         tdSql.checkData(0, 1, -9223372036854775806)
         tdSql.checkData(0, 2, -32765.000000000)
         tdSql.checkData(0, 3, -125.000000000)
         # check  + - * / in functions
         tdSql.query(
-            "select last_row(c1+1) ,last_row(c2) , last(c3*1) , last(c4/2)  from sub1_bound ")
+            "select last_row(c1+1) ,last_row(c2) , last(c3*1) , last(c4/2)  from bound_test.sub1_bound ")
 
     def test_tag_compute_for_scalar_function(self):
 
@@ -568,202 +564,235 @@ class TDTestCase:
 
         # bug need fix
 
-        tdSql.query(" select sum(c1) from stb1 where t1+10 >1; ")  
-        tdSql.query("select c1 ,t1 from stb1 where t1 =0 ")
+        tdSql.query(" select sum(c1) from testdb.stb1 where t1+10 >1; ")  
+        tdSql.query("select c1 ,t1 from testdb.stb1 where t1 =0 ")
         tdSql.checkRows(13)
-        tdSql.query("select last_row(c1,t1) from stb1 ")
+        tdSql.query("select last_row(c1,t1) from testdb.stb1 ")
         tdSql.checkData(0,0,None)
         tdSql.checkData(0,1,3)
-        # tdSql.query("select last_row(c1),t1 from stb1 ")
-        # tdSql.checkData(0,0,None)
-        # tdSql.checkData(0,1,3)
-        tdSql.query("select last_row(c1,t1),last(t1) from stb1 ")
+        tdSql.query("select last_row(c1),t1 from testdb.stb1 ")
+        tdSql.checkData(0,0,None)
+        tdSql.checkData(0,1,3)
+        tdSql.query("select last_row(c1,t1),last(t1) from testdb.stb1 ")
         tdSql.checkData(0,0,None)
         tdSql.checkData(0,1,3)
         tdSql.checkData(0,2,3)
 
-        tdSql.query("select last_row(t1) from stb1 where t1 >0 ")
+        tdSql.query("select last_row(t1) from testdb.stb1 where t1 >0 ")
         tdSql.checkRows(1)
         tdSql.checkData(0,0,3)
-        tdSql.query("select last_row(t1) from stb1 where t1 =3 ")
+        tdSql.query("select last_row(t1) from testdb.stb1 where t1 =3 ")
         tdSql.checkRows(1)
         tdSql.checkData(0,0,3)
 
-        tdSql.query("select last_row(t1) from stb1 where t1 =2")
+        tdSql.query("select last_row(t1) from testdb.stb1 where t1 =2")
         tdSql.checkRows(0)
 
         # nest query for last_row
-        # tdSql.query("select last_row(t1) from (select c1 ,t1 from stb1)")
-        # tdSql.checkData(0,0,61)
-        # tdSql.query("select distinct(c1) ,t1 from stb1")
-        # tdSql.checkRows(20)
-        tdSql.query("select last_row(c1) from (select _rowts , c1 ,t1 from stb1)")
+        tdSql.query("select last_row(t1) from (select ts , c1 ,t1 from testdb.stb1)")
+        tdSql.checkData(0,0,3)
+        tdSql.query("select distinct(c1) ,t1 from testdb.stb1")
+        tdSql.checkRows(20)
+        tdSql.query("select last_row(c1) from (select _rowts , c1 ,t1 from testdb.stb1)")
         tdSql.checkData(0,0,None)
 
-        tdSql.query("select last_row(c1) from (select ts , c1 ,t1 from stb1)")
+        tdSql.query("select last_row(c1) from (select ts , c1 ,t1 from testdb.stb1)")
         tdSql.checkData(0,0,None)
 
-        tdSql.query("select ts , last_row(c1) ,c1  from (select ts , c1 ,t1 from stb1)")
+        tdSql.query("select ts , last_row(c1) ,c1  from (select ts , c1 ,t1 from testdb.stb1)")
         tdSql.checkData(0,1,None)
 
-        tdSql.query("select ts , last_row(c1) ,c1  from (select ts , max(c1) c1  ,t1 from stb1 where ts >now -1h and ts <now interval(10s) fill(value ,10 ))")
+        tdSql.query("select ts , last_row(c1) ,c1  from (select ts , max(c1) c1  ,t1 from testdb.stb1 where ts >now -1h and ts <now+1h interval(10s) fill(value ,10 ))")
         tdSql.checkData(0,1,10)
         tdSql.checkData(0,1,10)
 
-        tdSql.query("select ts , last_row(c1) ,c1  from (select count(c1) c1 from stb1 where ts >now -1h and ts <now interval(10s) fill(value ,10 ))")
-        tdSql.checkData(0,1,10)
-        tdSql.checkData(0,1,10)
+        tdSql.error("select ts , last_row(c1) ,c1  from (select count(c1) c1 from testdb.stb1 where ts >now -1h and ts <now+1h interval(10s) fill(value ,10 ))")
 
-        tdSql.error("select  last_row(c1) ,c1  from (select  count(c1) c1 from stb1 where ts >now -1h and ts <now interval(10s) fill(value ,10 ))")
+        tdSql.error("select  last_row(c1) ,c1  from (select  count(c1) c1 from testdb.stb1 where ts >now -1h and ts <now+1h interval(10s) fill(value ,10 ))")
 
-        # tag filter with abs function
-        tdSql.query("select last_row(t1) from stb1 where abs(t1)=1")
+        # tag filter with last_row function
+        tdSql.query("select last_row(t1) from testdb.stb1 where abs(t1)=1")
+        tdSql.checkRows(0)
+        tdSql.query("select last_row(t1) from testdb.stb1 where abs(t1)=0")
         tdSql.checkRows(1)
-        tdSql.query(" select last_row(t1),last_row(c1) from ct1 where abs(c1+t1)=1")
+        tdSql.query(" select last_row(t1),last_row(c1) from db.ct1 where abs(c1+t1)=1")
         tdSql.checkRows(1)
-        tdSql.checkData(0,0,0)
         tdSql.checkData(0,0,1)
+        tdSql.checkData(0,1,0)
 
         tdSql.query(
-            "select last_row(c1+t1)*t1 from stb1 where abs(c1)/floor(abs(ceil(t1))) ==1")
+            "select last_row(c1+t1)*t1 from testdb.stb1 where abs(c1)/floor(abs(ceil(t1))) ==1")
 
     def group_test(self):
         tdSql.execute(" use testdb ")
-        tdSql.query(" select last_row(c1) from stb1 group by t1 order by t1 ")
+        tdSql.query(" select last_row(c1) from testdb.stb1 group by t1 order by t1 ")
         tdSql.checkRows(2)
         
         # bug need fix 
-        # tdSql.query("select last_row(c1) from testdb.stb1 group by c1 order by t1 ")
-        # tdSql.query("select last_row(c1) from db.stb1 group by c1 order by t1 ")
+        tdSql.query("select last_row(c1) from testdb.stb1 group by c1 order by c1,t1 ")
+        tdSql.checkRows(10)
+        tdSql.checkData(9,0,8)
+        tdSql.query("select last_row(c1) from db.stb1 group by c1 order by t1 ")
+        tdSql.checkRows(10)
+        tdSql.checkData(0,0,4)
+
+        tdSql.query("select last_row(c1) from testdb.stb1 group by c1 order by t1")
+        tdSql.checkRows(11)
+
+        tdSql.query("select last_row(c1) from testdb.stb1 group by c1 order by c1,t1;")
+        tdSql.checkRows(11)
+        tdSql.checkData(10,0,9)
 
         # bug need fix , result is error 
-        tdSql.query("select last_row(c1) from ct4 group by c1 order by t1 ")
-        tdSql.query("select last_row(t1) from ct4 group by c1 order by t1 ")
+        tdSql.query("select last_row(c1) from testdb.ct4 group by c1 order by t1 ")
+        tdSql.query("select last_row(t1) from testdb.ct4 group by c1 order by t1 ")
 
-        tdSql.query("select last_row(t1) from stb1 group by t1 order by t1 ")
+        tdSql.query("select last_row(t1) from testdb.stb1 group by t1 order by t1 ")
         tdSql.checkRows(2)
-        tdSql.query("select last_row(c1) from stb1 group by c1 order by c1 ")
+        tdSql.query("select last_row(c1) from testdb.stb1 group by c1 order by c1 ")
         tdSql.checkRows(11)
         tdSql.checkData(0,0,None)
         tdSql.checkData(10,0,9)
 
-        tdSql.query("select ceil(abs(last_row(abs(c1)))) from stb1 group by abs(c1) order by abs(c1);")
+        tdSql.query("select ceil(abs(last_row(abs(c1)))) from testdb.stb1 group by abs(c1) order by abs(c1);")
         tdSql.checkRows(11)
         tdSql.checkData(0,0,None)
         tdSql.checkData(10,0,9)
-        tdSql.query("select last_row(c1+c3) from stb1 group by abs(c1+c3) order by abs(c1+c3)")
+        tdSql.query("select last_row(c1+c3) from testdb.stb1 group by abs(c1+c3) order by abs(c1+c3)")
         tdSql.checkRows(11)
 
         # bug need fix , taosd crash 
-        tdSql.query("select last_row(c1+c3)+c2 from stb1 group by abs(c1+c3)+c2 order by abs(c1+c3)+c2")
+        tdSql.query("select last_row(c1+c3)+c2 from testdb.stb1 group by abs(c1+c3)+c2 order by abs(c1+c3)+c2")
         tdSql.checkRows(11)
-        tdSql.query("select last_row(c1+c3)+last_row(c2) from stb1 group by abs(c1+c3)+abs(c2) order by abs(c1+c3)+abs(c2)")
+        tdSql.query("select last_row(c1+c3)+last_row(c2) from testdb.stb1 group by abs(c1+c3)+abs(c2) order by abs(c1+c3)+abs(c2)")
         tdSql.checkRows(11)
+        tdSql.checkData(0,0,None)
+        tdSql.checkData(2,0,11223.000000000)
         
-        tdSql.query("select t1 from stb1 where abs(c1+t1)=1 partition by tbname")
-        tdSql.checkData(0,0,0)
+        tdSql.query("select last_row(t1) from testdb.stb1 where abs(c1+t1)=1 partition by tbname")
+        tdSql.checkData(0,0,1)
         
-        tdSql.query("select tbname , abs(c1) from stb1 partition by tbname order by tbname")
-        tdSql.checkRows(25)
-        tdSql.checkData(0,1,8)
-        tdSql.checkData(23,1,1)
-        tdSql.checkData(24,1,None)
+        tdSql.query("select tbname , last_row(c1) from testdb.stb1 partition by tbname order by tbname")
+        tdSql.checkRows(2)
+        tdSql.checkData(0, 0, 'ct1')
+        tdSql.checkData(0, 1,  9)
+        tdSql.checkData(0, 2, 'ct4')
+        tdSql.checkData(0, 3, None)
         
-        tdSql.query("select tbname , abs(c1) from stb1 partition by t1 order by t1")
-        tdSql.checkRows(25)
-        tdSql.checkData(0,1,8)
-        tdSql.checkData(23,1,1)
-        tdSql.checkData(24,1,None)
+        tdSql.query("select tbname , last_row(c1) from testdb.stb1 partition by t1 order by t1")
+        tdSql.checkRows(2)
+        tdSql.checkData(0, 0, 'ct1')
+        tdSql.checkData(0, 1,  9)
+        tdSql.checkData(0, 2, 'ct4')
+        tdSql.checkData(0, 3, None)
 
-        tdSql.query("select tbname , abs(c1) from stb1 partition by c2 order by c1")
-        tdSql.checkRows(25)
-        tdSql.checkData(24,1,9)
+        # bug need fix 
+        tdSql.query("select tbname , last_row(c1) from testdb.stb1 partition by c2 order by c1")
+        tdSql.checkRows(11)
+        tdSql.checkData(10,1,9)
 
-        tdSql.query("select tbname , abs(c1) from stb1 partition by c2 order by c2")
-        tdSql.checkRows(25)
-        tdSql.checkData(24,1,8)
+        tdSql.query("select tbname , last_row(c1) from testdb.stb1 partition by c2 order by c2")
+        tdSql.checkRows(11)
+        tdSql.checkData(10,1,88888)
 
-        tdSql.query("select tbname , abs(t1) from stb1 partition by c2 order by t1")
-        tdSql.checkRows(25)
-        tdSql.checkData(24,1,3)
+        tdSql.query("select tbname , last_row(t1) from testdb.stb1 partition by c2 order by t1")
+        tdSql.checkRows(11)
 
-        tdSql.query("select abs(c1) , abs(t1) from stb1 partition by c2 order by t1")
-        tdSql.checkRows(25)
-        tdSql.checkData(16,0,None)
-        tdSql.checkData(16,1,3)
+        tdSql.query("select abs(c1) ,c2 ,t1, last_row(t1) from testdb.stb1 partition by c2 order by t1")
+        tdSql.checkRows(11)
+   
+        tdSql.query("select t1 ,last_row(t1) ,c2 from testdb.stb1 partition by c2 order by t1")
+        tdSql.checkRows(11)
 
-        tdSql.query("select abs(c1) , abs(t1) ,c2 from stb1 partition by c2 order by t1")
-        tdSql.checkRows(25)
-        tdSql.checkData(16,0,None)
-        tdSql.checkData(16,1,3)
-        tdSql.checkData(16,2,None)
+        tdSql.query("select last_row(t1) ,last_row(t1) ,last_row(c2) from testdb.stb1 partition by c2 order by c2")
+        tdSql.checkRows(11)
 
-        tdSql.query("select abs(c1) , abs(t1) ,c2 from stb1 partition by tbname order by tbname")
-        tdSql.checkRows(25)
-        tdSql.checkData(16,0,7)
-        tdSql.checkData(16,1,3)
-        tdSql.checkData(16,2,77777)
+        tdSql.query("select abs(c1) , last_row(t1) ,c2 from testdb.stb1 partition by tbname order by tbname")
+        tdSql.checkRows(2)
 
-        tdSql.query("select abs(c1) , abs(t1) ,c2 from stb1 partition by t1 order by t1")
-        tdSql.checkRows(25)
-        tdSql.checkData(16,0,7)
-        tdSql.checkData(16,1,3)
-        tdSql.checkData(16,2,77777)
+        tdSql.query("select last_row(c1) , ceil(t1) ,c2 from testdb.stb1 partition by t1 order by t1")
+        tdSql.checkRows(2)
 
-        tdSql.query("select abs(c1) , abs(t1) ,c2 from stb1 partition by abs(c1) order by abs(c1)")
-        tdSql.checkRows(25)
-        tdSql.checkData(16,0,6)
-        tdSql.checkData(16,1,3)
-        tdSql.checkData(16,2,66666)
+        tdSql.query("select last_row(c1) , abs(t1) ,c2 from testdb.stb1 partition by abs(c1) order by abs(c1)")
+        tdSql.checkRows(11)
 
-        tdSql.query("select abs(ceil(c1)) , abs(floor(t1)) ,floor(c2) from stb1 partition by abs(floor(c1)) order by abs(c1)")
-        tdSql.checkRows(25)
-        tdSql.checkData(16,0,6)
-        tdSql.checkData(16,1,3)
-        tdSql.checkData(16,2,66666)
+        tdSql.query("select abs(last_row(c1)) , abs(floor(t1)) ,floor(c2) from testdb.stb1 partition by abs(floor(c1)) order by abs(c1)")
+        tdSql.checkRows(11)
 
-        tdSql.query("select abs(ceil(c1-2)) , abs(floor(t1+1)) ,floor(c2-c1) from stb1 partition by abs(floor(c1)) order by abs(c1)")
-        tdSql.checkRows(25)
-        tdSql.checkData(16,0,4.000000000)
-        tdSql.checkData(16,1,4.000000000)
-        tdSql.checkData(16,2,66660.000000000)
+        tdSql.query("select last_row(ceil(c1-2)) , abs(floor(t1+1)) ,floor(c2-c1) from testdb.stb1 partition by abs(floor(c1)) order by abs(c1)")
+        tdSql.checkRows(11)
 
         # interval 
+
         tdSql.query("select max(c1) from stb1 interval(50s) sliding(30s)")
         tdSql.checkRows(13)
-        # bug need fix
-        # tdSql.query('select max(c1) from stb1 where ts>="2022-07-06 16:00:00.000 " and ts < "2022-07-06 17:00:00.000 " interval(50s) sliding(30s) fill(NULL)')
-        # tdSql.checkRows(40)
-        # tdSql.checkData(0,0,None)
-        tdSql.query('select max(c1) from stb1 where ts>="2022-07-06 16:00:00.000 " and ts < "2022-07-06 17:00:00.000 " interval(50s) sliding(30s)')
-        tdSql.checkRows(5)
 
         tdSql.query("select unique(c1) from stb1 partition by tbname")
 
+        tdSql.query("select last_row(c1) from testdb.stb1 interval(50s) sliding(30s)")
+        tdSql.checkRows(27)
 
 
-    def support_super_table_test(self):
-        tdSql.execute(" use testdb ")
-        self.check_result_auto( " select c1 from stb1 order by ts " , "select abs(c1) from stb1 order by ts" )
-        self.check_result_auto( " select c1 from stb1 order by tbname " , "select abs(c1) from stb1 order by tbname" )
-        self.check_result_auto( " select c1 from stb1 where c1 > 0 order by tbname  " , "select abs(c1) from stb1 where c1 > 0 order by tbname" )
-        self.check_result_auto( " select c1 from stb1 where c1 > 0 order by tbname  " , "select abs(c1) from stb1 where c1 > 0 order by tbname" )
-
-        self.check_result_auto( " select t1,c1 from stb1 order by ts " , "select t1, abs(c1) from stb1 order by ts" )
-        self.check_result_auto( " select t2,c1 from stb1 order by tbname " , "select t2 ,abs(c1) from stb1 order by tbname" )
-        self.check_result_auto( " select t3,c1 from stb1 where c1 > 0 order by tbname  " , "select t3 ,abs(c1) from stb1 where c1 > 0 order by tbname" )
-        self.check_result_auto( " select t4,c1 from stb1 where c1 > 0 order by tbname  " , "select t4 , abs(c1) from stb1 where c1 > 0 order by tbname" )
-        pass
+        tdSql.query("select last_row(c1) from testdb.ct1 interval(50s) sliding(30s)")
+        tdSql.checkRows(5)
+        last_row_result = tdSql.queryResult
+        tdSql.query("select last(c1) from testdb.ct1 interval(50s) sliding(30s)")
+        for ind , row in enumerate(last_row_result):
+            tdSql.checkData(ind , 0 , row[0])
 
+        # bug need fix
+        tdSql.query('select max(c1) from testdb.t1 where ts>="2021-01-01 01:01:06.000" and ts < "2021-07-21 01:01:01.000" interval(50d) sliding(30d) fill(NULL)')
+        tdSql.checkRows(8)
+        tdSql.checkData(7,0,None)
+
+        tdSql.query('select last_row(c1) from testdb.t1 where ts>="2021-01-01 01:01:06.000" and ts < "2021-07-21 01:01:01.000" interval(50d) sliding(30d) fill(value ,2 )')
+        tdSql.checkRows(8)
+        tdSql.checkData(7,0,2)
+
+        tdSql.query('select last_row(c1) from testdb.stb1 where ts>="2022-07-06 16:00:00.000 " and ts < "2022-07-06 17:00:00.000 " interval(50s) sliding(30s)')
+        tdSql.query('select last_row(c1) from (select ts ,  c1  from testdb.t1 where ts>="2021-01-01 01:01:06.000" and ts < "2021-07-21 01:01:01.000" ) interval(10s) sliding(5s)')
+
+        # join 
+        tdSql.query("use test")
+        tdSql.query("select last(sub_tb_1.c1), last(sub_tb_2.c2) from sub_tb_1, sub_tb_2 where sub_tb_1.ts=sub_tb_2.ts")
+        tdSql.checkCols(2)
+        last_row_result = tdSql.queryResult
+        tdSql.query("select last_row(sub_tb_1.c1), last_row(sub_tb_2.c2) from sub_tb_1, sub_tb_2 where sub_tb_1.ts=sub_tb_2.ts")
+        
+        for ind , row in enumerate(last_row_result):
+            tdSql.checkData(ind , 0 , row[0])
 
-    def run(self):  # sourcery skip: extract-duplicate-method, remove-redundant-fstring
-        # tdSql.prepare()
+        tdSql.query("select last(*), last(*) from sub_tb_1, sub_tb_2 where sub_tb_1.ts=sub_tb_2.ts")
 
-        tdLog.printNoPrefix("==========step1:create table ==============")
+        last_row_result = tdSql.queryResult
+        tdSql.query("select last_row(*), last_row(*) from sub_tb_1, sub_tb_2 where sub_tb_1.ts=sub_tb_2.ts")
+        for ind , row in enumerate(last_row_result):
+            tdSql.checkData(ind , 0 , row[0])
 
-        self.prepare_datas()
-        self.prepare_tag_datas()
+        tdSql.query("select last(*), last_row(*) from sub_tb_1, sub_tb_2 where sub_tb_1.ts=sub_tb_2.ts")
+        for ind , row in enumerate(last_row_result):
+            tdSql.checkData(ind , 0 , row[0])
 
+        tdSql.query("select last_row(*), last(*) from sub_tb_1, sub_tb_2 where sub_tb_1.ts=sub_tb_2.ts")
+        for ind , row in enumerate(last_row_result):
+            tdSql.checkData(ind , 0 , row[0])
+        
+
+    def support_super_table_test(self):
+        tdSql.execute(" use testdb ")
+        self.check_result_auto( " select c1 from testdb.stb1 order by ts " , "select abs(c1) from testdb.stb1 order by ts" )
+        self.check_result_auto( " select c1 from testdb.stb1 order by tbname " , "select abs(c1) from testdb.stb1 order by tbname" )
+        self.check_result_auto( " select c1 from testdb.stb1 where c1 > 0 order by tbname  " , "select abs(c1) from testdb.stb1 where c1 > 0 order by tbname" )
+        self.check_result_auto( " select c1 from testdb.stb1 where c1 > 0 order by tbname  " , "select abs(c1) from testdb.stb1 where c1 > 0 order by tbname" )
+
+        self.check_result_auto( " select t1,c1 from testdb.stb1 order by ts " , "select t1, abs(c1) from testdb.stb1 order by ts" )
+        self.check_result_auto( " select t2,c1 from testdb.stb1 order by tbname " , "select t2 ,abs(c1) from testdb.stb1 order by tbname" )
+        self.check_result_auto( " select t3,c1 from testdb.stb1 where c1 > 0 order by tbname  " , "select t3 ,abs(c1) from testdb.stb1 where c1 > 0 order by tbname" )
+        self.check_result_auto( " select t4,c1 from testdb.stb1 where c1 > 0 order by tbname  " , "select t4 , abs(c1) from testdb.stb1 where c1 > 0 order by tbname" )
+        pass
+    
+    def basic_query(self):
+        
         tdLog.printNoPrefix("==========step2:test errors ==============")
 
         self.test_errors()
@@ -790,12 +819,41 @@ class TDTestCase:
 
         tdLog.printNoPrefix("==========step7: check result of query ============")
 
-        self.insert_datas_and_check_abs(self.tb_nums,self.row_nums,self.time_step)
 
         tdLog.printNoPrefix("==========step8: check abs result of  stable query ============")
 
         self.support_super_table_test()
 
+    def run(self):  # sourcery skip: extract-duplicate-method, remove-redundant-fstring
+        # tdSql.prepare()
+
+        tdLog.printNoPrefix("==========step1:create table ==============")
+
+        # cache_last 0
+        self.prepare_datas("'NONE' ")
+        self.prepare_tag_datas("'NONE'")
+        self.insert_datas_and_check_abs(self.tb_nums,self.row_nums,self.time_step,"'NONE'")
+        self.basic_query()
+
+        # cache_last 1 
+        self.prepare_datas("'LAST_ROW'")
+        self.prepare_tag_datas("'LAST_ROW'")
+        self.insert_datas_and_check_abs(self.tb_nums,self.row_nums,self.time_step,"'LAST_ROW'")
+        self.basic_query()
+
+        # cache_last 2 
+        self.prepare_datas("'LAST_VALUE'")
+        self.prepare_tag_datas("'LAST_VALUE'")
+        self.insert_datas_and_check_abs(self.tb_nums,self.row_nums,self.time_step,"'LAST_VALUE'")
+        self.basic_query()
+
+        # cache_last 3 
+        self.prepare_datas("'BOTH'")
+        self.prepare_tag_datas("'BOTH'")
+        self.insert_datas_and_check_abs(self.tb_nums,self.row_nums,self.time_step,"'BOTH'")
+        self.basic_query()
+
+
     def stop(self):
         tdSql.close()
         tdLog.success(f"{__file__} successfully executed")

tests/system-test/fulltest.sh

@@ -126,7 +126,7 @@ python3 ./test.py -f 2-query/count_partition.py
 python3 ./test.py -f 2-query/function_null.py
 python3 ./test.py -f 2-query/queryQnode.py
 python3 ./test.py -f 2-query/max_partition.py
-
+python3 ./test.py -f 2-query/last_row.py
 
 python3 ./test.py -f 6-cluster/5dnode1mnode.py
 #BUG python3 ./test.py -f 6-cluster/5dnode2mnode.py  -N 5 -M 3
@@ -274,6 +274,7 @@ python3 ./test.py -f 2-query/irate.py  -Q 2
 python3 ./test.py -f 2-query/function_null.py  -Q 2
 python3 ./test.py -f 2-query/count_partition.py -Q 2
 python3 ./test.py -f 2-query/max_partition.py -Q 2
+python3 ./test.py -f 2-query/last_row.py -Q 2
 
 #------------querPolicy  3-----------
 
@@ -361,3 +362,4 @@ python3 ./test.py -f 2-query/irate.py -Q  3
 python3 ./test.py -f 2-query/function_null.py -Q  3
 python3 ./test.py -f 2-query/count_partition.py -Q 3
 python3 ./test.py -f 2-query/max_partition.py -Q 3
+python3 ./test.py -f 2-query/last_row.py -Q 3

taos-tools @ 0b8a3373

-Subproject commit b7b922268c4a06d9db77ffdfde0726f3d9900b72
+Subproject commit 0b8a3373bb7548f8106d13e7d3b0a988d3c4d48a