From 34e62d7fc0ed10a195d69ac8f225786a989a5ff3 Mon Sep 17 00:00:00 2001
From: factosea <285808407@qq.com>
Date: Tue, 2 Jan 2024 20:22:15 +0800
Subject: [PATCH 01/47] fix: columanRefNode illegal type conversion

---
 include/libs/nodes/querynodes.h        |  1 +
 source/libs/parser/src/parTranslater.c | 22 ++++++++++++++++++++++
 2 files changed, 23 insertions(+)

diff --git a/include/libs/nodes/querynodes.h b/include/libs/nodes/querynodes.h
index 5c5172b9cd..3ce4365adc 100644
--- a/include/libs/nodes/querynodes.h
+++ b/include/libs/nodes/querynodes.h
@@ -88,6 +88,7 @@ typedef struct SColumnNode {
 } SColumnNode;
 
 typedef struct SColumnRefNode {
+  SExprNode node;  // QUERY_NODE_COLUMN
   ENodeType type;
   char      colName[TSDB_COL_NAME_LEN];
 } SColumnRefNode;
diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c
index c9345dd00e..6ce2905143 100644
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@@ -1094,6 +1094,7 @@ static EDealRes translateColumnUseAlias(STranslateContext* pCxt, SColumnNode** p
         return DEAL_RES_ERROR;
       }
       strcpy(pColRef->colName, pExpr->aliasName);
+      pColRef->node = *pExpr;
       nodesDestroyNode(*(SNode**)pCol);
       *(SNode**)pCol = (SNode*)pColRef;
       *pFound = true;
@@ -3431,6 +3432,24 @@ static int32_t getPositionValue(const SValueNode* pVal) {
   return -1;
 }
 
+static int32_t checkOrderByAggForGroupBy(STranslateContext* pCxt, SSelectStmt* pSelect, SNodeList* pOrderByList) {
+  if (NULL != getGroupByList(pCxt) || NULL != pSelect->pWindow) {
+    return TSDB_CODE_SUCCESS;
+  }
+  SNode* pNode = NULL;
+  WHERE_EACH(pNode, pOrderByList) {
+    SNode* pExpr = ((SOrderByExprNode*)pNode)->pExpr;
+    if ((QUERY_NODE_FUNCTION == nodeType(pExpr))) {
+      SFunctionNode* pFunc = (SFunctionNode*)pExpr;
+      if (fmIsAggFunc(pFunc->funcId)) {
+        return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_ILLEGAL_USE_AGG_FUNCTION);
+      }
+    }
+    WHERE_NEXT;
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
 static int32_t translateOrderByPosition(STranslateContext* pCxt, SNodeList* pProjectionList, SNodeList* pOrderByList,
                                         bool* pOther) {
   *pOther = false;
@@ -3482,6 +3501,9 @@ static int32_t translateOrderBy(STranslateContext* pCxt, SSelectStmt* pSelect) {
   if (TSDB_CODE_SUCCESS == code) {
     code = checkExprListForGroupBy(pCxt, pSelect, pSelect->pOrderByList);
   }
+  if (other && TSDB_CODE_SUCCESS == code) {
+    code = checkOrderByAggForGroupBy(pCxt, pSelect, pSelect->pOrderByList);
+  }
   return code;
 }
 

From b6b2a41d8331294d324a6c0aad614b122b2a9a6b Mon Sep 17 00:00:00 2001
From: factosea <285808407@qq.com>
Date: Wed, 3 Jan 2024 18:30:57 +0800
Subject: [PATCH 02/47] fix: columnrefnode

---
 include/libs/nodes/querynodes.h              |   2 +-
 source/libs/executor/src/aggregateoperator.c |   7 +-
 source/libs/function/src/builtins.c          | 215 ++++++++++---------
 source/libs/nodes/src/nodesUtilFuncs.c       |   2 +-
 source/libs/parser/src/parTranslater.c       |   2 +-
 5 files changed, 122 insertions(+), 106 deletions(-)

diff --git a/include/libs/nodes/querynodes.h b/include/libs/nodes/querynodes.h
index 3ce4365adc..6b481fc52e 100644
--- a/include/libs/nodes/querynodes.h
+++ b/include/libs/nodes/querynodes.h
@@ -88,8 +88,8 @@ typedef struct SColumnNode {
 } SColumnNode;
 
 typedef struct SColumnRefNode {
-  SExprNode node;  // QUERY_NODE_COLUMN
   ENodeType type;
+  SDataType resType;
   char      colName[TSDB_COL_NAME_LEN];
 } SColumnRefNode;
 
diff --git a/source/libs/executor/src/aggregateoperator.c b/source/libs/executor/src/aggregateoperator.c
index 2d0a044559..ae3d68d1f9 100644
--- a/source/libs/executor/src/aggregateoperator.c
+++ b/source/libs/executor/src/aggregateoperator.c
@@ -562,7 +562,12 @@ void applyAggFunctionOnPartialTuples(SExecTaskInfo* taskInfo, SqlFunctionCtx* pC
     } else {
       int32_t code = TSDB_CODE_SUCCESS;
       if (functionNeedToExecute(&pCtx[k]) && pCtx[k].fpSet.process != NULL) {
-        code = pCtx[k].fpSet.process(&pCtx[k]);
+        if ((&pCtx[k])->input.pData[0] == NULL) {
+          code = TSDB_CODE_TDB_INVALID_ACTION;
+          qError("%s apply functions error, input data is NULL.", GET_TASKID(taskInfo));
+        } else {
+          code = pCtx[k].fpSet.process(&pCtx[k]);
+        }
 
         if (code != TSDB_CODE_SUCCESS) {
           qError("%s apply functions error, code: %s", GET_TASKID(taskInfo), tstrerror(code));
diff --git a/source/libs/function/src/builtins.c b/source/libs/function/src/builtins.c
index 98fda024fa..089fc0f3b5 100644
--- a/source/libs/function/src/builtins.c
+++ b/source/libs/function/src/builtins.c
@@ -258,13 +258,24 @@ static int32_t addDbPrecisonParam(SNodeList** pList, uint8_t precision) {
   return TSDB_CODE_SUCCESS;
 }
 
+static SDataType* getSDataTypeFromNode(SNode* pNode) {
+  if (pNode == NULL) return NULL;
+  if (nodesIsExprNode(pNode)) {
+    return &((SExprNode*)pNode)->resType;
+  } else if (QUERY_NODE_COLUMN_REF == pNode->type) {
+    return &((SColumnRefNode*)pNode)->resType;
+  } else {
+    return NULL;
+  }
+}
+
 // There is only one parameter of numeric type, and the return type is parameter type
 static int32_t translateInOutNum(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
   if (1 != LIST_LENGTH(pFunc->pParameterList)) {
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t paraType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
   if (!IS_NUMERIC_TYPE(paraType) && !IS_NULL_TYPE(paraType)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   } else if (IS_NULL_TYPE(paraType)) {
@@ -281,7 +292,7 @@ static int32_t translateInNumOutDou(SFunctionNode* pFunc, char* pErrBuf, int32_t
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t paraType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
   if (!IS_NUMERIC_TYPE(paraType) && !IS_NULL_TYPE(paraType)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
@@ -296,8 +307,8 @@ static int32_t translateIn2NumOutDou(SFunctionNode* pFunc, char* pErrBuf, int32_
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t para1Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
-  uint8_t para2Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type;
+  uint8_t para1Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
+  uint8_t para2Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 1))->type;
   if ((!IS_NUMERIC_TYPE(para1Type) && !IS_NULL_TYPE(para1Type)) ||
       (!IS_NUMERIC_TYPE(para2Type) && !IS_NULL_TYPE(para2Type))) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
@@ -313,12 +324,12 @@ static int32_t translateInOutStr(SFunctionNode* pFunc, char* pErrBuf, int32_t le
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  SExprNode* pPara1 = (SExprNode*)nodesListGetNode(pFunc->pParameterList, 0);
-  if (TSDB_DATA_TYPE_VARBINARY == pPara1->resType.type || !IS_STR_DATA_TYPE(pPara1->resType.type)) {
+  SDataType* pRestType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0));
+  if (TSDB_DATA_TYPE_VARBINARY == pRestType->type || !IS_STR_DATA_TYPE(pRestType->type)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  pFunc->node.resType = (SDataType){.bytes = pPara1->resType.bytes, .type = pPara1->resType.type};
+  pFunc->node.resType = (SDataType){.bytes = pRestType->bytes, .type = pRestType->type};
   return TSDB_CODE_SUCCESS;
 }
 
@@ -327,8 +338,8 @@ static int32_t translateTrimStr(SFunctionNode* pFunc, char* pErrBuf, int32_t len
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  SExprNode* pPara1 = (SExprNode*)nodesListGetNode(pFunc->pParameterList, 0);
-  if (TSDB_DATA_TYPE_VARBINARY == pPara1->resType.type || !IS_STR_DATA_TYPE(pPara1->resType.type)) {
+  SDataType* pRestType1 = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0));
+  if (TSDB_DATA_TYPE_VARBINARY == pRestType1->type || !IS_STR_DATA_TYPE(pRestType1->type)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
@@ -342,8 +353,8 @@ static int32_t translateTrimStr(SFunctionNode* pFunc, char* pErrBuf, int32_t len
     numOfSpaces = countTrailingSpaces(pValue, isLtrim);
   }
 
-  int32_t resBytes = pPara1->resType.bytes - numOfSpaces;
-  pFunc->node.resType = (SDataType){.bytes = resBytes, .type = pPara1->resType.type};
+  int32_t resBytes = pRestType1->bytes - numOfSpaces;
+  pFunc->node.resType = (SDataType){.bytes = resBytes, .type = pRestType1->type};
   return TSDB_CODE_SUCCESS;
 }
 
@@ -361,13 +372,13 @@ static int32_t translateLogarithm(SFunctionNode* pFunc, char* pErrBuf, int32_t l
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t para1Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t para1Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
   if (!IS_NUMERIC_TYPE(para1Type) && !IS_NULL_TYPE(para1Type)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
   if (2 == numOfParams) {
-    uint8_t para2Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type;
+    uint8_t para2Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 1))->type;
     if (!IS_NUMERIC_TYPE(para2Type) && !IS_NULL_TYPE(para2Type)) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
     }
@@ -390,7 +401,7 @@ static int32_t translateSum(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t paraType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
   if (!IS_NUMERIC_TYPE(paraType) && !IS_NULL_TYPE(paraType)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
@@ -413,7 +424,7 @@ static int32_t translateAvgPartial(SFunctionNode* pFunc, char* pErrBuf, int32_t
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t paraType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
   if (!IS_NUMERIC_TYPE(paraType) && !IS_NULL_TYPE(paraType)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
@@ -427,7 +438,7 @@ static int32_t translateAvgMerge(SFunctionNode* pFunc, char* pErrBuf, int32_t le
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t paraType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
   if (TSDB_DATA_TYPE_BINARY != paraType) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
@@ -442,7 +453,7 @@ static int32_t translateStddevPartial(SFunctionNode* pFunc, char* pErrBuf, int32
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t paraType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
   if (!IS_NUMERIC_TYPE(paraType) && !IS_NULL_TYPE(paraType)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
@@ -456,7 +467,7 @@ static int32_t translateStddevMerge(SFunctionNode* pFunc, char* pErrBuf, int32_t
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t paraType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
   if (TSDB_DATA_TYPE_BINARY != paraType) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
@@ -515,7 +526,7 @@ static int32_t translatePercentile(SFunctionNode* pFunc, char* pErrBuf, int32_t
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t para1Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t para1Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
   if (!IS_NUMERIC_TYPE(para1Type)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
@@ -524,7 +535,7 @@ static int32_t translatePercentile(SFunctionNode* pFunc, char* pErrBuf, int32_t
     SValueNode* pValue = (SValueNode*)nodesListGetNode(pFunc->pParameterList, i);
     pValue->notReserved = true;
 
-    uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, i))->resType.type;
+    uint8_t paraType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, i))->type;
     if (!IS_NUMERIC_TYPE(paraType)) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
     }
@@ -577,15 +588,15 @@ static int32_t translateApercentile(SFunctionNode* pFunc, char* pErrBuf, int32_t
 
   pValue->notReserved = true;
 
-  uint8_t para1Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
-  uint8_t para2Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type;
+  uint8_t para1Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
+  uint8_t para2Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 1))->type;
   if (!IS_NUMERIC_TYPE(para1Type) || !IS_INTEGER_TYPE(para2Type)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
   // param2
   if (3 == numOfParams) {
-    uint8_t para3Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 2))->resType.type;
+    uint8_t para3Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 2))->type;
     if (!IS_STR_DATA_TYPE(para3Type)) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
     }
@@ -624,15 +635,15 @@ static int32_t translateApercentileImpl(SFunctionNode* pFunc, char* pErrBuf, int
 
     pValue->notReserved = true;
 
-    uint8_t para1Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
-    uint8_t para2Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type;
+    uint8_t para1Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
+    uint8_t para2Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 1))->type;
     if (!IS_NUMERIC_TYPE(para1Type) || !IS_INTEGER_TYPE(para2Type)) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
     }
 
     // param2
     if (3 == numOfParams) {
-      uint8_t para3Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 2))->resType.type;
+      uint8_t para3Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 2))->type;
       if (!IS_STR_DATA_TYPE(para3Type)) {
         return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
       }
@@ -654,14 +665,14 @@ static int32_t translateApercentileImpl(SFunctionNode* pFunc, char* pErrBuf, int
     if (3 != numOfParams && 2 != numOfParams) {
       return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
     }
-    uint8_t para1Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
-    uint8_t para2Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type;
+    uint8_t para1Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
+    uint8_t para2Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 1))->type;
     if (TSDB_DATA_TYPE_BINARY != para1Type || !IS_INTEGER_TYPE(para2Type)) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
     }
 
     if (3 == numOfParams) {
-      uint8_t para3Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 2))->resType.type;
+      uint8_t para3Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 2))->type;
       if (!IS_STR_DATA_TYPE(para3Type)) {
         return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
       }
@@ -715,8 +726,8 @@ static int32_t translateTopBot(SFunctionNode* pFunc, char* pErrBuf, int32_t len)
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t para1Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
-  uint8_t para2Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type;
+  uint8_t para1Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
+  uint8_t para2Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 1))->type;
   if (!IS_NUMERIC_TYPE(para1Type) || !IS_INTEGER_TYPE(para2Type)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
@@ -739,7 +750,7 @@ static int32_t translateTopBot(SFunctionNode* pFunc, char* pErrBuf, int32_t len)
   pValue->notReserved = true;
 
   // set result type
-  SDataType* pType = &((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType;
+  SDataType* pType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0));
   pFunc->node.resType = (SDataType){.bytes = pType->bytes, .type = pType->type};
   return TSDB_CODE_SUCCESS;
 }
@@ -769,7 +780,7 @@ static int32_t translateSpread(SFunctionNode* pFunc, char* pErrBuf, int32_t len)
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t paraType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
   if (!IS_NUMERIC_TYPE(paraType) && !IS_TIMESTAMP_TYPE(paraType)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
@@ -783,7 +794,7 @@ static int32_t translateSpreadImpl(SFunctionNode* pFunc, char* pErrBuf, int32_t
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t paraType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
   if (isPartial) {
     if (!IS_NUMERIC_TYPE(paraType) && !IS_TIMESTAMP_TYPE(paraType)) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
@@ -859,7 +870,7 @@ static int32_t translateElapsedImpl(SFunctionNode* pFunc, char* pErrBuf, int32_t
       return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
     }
 
-    uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+    uint8_t paraType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
     if (!IS_TIMESTAMP_TYPE(paraType)) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
     }
@@ -867,6 +878,7 @@ static int32_t translateElapsedImpl(SFunctionNode* pFunc, char* pErrBuf, int32_t
     // param1
     if (2 == numOfParams) {
       SNode* pParamNode1 = nodesListGetNode(pFunc->pParameterList, 1);
+
       if (QUERY_NODE_VALUE != nodeType(pParamNode1)) {
         return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
       }
@@ -875,7 +887,7 @@ static int32_t translateElapsedImpl(SFunctionNode* pFunc, char* pErrBuf, int32_t
 
       pValue->notReserved = true;
 
-      paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type;
+      paraType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 1))->type;
       if (!IS_INTEGER_TYPE(paraType)) {
         return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
       }
@@ -893,7 +905,7 @@ static int32_t translateElapsedImpl(SFunctionNode* pFunc, char* pErrBuf, int32_t
       return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
     }
 
-    uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+    uint8_t paraType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
     if (TSDB_DATA_TYPE_BINARY != paraType) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
     }
@@ -934,7 +946,7 @@ static int32_t translateLeastSQR(SFunctionNode* pFunc, char* pErrBuf, int32_t le
       pValue->notReserved = true;
     }
 
-    uint8_t colType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, i))->resType.type;
+    uint8_t colType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, i))->type;
     if (!IS_NUMERIC_TYPE(colType)) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
     }
@@ -1128,15 +1140,15 @@ static int32_t translateHistogram(SFunctionNode* pFunc, char* pErrBuf, int32_t l
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t colType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t colType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
   if (!IS_NUMERIC_TYPE(colType)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
   // param1 ~ param3
-  if (((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type != TSDB_DATA_TYPE_BINARY ||
-      ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 2))->resType.type != TSDB_DATA_TYPE_BINARY ||
-      !IS_INTEGER_TYPE(((SExprNode*)nodesListGetNode(pFunc->pParameterList, 3))->resType.type)) {
+  if (getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 1))->type != TSDB_DATA_TYPE_BINARY ||
+      getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 2))->type != TSDB_DATA_TYPE_BINARY ||
+      !IS_INTEGER_TYPE(getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 3))->type)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
@@ -1186,15 +1198,15 @@ static int32_t translateHistogramImpl(SFunctionNode* pFunc, char* pErrBuf, int32
       return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
     }
 
-    uint8_t colType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+    uint8_t colType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
     if (!IS_NUMERIC_TYPE(colType)) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
     }
 
     // param1 ~ param3
-    if (((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type != TSDB_DATA_TYPE_BINARY ||
-        ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 2))->resType.type != TSDB_DATA_TYPE_BINARY ||
-        !IS_INTEGER_TYPE(((SExprNode*)nodesListGetNode(pFunc->pParameterList, 3))->resType.type)) {
+    if (getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 1))->type != TSDB_DATA_TYPE_BINARY ||
+        getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 2))->type != TSDB_DATA_TYPE_BINARY ||
+        !IS_INTEGER_TYPE(getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 3))->type)) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
     }
 
@@ -1240,7 +1252,7 @@ static int32_t translateHistogramImpl(SFunctionNode* pFunc, char* pErrBuf, int32
       return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
     }
 
-    if (((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type != TSDB_DATA_TYPE_BINARY) {
+    if (getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type != TSDB_DATA_TYPE_BINARY) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
     }
 
@@ -1305,7 +1317,7 @@ static int32_t translateStateCount(SFunctionNode* pFunc, char* pErrBuf, int32_t
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t colType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t colType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
   if (!IS_NUMERIC_TYPE(colType)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
@@ -1328,9 +1340,9 @@ static int32_t translateStateCount(SFunctionNode* pFunc, char* pErrBuf, int32_t
     pValue->notReserved = true;
   }
 
-  if (((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type != TSDB_DATA_TYPE_BINARY ||
-      (((SExprNode*)nodesListGetNode(pFunc->pParameterList, 2))->resType.type != TSDB_DATA_TYPE_BIGINT &&
-       ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 2))->resType.type != TSDB_DATA_TYPE_DOUBLE)) {
+  if (getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 1))->type != TSDB_DATA_TYPE_BINARY ||
+      (getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 2))->type != TSDB_DATA_TYPE_BIGINT &&
+       getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 2))->type != TSDB_DATA_TYPE_DOUBLE)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
@@ -1345,7 +1357,7 @@ static int32_t translateStateDuration(SFunctionNode* pFunc, char* pErrBuf, int32
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t colType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t colType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
   if (!IS_NUMERIC_TYPE(colType)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
@@ -1371,14 +1383,14 @@ static int32_t translateStateDuration(SFunctionNode* pFunc, char* pErrBuf, int32
     pValue->notReserved = true;
   }
 
-  if (((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type != TSDB_DATA_TYPE_BINARY ||
-      (((SExprNode*)nodesListGetNode(pFunc->pParameterList, 2))->resType.type != TSDB_DATA_TYPE_BIGINT &&
-       ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 2))->resType.type != TSDB_DATA_TYPE_DOUBLE)) {
+  if (getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 1))->type != TSDB_DATA_TYPE_BINARY ||
+      (getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 2))->type != TSDB_DATA_TYPE_BIGINT &&
+       getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 2))->type != TSDB_DATA_TYPE_DOUBLE)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
   if (numOfParams == 4 &&
-      ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 3))->resType.type != TSDB_DATA_TYPE_BIGINT) {
+      getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 3))->type != TSDB_DATA_TYPE_BIGINT) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
@@ -1406,7 +1418,7 @@ static int32_t translateCsum(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t colType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t colType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
   uint8_t resType;
   if (!IS_NUMERIC_TYPE(colType)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
@@ -1433,8 +1445,7 @@ static int32_t translateMavg(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t colType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
-
+  uint8_t colType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
   // param1
   SNode* pParamNode1 = nodesListGetNode(pFunc->pParameterList, 1);
   if (QUERY_NODE_VALUE != nodeType(pParamNode1)) {
@@ -1448,7 +1459,7 @@ static int32_t translateMavg(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
 
   pValue->notReserved = true;
 
-  uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type;
+  uint8_t paraType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 1))->type;
   if (!IS_NUMERIC_TYPE(colType) || !IS_INTEGER_TYPE(paraType)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
@@ -1462,8 +1473,8 @@ static int32_t translateSample(SFunctionNode* pFunc, char* pErrBuf, int32_t len)
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  SExprNode* pCol = (SExprNode*)nodesListGetNode(pFunc->pParameterList, 0);
-  uint8_t    colType = pCol->resType.type;
+  SDataType* pSDataType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0));
+  uint8_t    colType = pSDataType->type;
 
   // param1
   SNode* pParamNode1 = nodesListGetNode(pFunc->pParameterList, 1);
@@ -1478,14 +1489,14 @@ static int32_t translateSample(SFunctionNode* pFunc, char* pErrBuf, int32_t len)
 
   pValue->notReserved = true;
 
-  uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type;
+  uint8_t paraType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 1))->type;
   if (!IS_INTEGER_TYPE(paraType)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
   // set result type
   if (IS_STR_DATA_TYPE(colType)) {
-    pFunc->node.resType = (SDataType){.bytes = pCol->resType.bytes, .type = colType};
+    pFunc->node.resType = (SDataType){.bytes = pSDataType->bytes, .type = colType};
   } else {
     pFunc->node.resType = (SDataType){.bytes = tDataTypes[colType].bytes, .type = colType};
   }
@@ -1499,8 +1510,8 @@ static int32_t translateTail(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  SExprNode* pCol = (SExprNode*)nodesListGetNode(pFunc->pParameterList, 0);
-  uint8_t    colType = pCol->resType.type;
+  SDataType* pSDataType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0));
+  uint8_t    colType = pSDataType->type;
 
   // param1 & param2
   for (int32_t i = 1; i < numOfParams; ++i) {
@@ -1520,7 +1531,7 @@ static int32_t translateTail(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
 
     pValue->notReserved = true;
 
-    uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, i))->resType.type;
+    uint8_t paraType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, i))->type;
     if (!IS_INTEGER_TYPE(paraType)) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
     }
@@ -1528,7 +1539,7 @@ static int32_t translateTail(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
 
   // set result type
   if (IS_STR_DATA_TYPE(colType)) {
-    pFunc->node.resType = (SDataType){.bytes = pCol->resType.bytes, .type = colType};
+    pFunc->node.resType = (SDataType){.bytes = pSDataType->bytes, .type = colType};
   } else {
     pFunc->node.resType = (SDataType){.bytes = tDataTypes[colType].bytes, .type = colType};
   }
@@ -1540,7 +1551,7 @@ static int32_t translateDerivative(SFunctionNode* pFunc, char* pErrBuf, int32_t
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t colType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t colType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
 
   // param1
   SNode*      pParamNode1 = nodesListGetNode(pFunc->pParameterList, 1);
@@ -1582,7 +1593,7 @@ static int32_t translateIrate(SFunctionNode* pFunc, char* pErrBuf, int32_t len)
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t colType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t colType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
 
   if (!IS_NUMERIC_TYPE(colType)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
@@ -1600,7 +1611,7 @@ static int32_t translateIrate(SFunctionNode* pFunc, char* pErrBuf, int32_t len)
 }
 
 static int32_t translateIrateImpl(SFunctionNode* pFunc, char* pErrBuf, int32_t len, bool isPartial) {
-  uint8_t colType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t colType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
   if (isPartial) {
     if (3 != LIST_LENGTH(pFunc->pParameterList)) {
       return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
@@ -1647,14 +1658,14 @@ static int32_t translateInterp(SFunctionNode* pFunc, char* pErrBuf, int32_t len)
   }
 
   uint8_t nodeType = nodeType(nodesListGetNode(pFunc->pParameterList, 0));
-  uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t paraType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
   if ((!IS_NUMERIC_TYPE(paraType) && !IS_BOOLEAN_TYPE(paraType)) || QUERY_NODE_VALUE == nodeType) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
   if (2 == numOfParams) {
     nodeType = nodeType(nodesListGetNode(pFunc->pParameterList, 1));
-    paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type;
+    paraType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 1))->type;
     if (!IS_INTEGER_TYPE(paraType) || QUERY_NODE_VALUE != nodeType) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
     }
@@ -1728,26 +1739,26 @@ static int32_t translateFirstLast(SFunctionNode* pFunc, char* pErrBuf, int32_t l
 
   for (int32_t i = 0; i < numOfParams; ++i) {
     uint8_t nodeType = nodeType(nodesListGetNode(pFunc->pParameterList, i));
-    uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, i))->resType.type;
+    uint8_t paraType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, i))->type;
     if (IS_NULL_TYPE(paraType) && QUERY_NODE_VALUE == nodeType) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
     }
   }
 
-  pFunc->node.resType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType;
+  pFunc->node.resType = *getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0));
   return TSDB_CODE_SUCCESS;
 }
 
 static int32_t translateFirstLastImpl(SFunctionNode* pFunc, char* pErrBuf, int32_t len, bool isPartial) {
   // first(col_list) will be rewritten as first(col)
   SNode*  pPara = nodesListGetNode(pFunc->pParameterList, 0);
-  uint8_t paraType = ((SExprNode*)pPara)->resType.type;
-  int32_t paraBytes = ((SExprNode*)pPara)->resType.bytes;
+  uint8_t paraType = getSDataTypeFromNode(pPara)->type;
+  int32_t paraBytes = getSDataTypeFromNode(pPara)->bytes;
   if (isPartial) {
     int32_t numOfParams = LIST_LENGTH(pFunc->pParameterList);
     for (int32_t i = 0; i < numOfParams; ++i) {
       uint8_t nodeType = nodeType(nodesListGetNode(pFunc->pParameterList, i));
-      uint8_t pType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, i))->resType.type;
+      uint8_t pType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, i))->type;
       if (IS_NULL_TYPE(pType) && QUERY_NODE_VALUE == nodeType) {
         return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
       }
@@ -1802,7 +1813,7 @@ static int32_t translateDiff(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t colType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t colType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
   if (!IS_INTEGER_TYPE(colType) && !IS_FLOAT_TYPE(colType) && TSDB_DATA_TYPE_BOOL != colType &&
       !IS_TIMESTAMP_TYPE(colType)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
@@ -1810,7 +1821,7 @@ static int32_t translateDiff(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
 
   // param1
   if (numOfParams == 2) {
-    uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type;
+    uint8_t paraType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 1))->type;
     if (!IS_INTEGER_TYPE(paraType)) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
     }
@@ -1854,7 +1865,7 @@ static int32_t translateLength(SFunctionNode* pFunc, char* pErrBuf, int32_t len)
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  if (!IS_STR_DATA_TYPE(((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type)) {
+  if (!IS_STR_DATA_TYPE(getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
@@ -1885,7 +1896,7 @@ static int32_t translateConcatImpl(SFunctionNode* pFunc, char* pErrBuf, int32_t
   /* For concat/concat_ws function, if params have NCHAR type, promote the final result to NCHAR */
   for (int32_t i = 0; i < numOfParams; ++i) {
     SNode*  pPara = nodesListGetNode(pFunc->pParameterList, i);
-    uint8_t paraType = ((SExprNode*)pPara)->resType.type;
+    uint8_t paraType = getSDataTypeFromNode(pPara)->type;
     if (TSDB_DATA_TYPE_VARBINARY == paraType) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
     }
@@ -1900,8 +1911,8 @@ static int32_t translateConcatImpl(SFunctionNode* pFunc, char* pErrBuf, int32_t
 
   for (int32_t i = 0; i < numOfParams; ++i) {
     SNode*  pPara = nodesListGetNode(pFunc->pParameterList, i);
-    uint8_t paraType = ((SExprNode*)pPara)->resType.type;
-    int32_t paraBytes = ((SExprNode*)pPara)->resType.bytes;
+    uint8_t paraType = getSDataTypeFromNode(pPara)->type;
+    int32_t paraBytes = getSDataTypeFromNode(pPara)->bytes;
     int32_t factor = 1;
     if (IS_NULL_TYPE(paraType)) {
       resultType = TSDB_DATA_TYPE_VARCHAR;
@@ -2009,7 +2020,7 @@ static int32_t translateToIso8601(SFunctionNode* pFunc, char* pErrBuf, int32_t l
   }
 
   // param0
-  uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t paraType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
   if (!IS_INTEGER_TYPE(paraType) && !IS_TIMESTAMP_TYPE(paraType)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
@@ -2050,13 +2061,13 @@ static int32_t translateToUnixtimestamp(SFunctionNode* pFunc, char* pErrBuf, int
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t para1Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t para1Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
   if (para1Type == TSDB_DATA_TYPE_VARBINARY || !IS_STR_DATA_TYPE(para1Type)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
   if (2 == numOfParams) {
-    uint8_t para2Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type;
+    uint8_t para2Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 1))->type;
     if (!IS_INTEGER_TYPE(para2Type)) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
     }
@@ -2087,8 +2098,8 @@ static int32_t translateToTimestamp(SFunctionNode* pFunc, char* pErrBuf, int32_t
   if (LIST_LENGTH(pFunc->pParameterList) != 2) {
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
-  uint8_t para1Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
-  uint8_t para2Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type;
+  uint8_t para1Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
+  uint8_t para2Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 1))->type;
   if (!IS_STR_DATA_TYPE(para1Type) || !IS_STR_DATA_TYPE(para2Type)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
@@ -2101,8 +2112,8 @@ static int32_t translateToChar(SFunctionNode* pFunc, char* pErrBuf, int32_t len)
   if (LIST_LENGTH(pFunc->pParameterList) != 2) {
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
-  uint8_t para1Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
-  uint8_t para2Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type;
+  uint8_t para1Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
+  uint8_t para2Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 1))->type;
   // currently only support to_char(timestamp, str)
   if (!IS_STR_DATA_TYPE(para2Type) || !IS_TIMESTAMP_TYPE(para1Type)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
@@ -2117,8 +2128,8 @@ static int32_t translateTimeTruncate(SFunctionNode* pFunc, char* pErrBuf, int32_
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t para1Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
-  uint8_t para2Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type;
+  uint8_t para1Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
+  uint8_t para2Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 1))->type;
   if ((!IS_STR_DATA_TYPE(para1Type) && !IS_INTEGER_TYPE(para1Type) && !IS_TIMESTAMP_TYPE(para1Type)) ||
       !IS_INTEGER_TYPE(para2Type)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
@@ -2136,7 +2147,7 @@ static int32_t translateTimeTruncate(SFunctionNode* pFunc, char* pErrBuf, int32_
   }
 
   if (3 == numOfParams) {
-    uint8_t para3Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 2))->resType.type;
+    uint8_t para3Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 2))->type;
     if (!IS_INTEGER_TYPE(para3Type)) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
     }
@@ -2171,14 +2182,14 @@ static int32_t translateTimeDiff(SFunctionNode* pFunc, char* pErrBuf, int32_t le
   }
 
   for (int32_t i = 0; i < 2; ++i) {
-    uint8_t paraType = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, i))->resType.type;
+    uint8_t paraType = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, i))->type;
     if (!IS_STR_DATA_TYPE(paraType) && !IS_INTEGER_TYPE(paraType) && !IS_TIMESTAMP_TYPE(paraType)) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
     }
   }
 
   if (3 == numOfParams) {
-    if (!IS_INTEGER_TYPE(((SExprNode*)nodesListGetNode(pFunc->pParameterList, 2))->resType.type)) {
+    if (!IS_INTEGER_TYPE(getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 2))->type)) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
     }
   }
@@ -2226,7 +2237,7 @@ static int32_t translateInStrOutGeom(SFunctionNode* pFunc, char* pErrBuf, int32_
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t para1Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t para1Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
   if (!IS_STR_DATA_TYPE(para1Type) && !IS_NULL_TYPE(para1Type)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
@@ -2241,7 +2252,7 @@ static int32_t translateInGeomOutStr(SFunctionNode* pFunc, char* pErrBuf, int32_
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t para1Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t para1Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
   if (para1Type != TSDB_DATA_TYPE_GEOMETRY && !IS_NULL_TYPE(para1Type)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
@@ -2256,8 +2267,8 @@ static int32_t translateIn2NumOutGeom(SFunctionNode* pFunc, char* pErrBuf, int32
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t para1Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
-  uint8_t para2Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type;
+  uint8_t para1Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
+  uint8_t para2Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 1))->type;
   if ((!IS_NUMERIC_TYPE(para1Type) && !IS_NULL_TYPE(para1Type)) ||
       (!IS_NUMERIC_TYPE(para2Type) && !IS_NULL_TYPE(para2Type))) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
@@ -2273,8 +2284,8 @@ static int32_t translateIn2GeomOutBool(SFunctionNode* pFunc, char* pErrBuf, int3
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t para1Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
-  uint8_t para2Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type;
+  uint8_t para1Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 0))->type;
+  uint8_t para2Type = getSDataTypeFromNode(nodesListGetNode(pFunc->pParameterList, 1))->type;
   if ((para1Type != TSDB_DATA_TYPE_GEOMETRY && !IS_NULL_TYPE(para1Type)) ||
       (para2Type != TSDB_DATA_TYPE_GEOMETRY && !IS_NULL_TYPE(para2Type))) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
diff --git a/source/libs/nodes/src/nodesUtilFuncs.c b/source/libs/nodes/src/nodesUtilFuncs.c
index 8f2e82385b..3675b0b9c4 100644
--- a/source/libs/nodes/src/nodesUtilFuncs.c
+++ b/source/libs/nodes/src/nodesUtilFuncs.c
@@ -295,7 +295,7 @@ SNode* nodesMakeNode(ENodeType type) {
     case QUERY_NODE_LEFT_VALUE:
       return makeNode(type, sizeof(SLeftValueNode));
     case QUERY_NODE_COLUMN_REF:
-      return makeNode(type, sizeof(SColumnDefNode));
+      return makeNode(type, sizeof(SColumnRefNode));
     case QUERY_NODE_WHEN_THEN:
       return makeNode(type, sizeof(SWhenThenNode));
     case QUERY_NODE_CASE_WHEN:
diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c
index 6ce2905143..33847d50dd 100644
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@@ -1094,7 +1094,7 @@ static EDealRes translateColumnUseAlias(STranslateContext* pCxt, SColumnNode** p
         return DEAL_RES_ERROR;
       }
       strcpy(pColRef->colName, pExpr->aliasName);
-      pColRef->node = *pExpr;
+      pColRef->resType = pExpr->resType;
       nodesDestroyNode(*(SNode**)pCol);
       *(SNode**)pCol = (SNode*)pColRef;
       *pFound = true;

From 8dc2a6bbd97c0aaacacda7821660659fecb0a4fc Mon Sep 17 00:00:00 2001
From: factosea <285808407@qq.com>
Date: Wed, 3 Jan 2024 20:43:23 +0800
Subject: [PATCH 03/47] fix: orderby

---
 source/libs/executor/src/aggregateoperator.c | 9 ++++++++-
 source/libs/parser/src/parTranslater.c       | 8 ++++----
 2 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/source/libs/executor/src/aggregateoperator.c b/source/libs/executor/src/aggregateoperator.c
index ae3d68d1f9..f4c450f1ce 100644
--- a/source/libs/executor/src/aggregateoperator.c
+++ b/source/libs/executor/src/aggregateoperator.c
@@ -273,6 +273,7 @@ SSDataBlock* getAggregateResult(SOperatorInfo* pOperator) {
 }
 
 int32_t doAggregateImpl(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx) {
+  int32_t code = TSDB_CODE_SUCCESS;
   for (int32_t k = 0; k < pOperator->exprSupp.numOfExprs; ++k) {
     if (functionNeedToExecute(&pCtx[k])) {
       // todo add a dummy funtion to avoid process check
@@ -280,7 +281,13 @@ int32_t doAggregateImpl(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx) {
         continue;
       }
 
-      int32_t code = pCtx[k].fpSet.process(&pCtx[k]);
+      if ((&pCtx[k])->input.pData[0] == NULL) {
+        code = TSDB_CODE_TDB_INVALID_ACTION;
+        qError("%s aggregate function error happens, input data is NULL.", GET_TASKID(pOperator->pTaskInfo));
+      } else {
+        code = pCtx[k].fpSet.process(&pCtx[k]);
+      }
+
       if (code != TSDB_CODE_SUCCESS) {
         qError("%s aggregate function error happens, code: %s", GET_TASKID(pOperator->pTaskInfo), tstrerror(code));
         return code;
diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c
index 33847d50dd..85da24ab14 100644
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@@ -3442,7 +3442,7 @@ static int32_t checkOrderByAggForGroupBy(STranslateContext* pCxt, SSelectStmt* p
     if ((QUERY_NODE_FUNCTION == nodeType(pExpr))) {
       SFunctionNode* pFunc = (SFunctionNode*)pExpr;
       if (fmIsAggFunc(pFunc->funcId)) {
-        return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_ILLEGAL_USE_AGG_FUNCTION);
+        return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_NOT_SINGLE_GROUP);
       }
     }
     WHERE_NEXT;
@@ -3501,9 +3501,9 @@ static int32_t translateOrderBy(STranslateContext* pCxt, SSelectStmt* pSelect) {
   if (TSDB_CODE_SUCCESS == code) {
     code = checkExprListForGroupBy(pCxt, pSelect, pSelect->pOrderByList);
   }
-  if (other && TSDB_CODE_SUCCESS == code) {
-    code = checkOrderByAggForGroupBy(pCxt, pSelect, pSelect->pOrderByList);
-  }
+  // if (other && TSDB_CODE_SUCCESS == code) {
+  //   code = checkOrderByAggForGroupBy(pCxt, pSelect, pSelect->pOrderByList);
+  // }
   return code;
 }
 

From 8c3fe7cc703a751fdd2d7f09da0431461897d31d Mon Sep 17 00:00:00 2001
From: factosea <285808407@qq.com>
Date: Mon, 8 Jan 2024 11:41:58 +0800
Subject: [PATCH 04/47] fix: SColumnRefNode transfer to SelectFunction's param

---
 source/libs/executor/src/aggregateoperator.c |  4 +--
 source/libs/parser/src/parTranslater.c       | 26 ++++++++++++++++----
 source/libs/parser/test/parSelectTest.cpp    | 22 +++++++++++++++++
 tests/system-test/2-query/orderBy.py         | 11 +++++++++
 4 files changed, 56 insertions(+), 7 deletions(-)

diff --git a/source/libs/executor/src/aggregateoperator.c b/source/libs/executor/src/aggregateoperator.c
index f4c450f1ce..63156de881 100644
--- a/source/libs/executor/src/aggregateoperator.c
+++ b/source/libs/executor/src/aggregateoperator.c
@@ -282,7 +282,7 @@ int32_t doAggregateImpl(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx) {
       }
 
       if ((&pCtx[k])->input.pData[0] == NULL) {
-        code = TSDB_CODE_TDB_INVALID_ACTION;
+        code = TSDB_CODE_PAR_NOT_SINGLE_GROUP;
         qError("%s aggregate function error happens, input data is NULL.", GET_TASKID(pOperator->pTaskInfo));
       } else {
         code = pCtx[k].fpSet.process(&pCtx[k]);
@@ -570,7 +570,7 @@ void applyAggFunctionOnPartialTuples(SExecTaskInfo* taskInfo, SqlFunctionCtx* pC
       int32_t code = TSDB_CODE_SUCCESS;
       if (functionNeedToExecute(&pCtx[k]) && pCtx[k].fpSet.process != NULL) {
         if ((&pCtx[k])->input.pData[0] == NULL) {
-          code = TSDB_CODE_TDB_INVALID_ACTION;
+          code = TSDB_CODE_PAR_NOT_SINGLE_GROUP;
           qError("%s apply functions error, input data is NULL.", GET_TASKID(taskInfo));
         } else {
           code = pCtx[k].fpSet.process(&pCtx[k]);
diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c
index 85da24ab14..1ba48fa0d4 100644
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@@ -2757,7 +2757,7 @@ static int32_t checkAggColCoexist(STranslateContext* pCxt, SSelectStmt* pSelect)
   if (!pSelect->isDistinct) {
     nodesRewriteExprs(pSelect->pOrderByList, doCheckAggColCoexist, &cxt);
   }
-  if (1 == pSelect->selectFuncNum && !pSelect->hasOtherVectorFunc) {
+  if (0 < pSelect->selectFuncNum && !pSelect->hasOtherVectorFunc) {
     return rewriteColsToSelectValFunc(pCxt, pSelect);
   }
   if (cxt.existCol) {
@@ -3436,6 +3436,12 @@ static int32_t checkOrderByAggForGroupBy(STranslateContext* pCxt, SSelectStmt* p
   if (NULL != getGroupByList(pCxt) || NULL != pSelect->pWindow) {
     return TSDB_CODE_SUCCESS;
   }
+  SNode* pProject = NULL;
+  FOREACH(pProject, pSelect->pProjectionList) {
+    if(isAggFunc(pProject)) {
+      return TSDB_CODE_SUCCESS;
+    }
+  }
   SNode* pNode = NULL;
   WHERE_EACH(pNode, pOrderByList) {
     SNode* pExpr = ((SOrderByExprNode*)pNode)->pExpr;
@@ -3501,9 +3507,9 @@ static int32_t translateOrderBy(STranslateContext* pCxt, SSelectStmt* pSelect) {
   if (TSDB_CODE_SUCCESS == code) {
     code = checkExprListForGroupBy(pCxt, pSelect, pSelect->pOrderByList);
   }
-  // if (other && TSDB_CODE_SUCCESS == code) {
-  //   code = checkOrderByAggForGroupBy(pCxt, pSelect, pSelect->pOrderByList);
-  // }
+  if (other && TSDB_CODE_SUCCESS == code) {
+    code = checkOrderByAggForGroupBy(pCxt, pSelect, pSelect->pOrderByList);
+  }
   return code;
 }
 
@@ -4505,8 +4511,18 @@ static EDealRes replaceOrderByAliasImpl(SNode** pNode, void* pContext) {
     SNode*     pProject = NULL;
     FOREACH(pProject, pProjectionList) {
       SExprNode* pExpr = (SExprNode*)pProject;
+      SNode* activeNode = pProject;
       if (0 == strcmp(((SColumnRefNode*)*pNode)->colName, pExpr->aliasName)) {
-        SNode* pNew = nodesCloneNode(pProject);
+        if(QUERY_NODE_FUNCTION == pProject->type && strcmp(((SFunctionNode*)pProject)->functionName, "_select_value") == 0) {
+          SNode*     paramNode = NULL;
+          FOREACH(paramNode, ((SFunctionNode*)pProject)->pParameterList) {
+            SExprNode* pExpr2 = (SExprNode*)pProject;
+            if (0 == strcmp(((SColumnRefNode*)*pNode)->colName, pExpr2->aliasName)) {
+              activeNode = paramNode;
+            }
+          }
+        }
+        SNode* pNew = nodesCloneNode(activeNode);
         if (NULL == pNew) {
           pCxt->pTranslateCxt->errCode = TSDB_CODE_OUT_OF_MEMORY;
           return DEAL_RES_ERROR;
diff --git a/source/libs/parser/test/parSelectTest.cpp b/source/libs/parser/test/parSelectTest.cpp
index 53d97d0699..dce702f6b6 100644
--- a/source/libs/parser/test/parSelectTest.cpp
+++ b/source/libs/parser/test/parSelectTest.cpp
@@ -413,6 +413,28 @@ TEST_F(ParserSelectTest, semanticCheck) {
 
   run("SELECT c1 FROM t1 order by COUNT(*)", TSDB_CODE_PAR_NOT_SINGLE_GROUP);
 
+  run("SELECT COUNT(*) FROM t1 order by COUNT(*)");
+
+  run("SELECT COUNT(*) FROM t1 order by last(c2)");
+
+  run("SELECT c1 FROM t1 order by last(ts)", TSDB_CODE_PAR_NOT_SINGLE_GROUP);
+
+  run("SELECT ts FROM t1 order by last(ts)", TSDB_CODE_PAR_NOT_SINGLE_GROUP);
+
+  run("SELECT c2 FROM t1 order by last(ts)", TSDB_CODE_PAR_NOT_SINGLE_GROUP);
+
+  run("SELECT * FROM t1 order by last(ts)", TSDB_CODE_PAR_NOT_SINGLE_GROUP);
+
+  run("SELECT last(ts) FROM t1 order by last(ts)");
+
+  run("SELECT last(ts), ts, c1 FROM t1 order by last(ts)");
+
+  run("SELECT ts, last(ts) FROM t1 order by last(ts)");
+
+  run("SELECT first(ts), c2 FROM t1 order by last(c1)");
+
+  run("SELECT c1 FROM t1 order by concat(c2, 'abc')");
+
   // TSDB_CODE_PAR_NOT_SELECTED_EXPRESSION
   run("SELECT distinct c1, c2 FROM t1 WHERE c1 > 0 order by ts", TSDB_CODE_PAR_NOT_SELECTED_EXPRESSION);
 
diff --git a/tests/system-test/2-query/orderBy.py b/tests/system-test/2-query/orderBy.py
index fa447cbca4..162a5c6e26 100644
--- a/tests/system-test/2-query/orderBy.py
+++ b/tests/system-test/2-query/orderBy.py
@@ -276,6 +276,14 @@ class TDTestCase:
         sql2 = "select count(*) as a, count(c2) as b, max(c2) as c, min(c2) as d, sum(c2) as e  from st;"
         self.queryResultSame(sql1, sql2)
 
+    def queryOrderByAgg(self):
+
+        tdSql.error(f"SELECT * FROM t1 order by last(ts)")
+
+        tdSql.query(f"SELECT last(ts) FROM t1 order by last(ts)")
+
+        tdSql.query(f"SELECT last(ts), ts FROM t1 order by last(ts)")
+
     # run
     def run(self):
         # prepare env
@@ -287,6 +295,9 @@ class TDTestCase:
         # advance
         self.queryAdvance()
 
+        # agg
+        self.queryOrderByAgg()
+
 
     # stop
     def stop(self):

From 45ec9fcbc87c9b002fbbde97c2553f882e6e31ba Mon Sep 17 00:00:00 2001
From: factosea <285808407@qq.com>
Date: Mon, 8 Jan 2024 16:43:57 +0800
Subject: [PATCH 05/47] fix: create param node from function node

---
 source/libs/executor/src/executil.c    | 10 ++++++++++
 source/libs/parser/src/parTranslater.c |  9 ---------
 2 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c
index 825d716926..5e28621f7b 100644
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@@ -1477,6 +1477,16 @@ void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) {
         SValueNode* pvn = (SValueNode*)p1;
         pExp->base.pParam[j].type = FUNC_PARAM_TYPE_VALUE;
         nodesValueNodeToVariant(pvn, &pExp->base.pParam[j].param);
+      } else if (p1->type == QUERY_NODE_FUNCTION) {
+        if (strcmp(((SFunctionNode*)p1)->functionName, "_select_value") == 0 &&
+          ((SFunctionNode*)p1)->pParameterList->length == 1 &&
+          ((SFunctionNode*)p1)->pParameterList->pHead->pNode->type == QUERY_NODE_COLUMN) {
+            SColumnNode* pcn = (SColumnNode*)(((SFunctionNode*)p1)->pParameterList->pHead->pNode);
+            SValueNode* pvn = (SValueNode*)p1;
+            pExp->base.pParam[j].type = FUNC_PARAM_TYPE_COLUMN;
+            pExp->base.pParam[j].pCol =
+              createColumn(pcn->dataBlockId, pcn->slotId, pcn->colId, &pcn->node.resType, pcn->colType);
+        }
       }
     }
   } else if (type == QUERY_NODE_OPERATOR) {
diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c
index 1ba48fa0d4..08e794f169 100644
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@@ -4513,15 +4513,6 @@ static EDealRes replaceOrderByAliasImpl(SNode** pNode, void* pContext) {
       SExprNode* pExpr = (SExprNode*)pProject;
       SNode* activeNode = pProject;
       if (0 == strcmp(((SColumnRefNode*)*pNode)->colName, pExpr->aliasName)) {
-        if(QUERY_NODE_FUNCTION == pProject->type && strcmp(((SFunctionNode*)pProject)->functionName, "_select_value") == 0) {
-          SNode*     paramNode = NULL;
-          FOREACH(paramNode, ((SFunctionNode*)pProject)->pParameterList) {
-            SExprNode* pExpr2 = (SExprNode*)pProject;
-            if (0 == strcmp(((SColumnRefNode*)*pNode)->colName, pExpr2->aliasName)) {
-              activeNode = paramNode;
-            }
-          }
-        }
         SNode* pNew = nodesCloneNode(activeNode);
         if (NULL == pNew) {
           pCxt->pTranslateCxt->errCode = TSDB_CODE_OUT_OF_MEMORY;

From d2433085413fbfa2fa99d7ec9a4b19b792a33611 Mon Sep 17 00:00:00 2001
From: factosea <285808407@qq.com>
Date: Wed, 10 Jan 2024 09:04:40 +0800
Subject: [PATCH 06/47] fix: colref

---
 include/libs/nodes/querynodes.h        |  1 +
 source/libs/executor/src/executil.c    | 23 ++++++-----
 source/libs/nodes/src/nodesUtilFuncs.c | 57 ++++++++++++++++++++++++++
 source/libs/parser/src/parTranslater.c | 22 +++++++++-
 4 files changed, 91 insertions(+), 12 deletions(-)

diff --git a/include/libs/nodes/querynodes.h b/include/libs/nodes/querynodes.h
index 6b481fc52e..615ee222a6 100644
--- a/include/libs/nodes/querynodes.h
+++ b/include/libs/nodes/querynodes.h
@@ -531,6 +531,7 @@ int32_t nodesCollectColumnsFromNode(SNode* node, const char* pTableAlias, EColle
 
 typedef bool (*FFuncClassifier)(int32_t funcId);
 int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier, SNodeList** pFuncs);
+int32_t nodesCollectSelectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier, SNodeList** pFuncs);
 
 int32_t nodesCollectSpecialNodes(SSelectStmt* pSelect, ESqlClause clause, ENodeType type, SNodeList** pNodes);
 
diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c
index 5e28621f7b..0a0502c7f5 100644
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@@ -1477,17 +1477,18 @@ void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) {
         SValueNode* pvn = (SValueNode*)p1;
         pExp->base.pParam[j].type = FUNC_PARAM_TYPE_VALUE;
         nodesValueNodeToVariant(pvn, &pExp->base.pParam[j].param);
-      } else if (p1->type == QUERY_NODE_FUNCTION) {
-        if (strcmp(((SFunctionNode*)p1)->functionName, "_select_value") == 0 &&
-          ((SFunctionNode*)p1)->pParameterList->length == 1 &&
-          ((SFunctionNode*)p1)->pParameterList->pHead->pNode->type == QUERY_NODE_COLUMN) {
-            SColumnNode* pcn = (SColumnNode*)(((SFunctionNode*)p1)->pParameterList->pHead->pNode);
-            SValueNode* pvn = (SValueNode*)p1;
-            pExp->base.pParam[j].type = FUNC_PARAM_TYPE_COLUMN;
-            pExp->base.pParam[j].pCol =
-              createColumn(pcn->dataBlockId, pcn->slotId, pcn->colId, &pcn->node.resType, pcn->colType);
-        }
-      }
+      } 
+      // else if (p1->type == QUERY_NODE_FUNCTION) {
+      //   if (strcmp(((SFunctionNode*)p1)->functionName, "_select_value") == 0 &&
+      //     ((SFunctionNode*)p1)->pParameterList->length == 1 &&
+      //     ((SFunctionNode*)p1)->pParameterList->pHead->pNode->type == QUERY_NODE_COLUMN) {
+      //       SColumnNode* pcn = (SColumnNode*)(((SFunctionNode*)p1)->pParameterList->pHead->pNode);
+      //       SValueNode* pvn = (SValueNode*)p1;
+      //       pExp->base.pParam[j].type = FUNC_PARAM_TYPE_COLUMN;
+      //       pExp->base.pParam[j].pCol =
+      //         createColumn(pcn->dataBlockId, pcn->slotId, pcn->colId, &pcn->node.resType, pcn->colType);
+      //   }
+      // }
     }
   } else if (type == QUERY_NODE_OPERATOR) {
     pExp->pExpr->nodeType = QUERY_NODE_OPERATOR;
diff --git a/source/libs/nodes/src/nodesUtilFuncs.c b/source/libs/nodes/src/nodesUtilFuncs.c
index 3675b0b9c4..b13af4f49a 100644
--- a/source/libs/nodes/src/nodesUtilFuncs.c
+++ b/source/libs/nodes/src/nodesUtilFuncs.c
@@ -2111,6 +2111,34 @@ static EDealRes collectFuncs(SNode* pNode, void* pContext) {
     FOREACH(pn, pCxt->pFuncs) {
       if (nodesEqualNode(pn, pNode)) {
         bFound = true;
+        break;
+      }
+    }
+    if (!bFound) {
+      pCxt->errCode = nodesListStrictAppend(pCxt->pFuncs, nodesCloneNode(pNode));
+    }
+    return (TSDB_CODE_SUCCESS == pCxt->errCode ? DEAL_RES_IGNORE_CHILD : DEAL_RES_ERROR);
+  }
+  return DEAL_RES_CONTINUE;
+}
+
+static EDealRes collectSelectFuncs(SNode* pNode, void* pContext) {
+  SCollectFuncsCxt* pCxt = (SCollectFuncsCxt*)pContext;
+  if (QUERY_NODE_FUNCTION == nodeType(pNode) && pCxt->classifier(((SFunctionNode*)pNode)->funcId)) {   
+    SFunctionNode* pFunc = (SFunctionNode*)pNode;
+    if (FUNCTION_TYPE_TBNAME == pFunc->funcType && pCxt->tableAlias) {
+      SValueNode* pVal = (SValueNode*)nodesListGetNode(pFunc->pParameterList, 0);
+      if (pVal && strcmp(pVal->literal, pCxt->tableAlias)) {
+        return DEAL_RES_CONTINUE;
+      }
+    }
+    SExprNode* pExpr = (SExprNode*)pNode;
+    bool bFound = false;
+    SNode* pn = NULL;
+    FOREACH(pn, pCxt->pFuncs) {
+      if (nodesEqualNode(pn, pNode)) {
+        bFound = true;
+        break;
       }
     }
     if (!bFound) {
@@ -2133,6 +2161,33 @@ static int32_t funcNodeEqual(const void* pLeft, const void* pRight, size_t len)
   return nodesEqualNode(*(const SNode**)pLeft, *(const SNode**)pRight) ? 0 : 1;
 }
 
+int32_t nodesCollectSelectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier, SNodeList** pFuncs) {
+  if (NULL == pSelect || NULL == pFuncs) {
+    return TSDB_CODE_FAILED;
+  }
+
+  SCollectFuncsCxt cxt = {.errCode = TSDB_CODE_SUCCESS,
+                          .classifier = classifier,
+                          .tableAlias = tableAlias,
+                          .pFuncs = *pFuncs};
+  if (NULL == cxt.pFuncs) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  nodesWalkSelectStmt(pSelect, clause, collectFuncs, &cxt);
+  if (TSDB_CODE_SUCCESS == cxt.errCode) {
+    if (LIST_LENGTH(cxt.pFuncs) > 0) {
+      *pFuncs = cxt.pFuncs;
+    } else {
+      nodesDestroyList(cxt.pFuncs);
+    }
+  } else {
+    nodesDestroyList(cxt.pFuncs);
+  }
+
+  return cxt.errCode;
+}
+
 int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier, SNodeList** pFuncs) {
   if (NULL == pSelect || NULL == pFuncs) {
     return TSDB_CODE_FAILED;
@@ -2152,9 +2207,11 @@ int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAl
       *pFuncs = cxt.pFuncs;
     } else {
       nodesDestroyList(cxt.pFuncs);
+      *pFuncs = NULL;
     }
   } else {
     nodesDestroyList(cxt.pFuncs);
+    *pFuncs = NULL;
   }
 
   return cxt.errCode;
diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c
index 08e794f169..e69fa20cc6 100644
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@@ -2744,6 +2744,24 @@ static EDealRes doCheckAggColCoexist(SNode** pNode, void* pContext) {
   return DEAL_RES_CONTINUE;
 }
 
+static int32_t reCalSelectFuncNum(SSelectStmt* pSelect) {
+  pSelect->selectFuncNum = 0;
+  SNodeList* pNodeList = nodesMakeList();
+  int32_t    code = TSDB_CODE_SUCCESS;
+  for (ESqlClause clause = SQL_CLAUSE_FROM; clause < SQL_CLAUSE_ORDER_BY; clause++) {
+    code = nodesCollectSelectFuncs(pSelect, clause, NULL, fmIsSelectFunc, &pNodeList);
+    if (TSDB_CODE_SUCCESS != code) {
+      return code;
+    }
+  }
+  SNode* pNode = NULL;
+  FOREACH(pNode, pNodeList) {
+    pSelect->selectFuncNum = calcSelectFuncNum((SFunctionNode*)pNode, pSelect->selectFuncNum);
+  }
+  nodesDestroyList(pNodeList);
+  return TSDB_CODE_SUCCESS;
+}
+
 static int32_t checkAggColCoexist(STranslateContext* pCxt, SSelectStmt* pSelect) {
   if (NULL != pSelect->pGroupByList || NULL != pSelect->pWindow ||
       (!pSelect->hasAggFuncs && !pSelect->hasIndefiniteRowsFunc && !pSelect->hasInterpFunc)) {
@@ -2757,7 +2775,8 @@ static int32_t checkAggColCoexist(STranslateContext* pCxt, SSelectStmt* pSelect)
   if (!pSelect->isDistinct) {
     nodesRewriteExprs(pSelect->pOrderByList, doCheckAggColCoexist, &cxt);
   }
-  if (0 < pSelect->selectFuncNum && !pSelect->hasOtherVectorFunc) {
+  if (((!cxt.existCol && 0 < pSelect->selectFuncNum) || (cxt.existCol && 1 == pSelect->selectFuncNum) ) 
+    && !pSelect->hasOtherVectorFunc) {
     return rewriteColsToSelectValFunc(pCxt, pSelect);
   }
   if (cxt.existCol) {
@@ -4597,6 +4616,7 @@ static int32_t translateSelectFrom(STranslateContext* pCxt, SSelectStmt* pSelect
     code = translateOrderBy(pCxt, pSelect);
   }
   if (TSDB_CODE_SUCCESS == code) {
+    reCalSelectFuncNum(pSelect);
     code = checkAggColCoexist(pCxt, pSelect);
   }
   if (TSDB_CODE_SUCCESS == code) {

From c8fb8486efd0206af42f29901263dd95688b08cd Mon Sep 17 00:00:00 2001
From: factosea <285808407@qq.com>
Date: Wed, 10 Jan 2024 19:07:21 +0800
Subject: [PATCH 07/47] fix: SColumnRefNode disable

---
 include/libs/nodes/querynodes.h        |  2 +-
 source/libs/nodes/src/nodesUtilFuncs.c | 14 ++------
 source/libs/parser/src/parTranslater.c | 45 ++++++++++++++++++--------
 3 files changed, 35 insertions(+), 26 deletions(-)

diff --git a/include/libs/nodes/querynodes.h b/include/libs/nodes/querynodes.h
index 615ee222a6..845d253f1c 100644
--- a/include/libs/nodes/querynodes.h
+++ b/include/libs/nodes/querynodes.h
@@ -531,7 +531,7 @@ int32_t nodesCollectColumnsFromNode(SNode* node, const char* pTableAlias, EColle
 
 typedef bool (*FFuncClassifier)(int32_t funcId);
 int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier, SNodeList** pFuncs);
-int32_t nodesCollectSelectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier, SNodeList** pFuncs);
+int32_t nodesCollectSelectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier, SNodeList* pFuncs);
 
 int32_t nodesCollectSpecialNodes(SSelectStmt* pSelect, ESqlClause clause, ENodeType type, SNodeList** pNodes);
 
diff --git a/source/libs/nodes/src/nodesUtilFuncs.c b/source/libs/nodes/src/nodesUtilFuncs.c
index b13af4f49a..1f641410d9 100644
--- a/source/libs/nodes/src/nodesUtilFuncs.c
+++ b/source/libs/nodes/src/nodesUtilFuncs.c
@@ -2161,7 +2161,7 @@ static int32_t funcNodeEqual(const void* pLeft, const void* pRight, size_t len)
   return nodesEqualNode(*(const SNode**)pLeft, *(const SNode**)pRight) ? 0 : 1;
 }
 
-int32_t nodesCollectSelectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier, SNodeList** pFuncs) {
+int32_t nodesCollectSelectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier, SNodeList* pFuncs) {
   if (NULL == pSelect || NULL == pFuncs) {
     return TSDB_CODE_FAILED;
   }
@@ -2169,22 +2169,12 @@ int32_t nodesCollectSelectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* t
   SCollectFuncsCxt cxt = {.errCode = TSDB_CODE_SUCCESS,
                           .classifier = classifier,
                           .tableAlias = tableAlias,
-                          .pFuncs = *pFuncs};
+                          .pFuncs = pFuncs};
   if (NULL == cxt.pFuncs) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }
 
   nodesWalkSelectStmt(pSelect, clause, collectFuncs, &cxt);
-  if (TSDB_CODE_SUCCESS == cxt.errCode) {
-    if (LIST_LENGTH(cxt.pFuncs) > 0) {
-      *pFuncs = cxt.pFuncs;
-    } else {
-      nodesDestroyList(cxt.pFuncs);
-    }
-  } else {
-    nodesDestroyList(cxt.pFuncs);
-  }
-
   return cxt.errCode;
 }
 
diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c
index e69fa20cc6..1fdf2bc5fe 100644
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@@ -1316,7 +1316,7 @@ static EDealRes translateColumn(STranslateContext* pCxt, SColumnNode** pCol) {
   } else {
     bool found = false;
     if (SQL_CLAUSE_ORDER_BY == pCxt->currClause) {
-      res = translateColumnUseAlias(pCxt, pCol, &found);
+      // res = translateColumnUseAlias(pCxt, pCol, &found);
     }
     if (DEAL_RES_ERROR != res && !found) {
       if (isSetOperator(pCxt->pCurrStmt)) {
@@ -2747,12 +2747,10 @@ static EDealRes doCheckAggColCoexist(SNode** pNode, void* pContext) {
 static int32_t reCalSelectFuncNum(SSelectStmt* pSelect) {
   pSelect->selectFuncNum = 0;
   SNodeList* pNodeList = nodesMakeList();
-  int32_t    code = TSDB_CODE_SUCCESS;
-  for (ESqlClause clause = SQL_CLAUSE_FROM; clause < SQL_CLAUSE_ORDER_BY; clause++) {
-    code = nodesCollectSelectFuncs(pSelect, clause, NULL, fmIsSelectFunc, &pNodeList);
-    if (TSDB_CODE_SUCCESS != code) {
-      return code;
-    }
+  int32_t code = nodesCollectSelectFuncs(pSelect, SQL_CLAUSE_FROM, NULL, fmIsSelectFunc, pNodeList);
+  if (TSDB_CODE_SUCCESS != code) {
+    nodesDestroyList(pNodeList);
+    return code;
   }
   SNode* pNode = NULL;
   FOREACH(pNode, pNodeList) {
@@ -4525,14 +4523,34 @@ typedef struct SReplaceOrderByAliasCxt {
 
 static EDealRes replaceOrderByAliasImpl(SNode** pNode, void* pContext) {
   SReplaceOrderByAliasCxt* pCxt = pContext;
-  if (QUERY_NODE_COLUMN_REF == nodeType(*pNode)) {
-    SNodeList* pProjectionList = pCxt->pProjectionList;
-    SNode*     pProject = NULL;
+  SNodeList* pProjectionList = pCxt->pProjectionList;
+  SNode*     pProject = NULL;
+  if (QUERY_NODE_COLUMN == nodeType(*pNode)) {
     FOREACH(pProject, pProjectionList) {
       SExprNode* pExpr = (SExprNode*)pProject;
-      SNode* activeNode = pProject;
-      if (0 == strcmp(((SColumnRefNode*)*pNode)->colName, pExpr->aliasName)) {
-        SNode* pNew = nodesCloneNode(activeNode);
+      if (0 == strcmp(((SColumnRefNode*)*pNode)->colName, pExpr->userAlias)) {
+        SNode* pNew = nodesCloneNode(pProject);
+        if (NULL == pNew) {
+          pCxt->pTranslateCxt->errCode = TSDB_CODE_OUT_OF_MEMORY;
+          return DEAL_RES_ERROR;
+        }
+        ((SExprNode*)pNew)->orderAlias = true;
+        nodesDestroyNode(*pNode);
+        *pNode = pNew;
+        return DEAL_RES_CONTINUE;
+      }
+    }
+  } else if (QUERY_NODE_ORDER_BY_EXPR == nodeType(*pNode)) {
+    STranslateContext* pTransCxt = pCxt->pTranslateCxt;
+    SNode* pExpr = ((SOrderByExprNode*)*pNode)->pExpr;
+        if (QUERY_NODE_VALUE == nodeType(pExpr)) {
+      SValueNode* pVal = (SValueNode*)pExpr;
+      if (DEAL_RES_ERROR == translateValue(pTransCxt, pVal)) {
+        return pTransCxt->errCode;
+      }
+      int32_t pos = getPositionValue(pVal);
+      if ( 0 < pos && pos <= LIST_LENGTH(pProjectionList)) {
+        SNode* pNew = nodesCloneNode(nodesListGetNode(pProjectionList, pos - 1));
         if (NULL == pNew) {
           pCxt->pTranslateCxt->errCode = TSDB_CODE_OUT_OF_MEMORY;
           return DEAL_RES_ERROR;
@@ -4544,6 +4562,7 @@ static EDealRes replaceOrderByAliasImpl(SNode** pNode, void* pContext) {
       }
     }
   }
+
   return DEAL_RES_CONTINUE;
 }
 

From 89ca3418af92d3c4ea42b1010f726347e401c350 Mon Sep 17 00:00:00 2001
From: wangmm0220 <wangmm0220@gmail.com>
Date: Thu, 11 Jan 2024 17:38:15 +0800
Subject: [PATCH 08/47] fix:[TD-28188]the epset of snode is error because epset
 is not initilized

---
 source/dnode/mnode/impl/src/mndStream.c | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/source/dnode/mnode/impl/src/mndStream.c b/source/dnode/mnode/impl/src/mndStream.c
index a656137770..a092aafb61 100644
--- a/source/dnode/mnode/impl/src/mndStream.c
+++ b/source/dnode/mnode/impl/src/mndStream.c
@@ -688,6 +688,7 @@ _OVER:
 static int32_t extractNodeEpset(SMnode *pMnode, SEpSet *pEpSet, bool* hasEpset, int32_t taskId, int32_t nodeId) {
   *hasEpset = false;
 
+  pEpSet->numOfEps = 0;
   if (nodeId == SNODE_HANDLE) {
     SSnodeObj *pObj = NULL;
     void      *pIter = NULL;
@@ -1800,7 +1801,8 @@ static int32_t mndPauseStreamTask(SMnode *pMnode, STrans *pTrans, SStreamTask *p
   pReq->taskId = pTask->id.taskId;
   pReq->streamId = pTask->id.streamId;
 
-  SEpSet  epset;
+  SEpSet  epset = {0};
+  mDebug("pause node:%d, epset:%d", pTask->info.nodeId, epset.numOfEps);
   bool    hasEpset = false;
   int32_t code = extractNodeEpset(pMnode, &epset, &hasEpset, pTask->id.taskId, pTask->info.nodeId);
   if (code != TSDB_CODE_SUCCESS) {
@@ -1966,7 +1968,7 @@ static int32_t mndResumeStreamTask(STrans *pTrans, SMnode *pMnode, SStreamTask *
   pReq->streamId = pTask->id.streamId;
   pReq->igUntreated = igUntreated;
 
-  SEpSet  epset;
+  SEpSet  epset = {0};
   bool    hasEpset = false;
   int32_t code = extractNodeEpset(pMnode, &epset, &hasEpset, pTask->id.taskId, pTask->info.nodeId);
   if (code != TSDB_CODE_SUCCESS) {
@@ -2767,7 +2769,7 @@ int32_t createStreamResetStatusTrans(SMnode *pMnode, SStreamObj *pStream) {
       pReq->taskId = pTask->id.taskId;
       pReq->streamId = pTask->id.streamId;
 
-      SEpSet epset;
+      SEpSet epset = {0};
       bool hasEpset = false;
       int32_t code = extractNodeEpset(pMnode, &epset, &hasEpset, pTask->id.taskId, pTask->info.nodeId);
       if (code != TSDB_CODE_SUCCESS) {
@@ -2947,7 +2949,7 @@ static int32_t mndDropRelatedFillhistoryTask(SMnode *pMnode, STaskStatusEntry *p
 
   mDebug("build and send drop related fill-history task for task:0x%x", pTask->id.taskId);
 
-  SEpSet  epset;
+  SEpSet  epset = {0};
   bool    hasEpset = false;
   int32_t code = extractNodeEpset(pMnode, &epset, &hasEpset, pTask->id.taskId, pTask->info.nodeId);
   if (code != TSDB_CODE_SUCCESS) {

From 3ed63df082524d0f33d3f44af41f431e9d30c58f Mon Sep 17 00:00:00 2001
From: factosea <285808407@qq.com>
Date: Thu, 11 Jan 2024 18:34:21 +0800
Subject: [PATCH 09/47] fix case

---
 source/libs/executor/src/executil.c       | 22 ++++++++++-----------
 source/libs/parser/src/parTranslater.c    | 24 +++++++++++------------
 source/libs/parser/test/parSelectTest.cpp |  2 +-
 3 files changed, 23 insertions(+), 25 deletions(-)

diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c
index 0a0502c7f5..8f780e008a 100644
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@@ -1478,17 +1478,17 @@ void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) {
         pExp->base.pParam[j].type = FUNC_PARAM_TYPE_VALUE;
         nodesValueNodeToVariant(pvn, &pExp->base.pParam[j].param);
       } 
-      // else if (p1->type == QUERY_NODE_FUNCTION) {
-      //   if (strcmp(((SFunctionNode*)p1)->functionName, "_select_value") == 0 &&
-      //     ((SFunctionNode*)p1)->pParameterList->length == 1 &&
-      //     ((SFunctionNode*)p1)->pParameterList->pHead->pNode->type == QUERY_NODE_COLUMN) {
-      //       SColumnNode* pcn = (SColumnNode*)(((SFunctionNode*)p1)->pParameterList->pHead->pNode);
-      //       SValueNode* pvn = (SValueNode*)p1;
-      //       pExp->base.pParam[j].type = FUNC_PARAM_TYPE_COLUMN;
-      //       pExp->base.pParam[j].pCol =
-      //         createColumn(pcn->dataBlockId, pcn->slotId, pcn->colId, &pcn->node.resType, pcn->colType);
-      //   }
-      // }
+      else if (p1->type == QUERY_NODE_FUNCTION) {
+        if (strcmp(((SFunctionNode*)p1)->functionName, "_select_value") == 0 &&
+          ((SFunctionNode*)p1)->pParameterList->length == 1 &&
+          ((SFunctionNode*)p1)->pParameterList->pHead->pNode->type == QUERY_NODE_COLUMN) {
+            SColumnNode* pcn = (SColumnNode*)(((SFunctionNode*)p1)->pParameterList->pHead->pNode);
+            SValueNode* pvn = (SValueNode*)p1;
+            pExp->base.pParam[j].type = FUNC_PARAM_TYPE_COLUMN;
+            pExp->base.pParam[j].pCol =
+              createColumn(pcn->dataBlockId, pcn->slotId, pcn->colId, &pcn->node.resType, pcn->colType);
+        }
+      }
     }
   } else if (type == QUERY_NODE_OPERATOR) {
     pExp->pExpr->nodeType = QUERY_NODE_OPERATOR;
diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c
index 1fdf2bc5fe..74f4f94cf3 100644
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@@ -1088,18 +1088,16 @@ static EDealRes translateColumnUseAlias(STranslateContext* pCxt, SColumnNode** p
   FOREACH(pNode, pProjectionList) {
     SExprNode* pExpr = (SExprNode*)pNode;
     if (0 == strcmp((*pCol)->colName, pExpr->userAlias)) {
-      SColumnRefNode* pColRef = (SColumnRefNode*)nodesMakeNode(QUERY_NODE_COLUMN_REF);
-      if (NULL == pColRef) {
-        pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY;
-        return DEAL_RES_ERROR;
-      }
-      strcpy(pColRef->colName, pExpr->aliasName);
-      pColRef->resType = pExpr->resType;
-      nodesDestroyNode(*(SNode**)pCol);
-      *(SNode**)pCol = (SNode*)pColRef;
-      *pFound = true;
-      return DEAL_RES_CONTINUE;
-    }
+      SNode* pNew = nodesCloneNode(pNode);
+        if (NULL == pNew) {
+          pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY;
+          return DEAL_RES_ERROR;
+        }
+        nodesDestroyNode(*(SNode**)pCol);
+        *(SNode**)pCol = (SNode*)pNew;
+        *pFound = true;
+        return DEAL_RES_CONTINUE;
+    }   
   }
   *pFound = false;
   return DEAL_RES_CONTINUE;
@@ -1316,7 +1314,7 @@ static EDealRes translateColumn(STranslateContext* pCxt, SColumnNode** pCol) {
   } else {
     bool found = false;
     if (SQL_CLAUSE_ORDER_BY == pCxt->currClause) {
-      // res = translateColumnUseAlias(pCxt, pCol, &found);
+      res = translateColumnUseAlias(pCxt, pCol, &found);
     }
     if (DEAL_RES_ERROR != res && !found) {
       if (isSetOperator(pCxt->pCurrStmt)) {
diff --git a/source/libs/parser/test/parSelectTest.cpp b/source/libs/parser/test/parSelectTest.cpp
index dce702f6b6..687344d56b 100644
--- a/source/libs/parser/test/parSelectTest.cpp
+++ b/source/libs/parser/test/parSelectTest.cpp
@@ -431,7 +431,7 @@ TEST_F(ParserSelectTest, semanticCheck) {
 
   run("SELECT ts, last(ts) FROM t1 order by last(ts)");
 
-  run("SELECT first(ts), c2 FROM t1 order by last(c1)");
+  run("SELECT first(ts), c2 FROM t1 order by last(c1)", TSDB_CODE_PAR_NOT_SINGLE_GROUP);
 
   run("SELECT c1 FROM t1 order by concat(c2, 'abc')");
 

From 25f9956ccbf5691377d81c8987571ab1b28cbb1a Mon Sep 17 00:00:00 2001
From: factosea <285808407@qq.com>
Date: Thu, 11 Jan 2024 21:21:00 +0800
Subject: [PATCH 10/47] fix:test

---
 source/libs/parser/src/parTranslater.c | 2 +-
 tests/script/tsim/compute/last_row.sim | 1 -
 tests/system-test/2-query/last_row.py  | 2 +-
 3 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c
index 74f4f94cf3..798295b488 100644
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@@ -3523,7 +3523,7 @@ static int32_t translateOrderBy(STranslateContext* pCxt, SSelectStmt* pSelect) {
     code = checkExprListForGroupBy(pCxt, pSelect, pSelect->pOrderByList);
   }
   if (other && TSDB_CODE_SUCCESS == code) {
-    code = checkOrderByAggForGroupBy(pCxt, pSelect, pSelect->pOrderByList);
+    // code = checkOrderByAggForGroupBy(pCxt, pSelect, pSelect->pOrderByList);
   }
   return code;
 }
diff --git a/tests/script/tsim/compute/last_row.sim b/tests/script/tsim/compute/last_row.sim
index 8e62fbffb5..04f4234ad6 100644
--- a/tests/script/tsim/compute/last_row.sim
+++ b/tests/script/tsim/compute/last_row.sim
@@ -245,7 +245,6 @@ endi
 
 sql alter database db cachemodel 'none';
 sql reset query cache;
-sql select tbname,last_row(c0, ts) from db.stb;
 
 if $rows != 1 then
   return -1
diff --git a/tests/system-test/2-query/last_row.py b/tests/system-test/2-query/last_row.py
index a6bcc2c5f1..b6cb468cf7 100644
--- a/tests/system-test/2-query/last_row.py
+++ b/tests/system-test/2-query/last_row.py
@@ -507,7 +507,7 @@ class TDTestCase:
         tdSql.query(f"select last(*), last_row(*),last(c1), last_row(c1) from {dbname}.stb1 ")
         tdSql.query(f"select last(*), last_row(*),last(c1), last_row(c1) from {dbname}.ct1 ")
         tdSql.query(f"select last(*), last_row(*),last(c1+1)*max(c1), last_row(c1+2)/2 from {dbname}.t1 ")
-        tdSql.query(f"select last_row(*) ,abs(c1/2)+100 from {dbname}.stb1 where tbname =\"ct1\" ")
+        # tdSql.query(f"select last_row(*) ,abs(c1/2)+100 from {dbname}.stb1 where tbname =\"ct1\" ")
         tdSql.query(f"select c1, last_row(c5) from {dbname}.ct1 ")
         tdSql.error(f"select c1, last_row(c5) ,last(c1) from {dbname}.stb1 ")
 

From 6115d7a67f468f056fbbbe79d3aad45deb44a933 Mon Sep 17 00:00:00 2001
From: factosea <285808407@qq.com>
Date: Fri, 12 Jan 2024 10:47:48 +0800
Subject: [PATCH 11/47] fix functionNode ref

---
 source/libs/parser/src/parTranslater.c    | 5 +++--
 source/libs/parser/test/parSelectTest.cpp | 8 ++++----
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c
index 798295b488..3eb8a63ae6 100644
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@@ -4523,10 +4523,11 @@ static EDealRes replaceOrderByAliasImpl(SNode** pNode, void* pContext) {
   SReplaceOrderByAliasCxt* pCxt = pContext;
   SNodeList* pProjectionList = pCxt->pProjectionList;
   SNode*     pProject = NULL;
-  if (QUERY_NODE_COLUMN == nodeType(*pNode)) {
+  if (QUERY_NODE_COLUMN == nodeType(*pNode) || QUERY_NODE_FUNCTION == nodeType(*pNode)) {
     FOREACH(pProject, pProjectionList) {
       SExprNode* pExpr = (SExprNode*)pProject;
-      if (0 == strcmp(((SColumnRefNode*)*pNode)->colName, pExpr->userAlias)) {
+      if (0 == strcmp(((SColumnRefNode*)*pNode)->colName, pExpr->userAlias)
+        && nodeType(*pNode) == nodeType(pProject)) {
         SNode* pNew = nodesCloneNode(pProject);
         if (NULL == pNew) {
           pCxt->pTranslateCxt->errCode = TSDB_CODE_OUT_OF_MEMORY;
diff --git a/source/libs/parser/test/parSelectTest.cpp b/source/libs/parser/test/parSelectTest.cpp
index 687344d56b..390faab537 100644
--- a/source/libs/parser/test/parSelectTest.cpp
+++ b/source/libs/parser/test/parSelectTest.cpp
@@ -417,13 +417,13 @@ TEST_F(ParserSelectTest, semanticCheck) {
 
   run("SELECT COUNT(*) FROM t1 order by last(c2)");
 
-  run("SELECT c1 FROM t1 order by last(ts)", TSDB_CODE_PAR_NOT_SINGLE_GROUP);
+  run("SELECT c1 FROM t1 order by last(ts)");
 
-  run("SELECT ts FROM t1 order by last(ts)", TSDB_CODE_PAR_NOT_SINGLE_GROUP);
+  run("SELECT ts FROM t1 order by last(ts)");
 
-  run("SELECT c2 FROM t1 order by last(ts)", TSDB_CODE_PAR_NOT_SINGLE_GROUP);
+  run("SELECT c2 FROM t1 order by last(ts)");
 
-  run("SELECT * FROM t1 order by last(ts)", TSDB_CODE_PAR_NOT_SINGLE_GROUP);
+  run("SELECT * FROM t1 order by last(ts)");
 
   run("SELECT last(ts) FROM t1 order by last(ts)");
 

From 19d7579e75963df791cba90cb0f339746d54ac8e Mon Sep 17 00:00:00 2001
From: factosea <285808407@qq.com>
Date: Fri, 12 Jan 2024 14:01:35 +0800
Subject: [PATCH 12/47] fix: copy expr

---
 source/libs/parser/src/parTranslater.c | 25 ++++++++++++++-----------
 tests/system-test/2-query/orderBy.py   |  2 +-
 2 files changed, 15 insertions(+), 12 deletions(-)

diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c
index 3eb8a63ae6..988c2442e0 100644
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@@ -2742,7 +2742,8 @@ static EDealRes doCheckAggColCoexist(SNode** pNode, void* pContext) {
   return DEAL_RES_CONTINUE;
 }
 
-static int32_t reCalSelectFuncNum(SSelectStmt* pSelect) {
+static int32_t resetSelectFuncNumWithoutDup(SSelectStmt* pSelect) {
+  if (pSelect->selectFuncNum <= 1) return TSDB_CODE_SUCCESS;
   pSelect->selectFuncNum = 0;
   SNodeList* pNodeList = nodesMakeList();
   int32_t code = nodesCollectSelectFuncs(pSelect, SQL_CLAUSE_FROM, NULL, fmIsSelectFunc, pNodeList);
@@ -3489,13 +3490,15 @@ static int32_t translateOrderByPosition(STranslateContext* pCxt, SNodeList* pPro
       } else if (0 == pos || pos > LIST_LENGTH(pProjectionList)) {
         return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_WRONG_NUMBER_OF_SELECT);
       } else {
-        SColumnRefNode* pCol = (SColumnRefNode*)nodesMakeNode(QUERY_NODE_COLUMN_REF);
-        if (NULL == pCol) {
-          return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_OUT_OF_MEMORY);
-        }
-        strcpy(pCol->colName, ((SExprNode*)nodesListGetNode(pProjectionList, pos - 1))->aliasName);
-        ((SOrderByExprNode*)pNode)->pExpr = (SNode*)pCol;
-        nodesDestroyNode(pExpr);
+        // SColumnRefNode* pCol = (SColumnRefNode*)nodesMakeNode(QUERY_NODE_COLUMN_REF);
+        // if (NULL == pCol) {
+        //   return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_OUT_OF_MEMORY);
+        // }
+        // strcpy(pCol->colName, ((SExprNode*)nodesListGetNode(pProjectionList, pos - 1))->aliasName);
+
+        // (SExprNode*)nodesListGetNode(pProjectionList, pos - 1);
+        // ((SOrderByExprNode*)pNode)->pExpr = (SNode*)pCol;
+        // nodesDestroyNode(pExpr);
       }
     } else {
       *pOther = true;
@@ -4555,8 +4558,8 @@ static EDealRes replaceOrderByAliasImpl(SNode** pNode, void* pContext) {
           return DEAL_RES_ERROR;
         }
         ((SExprNode*)pNew)->orderAlias = true;
-        nodesDestroyNode(*pNode);
-        *pNode = pNew;
+        ((SOrderByExprNode*)*pNode)->pExpr = pNew;
+        nodesDestroyNode(pExpr);
         return DEAL_RES_CONTINUE;
       }
     }
@@ -4634,7 +4637,7 @@ static int32_t translateSelectFrom(STranslateContext* pCxt, SSelectStmt* pSelect
     code = translateOrderBy(pCxt, pSelect);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    reCalSelectFuncNum(pSelect);
+    resetSelectFuncNumWithoutDup(pSelect);
     code = checkAggColCoexist(pCxt, pSelect);
   }
   if (TSDB_CODE_SUCCESS == code) {
diff --git a/tests/system-test/2-query/orderBy.py b/tests/system-test/2-query/orderBy.py
index 162a5c6e26..8ca44e49da 100644
--- a/tests/system-test/2-query/orderBy.py
+++ b/tests/system-test/2-query/orderBy.py
@@ -278,7 +278,7 @@ class TDTestCase:
 
     def queryOrderByAgg(self):
 
-        tdSql.error(f"SELECT * FROM t1 order by last(ts)")
+        tdSql.query(f"SELECT * FROM t1 order by last(ts)")
 
         tdSql.query(f"SELECT last(ts) FROM t1 order by last(ts)")
 

From 4c374dec2f929965a7b89b2275323e696db3d89a Mon Sep 17 00:00:00 2001
From: factosea <285808407@qq.com>
Date: Fri, 12 Jan 2024 14:16:54 +0800
Subject: [PATCH 13/47] test case

---
 tests/script/tsim/compute/last_row.sim | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/script/tsim/compute/last_row.sim b/tests/script/tsim/compute/last_row.sim
index 04f4234ad6..8e62fbffb5 100644
--- a/tests/script/tsim/compute/last_row.sim
+++ b/tests/script/tsim/compute/last_row.sim
@@ -245,6 +245,7 @@ endi
 
 sql alter database db cachemodel 'none';
 sql reset query cache;
+sql select tbname,last_row(c0, ts) from db.stb;
 
 if $rows != 1 then
   return -1

From ab02ec74c93dd9cf49947b503edd371be071b73b Mon Sep 17 00:00:00 2001
From: factosea <285808407@qq.com>
Date: Fri, 12 Jan 2024 18:10:54 +0800
Subject: [PATCH 14/47] fix taosd crash

---
 source/libs/executor/src/executil.c | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c
index 8f780e008a..0a0502c7f5 100644
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@@ -1478,17 +1478,17 @@ void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) {
         pExp->base.pParam[j].type = FUNC_PARAM_TYPE_VALUE;
         nodesValueNodeToVariant(pvn, &pExp->base.pParam[j].param);
       } 
-      else if (p1->type == QUERY_NODE_FUNCTION) {
-        if (strcmp(((SFunctionNode*)p1)->functionName, "_select_value") == 0 &&
-          ((SFunctionNode*)p1)->pParameterList->length == 1 &&
-          ((SFunctionNode*)p1)->pParameterList->pHead->pNode->type == QUERY_NODE_COLUMN) {
-            SColumnNode* pcn = (SColumnNode*)(((SFunctionNode*)p1)->pParameterList->pHead->pNode);
-            SValueNode* pvn = (SValueNode*)p1;
-            pExp->base.pParam[j].type = FUNC_PARAM_TYPE_COLUMN;
-            pExp->base.pParam[j].pCol =
-              createColumn(pcn->dataBlockId, pcn->slotId, pcn->colId, &pcn->node.resType, pcn->colType);
-        }
-      }
+      // else if (p1->type == QUERY_NODE_FUNCTION) {
+      //   if (strcmp(((SFunctionNode*)p1)->functionName, "_select_value") == 0 &&
+      //     ((SFunctionNode*)p1)->pParameterList->length == 1 &&
+      //     ((SFunctionNode*)p1)->pParameterList->pHead->pNode->type == QUERY_NODE_COLUMN) {
+      //       SColumnNode* pcn = (SColumnNode*)(((SFunctionNode*)p1)->pParameterList->pHead->pNode);
+      //       SValueNode* pvn = (SValueNode*)p1;
+      //       pExp->base.pParam[j].type = FUNC_PARAM_TYPE_COLUMN;
+      //       pExp->base.pParam[j].pCol =
+      //         createColumn(pcn->dataBlockId, pcn->slotId, pcn->colId, &pcn->node.resType, pcn->colType);
+      //   }
+      // }
     }
   } else if (type == QUERY_NODE_OPERATOR) {
     pExp->pExpr->nodeType = QUERY_NODE_OPERATOR;

From df40772e95f34566b06037b321fce115c25c426a Mon Sep 17 00:00:00 2001
From: Alex Duan <417921451@qq.com>
Date: Sun, 14 Jan 2024 20:23:37 +0800
Subject: [PATCH 15/47] coverage: sum add all types test

---
 source/libs/function/src/builtinsimpl.c  |  2 ++
 tests/army/community/cluster/snapshot.py | 13 ++++++--
 tests/army/frame/autogen.py              | 25 +++++++++++++--
 tests/pytest/util/autogen.py             | 25 +++++++++++++--
 tests/system-test/2-query/sum.py         | 40 +++++++++++++++++++++++-
 5 files changed, 98 insertions(+), 7 deletions(-)

diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c
index 390190e8db..318a159109 100644
--- a/source/libs/function/src/builtinsimpl.c
+++ b/source/libs/function/src/builtinsimpl.c
@@ -832,6 +832,7 @@ int32_t minmaxFunctionFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
   return code;
 }
 
+#ifdef BUILD_NO_CALL
 int32_t setNullSelectivityValue(SqlFunctionCtx* pCtx, SSDataBlock* pBlock, int32_t rowIndex) {
   if (pCtx->subsidiaries.num <= 0) {
     return TSDB_CODE_SUCCESS;
@@ -847,6 +848,7 @@ int32_t setNullSelectivityValue(SqlFunctionCtx* pCtx, SSDataBlock* pBlock, int32
 
   return TSDB_CODE_SUCCESS;
 }
+#endif
 
 int32_t setSelectivityValue(SqlFunctionCtx* pCtx, SSDataBlock* pBlock, const STuplePos* pTuplePos, int32_t rowIndex) {
   if (pCtx->subsidiaries.num <= 0) {
diff --git a/tests/army/community/cluster/snapshot.py b/tests/army/community/cluster/snapshot.py
index 92ecc00726..8543101300 100644
--- a/tests/army/community/cluster/snapshot.py
+++ b/tests/army/community/cluster/snapshot.py
@@ -28,7 +28,9 @@ from frame import *
 
 
 class TDTestCase(TBase):
-        
+    updatecfgDict = {
+        "countAlwaysReturnValue" : "0"
+    }
 
     def insertData(self):
         tdLog.info(f"insert data.")
@@ -42,6 +44,10 @@ class TDTestCase(TBase):
         self.insert_rows      = 100000
         self.timestamp_step   = 10000
 
+        # create count check table
+        sql = f"create table {self.db}.ta(ts timestamp, age int) tags(area int)"
+        tdSql.execute(sql)
+
     def doAction(self):
         tdLog.info(f"do action.")
         self.flushDb()
@@ -64,7 +70,10 @@ class TDTestCase(TBase):
         selid = random.choice(vgids)
         self.balanceVGroupLeaderOn(selid)
 
-        
+        # check count always return value
+        sql = f"select count(*) from {self.db}.ta"
+        tdSql.waitedQuery(sql, 0, 2)        
+
 
     # run
     def run(self):
diff --git a/tests/army/frame/autogen.py b/tests/army/frame/autogen.py
index 9dca96e7b0..bb9ca163d7 100644
--- a/tests/army/frame/autogen.py
+++ b/tests/army/frame/autogen.py
@@ -14,11 +14,12 @@ import time
 # Auto Gen class
 #
 class AutoGen:
-    def __init__(self):
+    def __init__(self, fillOne=False):
         self.ts = 1600000000000
         self.batch_size = 100
         seed = time.time() % 10000
         random.seed(seed)
+        self.fillOne = fillOne
 
     # set start ts
     def set_start_ts(self, ts):
@@ -87,6 +88,23 @@ class AutoGen:
         
         return datas
 
+    # fill one data
+    def fillone_data(self, i, marr):
+        datas = ""
+        for c in marr:
+            if datas != "":
+                datas += ","
+
+            if c == 0:
+                datas += "%d" % (self.ts + i)
+            elif c == 12 or c == 13: # binary
+                datas += '"1"'
+            else:
+                datas += '1'
+        
+        return datas
+
+
     # generate specail wide random string
     def random_string(self, count):
         letters = string.ascii_letters
@@ -127,7 +145,10 @@ class AutoGen:
 
         # loop do
         for i in range(cnt):
-            value = self.gen_data(i, self.mcols)
+            if self.fillOne :
+                value = self.fillone_data(i, self.mcols)
+            else:
+                value = self.gen_data(i, self.mcols)
             ts += step
             values += f"({ts},{value}) "
             if batch_size == 1 or (i > 0 and i % batch_size == 0) :
diff --git a/tests/pytest/util/autogen.py b/tests/pytest/util/autogen.py
index e1227a680f..243cb8c333 100644
--- a/tests/pytest/util/autogen.py
+++ b/tests/pytest/util/autogen.py
@@ -14,11 +14,12 @@ import time
 # Auto Gen class
 #
 class AutoGen:
-    def __init__(self):
+    def __init__(self, fillOne=False):
         self.ts = 1600000000000
         self.batch_size = 100
         seed = time.time() % 10000
         random.seed(seed)
+        self.fillOne = fillOne
 
     # set start ts
     def set_start_ts(self, ts):
@@ -87,6 +88,23 @@ class AutoGen:
         
         return datas
 
+    # fill one data
+    def fillone_data(self, i, marr):
+        datas = ""
+        for c in marr:
+            if datas != "":
+                datas += ","
+
+            if c == 0:
+                datas += "%d" % (self.ts + i)
+            elif c == 12 or c == 13: # binary
+                datas += '"1"'
+            else:
+                datas += '1'
+        
+        return datas
+
+
     # generate specail wide random string
     def random_string(self, count):
         letters = string.ascii_letters
@@ -127,7 +145,10 @@ class AutoGen:
 
         # loop do
         for i in range(cnt):
-            value = self.gen_data(i, self.mcols)
+            if self.fillOne :
+                value = self.fillone_data(i, self.mcols)
+            else:
+                value = self.gen_data(i, self.mcols)
             ts += step
             values += f"({ts},{value}) "
             if batch_size == 1 or (i > 0 and i % batch_size == 0) :
diff --git a/tests/system-test/2-query/sum.py b/tests/system-test/2-query/sum.py
index 27096fe5ad..90d9f50f87 100644
--- a/tests/system-test/2-query/sum.py
+++ b/tests/system-test/2-query/sum.py
@@ -2,6 +2,7 @@ from util.log import *
 from util.sql import *
 from util.cases import *
 from util.dnodes import *
+from util.autogen import *
 
 
 INT_COL     = "c1"
@@ -23,11 +24,11 @@ TS_TYPE_COL = [TS_COL]
 DBNAME = "db"
 
 class TDTestCase:
-
     def init(self, conn, logSql, replicaVar=1):
         self.replicaVar = int(replicaVar)
         tdLog.debug(f"start to excute {__file__}")
         tdSql.init(conn.cursor())
+        self.autoGen = AutoGen(True)
 
     def __sum_condition(self):
         sum_condition = []
@@ -207,9 +208,46 @@ class TDTestCase:
             '''
         )
 
+    def testAllTypes(self):
+        # create stable and insert
+        tdLog.info("test all types")
+        stbname = "stb"
+        colnum = 16
+        self.autoGen.set_batch_size(1000)
+        self.autoGen.create_stable(stbname, 16, colnum, 8, 16)
+        self.autoGen.create_child(stbname, "d", 4)
+        self.autoGen.insert_data(10000)
+
+        # check correct
+        i = 0
+        for c in self.autoGen.mcols:
+
+            if c in [0, 11, 12, 13]:
+                i += 1
+                continue
+
+            # query
+            col = f"c{i}"
+            sql = f"select count({col}), sum({col}), avg({col}), max({col}), min({col}) from stb"
+            tdSql.query(sql)
+            # sum
+            tdSql.checkData(0, 0, 4*10000, True)
+            # sum
+            tdSql.checkData(0, 1, 4*10000, True)
+            # avg
+            tdSql.checkData(0, 2, 1, True)
+            # max
+            tdSql.checkData(0, 3, 1, True)
+            # min
+            tdSql.checkData(0, 4, 1, True)
+            i += 1
+
+
     def run(self):
         tdSql.prepare()
 
+        self.testAllTypes()
+
         tdLog.printNoPrefix("==========step1:create table")
         self.__create_tb()
 

From c277abd3bfc38a9e6ab273baa9187cceae7b2a5f Mon Sep 17 00:00:00 2001
From: facetosea <25808407@qq.com>
Date: Sun, 14 Jan 2024 21:47:13 +0800
Subject: [PATCH 16/47] fix: functionNode skip

---
 source/libs/nodes/src/nodesUtilFuncs.c | 5 -----
 source/libs/parser/src/parTranslater.c | 2 +-
 2 files changed, 1 insertion(+), 6 deletions(-)

diff --git a/source/libs/nodes/src/nodesUtilFuncs.c b/source/libs/nodes/src/nodesUtilFuncs.c
index 1f641410d9..446b29d7f2 100644
--- a/source/libs/nodes/src/nodesUtilFuncs.c
+++ b/source/libs/nodes/src/nodesUtilFuncs.c
@@ -2170,9 +2170,6 @@ int32_t nodesCollectSelectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* t
                           .classifier = classifier,
                           .tableAlias = tableAlias,
                           .pFuncs = pFuncs};
-  if (NULL == cxt.pFuncs) {
-    return TSDB_CODE_OUT_OF_MEMORY;
-  }
 
   nodesWalkSelectStmt(pSelect, clause, collectFuncs, &cxt);
   return cxt.errCode;
@@ -2197,11 +2194,9 @@ int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAl
       *pFuncs = cxt.pFuncs;
     } else {
       nodesDestroyList(cxt.pFuncs);
-      *pFuncs = NULL;
     }
   } else {
     nodesDestroyList(cxt.pFuncs);
-    *pFuncs = NULL;
   }
 
   return cxt.errCode;
diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c
index 988c2442e0..b14efcd40b 100644
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@@ -4526,7 +4526,7 @@ static EDealRes replaceOrderByAliasImpl(SNode** pNode, void* pContext) {
   SReplaceOrderByAliasCxt* pCxt = pContext;
   SNodeList* pProjectionList = pCxt->pProjectionList;
   SNode*     pProject = NULL;
-  if (QUERY_NODE_COLUMN == nodeType(*pNode) || QUERY_NODE_FUNCTION == nodeType(*pNode)) {
+  if (QUERY_NODE_COLUMN == nodeType(*pNode)) {
     FOREACH(pProject, pProjectionList) {
       SExprNode* pExpr = (SExprNode*)pProject;
       if (0 == strcmp(((SColumnRefNode*)*pNode)->colName, pExpr->userAlias)

From 14fb86c0a9086ca42d34f407c1d713dd2732dd1c Mon Sep 17 00:00:00 2001
From: Alex Duan <417921451@qq.com>
Date: Sun, 14 Jan 2024 22:02:43 +0800
Subject: [PATCH 17/47] feat: add query_basic.py

---
 tests/army/community/query/query_basic.json | 60 ++++++++++++++++
 tests/army/community/query/query_basic.py   | 79 +++++++++++++++++++++
 tests/army/frame/caseBase.py                | 25 +++++++
 tests/army/frame/sql.py                     |  6 ++
 tests/system-test/2-query/sum.py            |  5 +-
 5 files changed, 174 insertions(+), 1 deletion(-)
 create mode 100644 tests/army/community/query/query_basic.json
 create mode 100644 tests/army/community/query/query_basic.py

diff --git a/tests/army/community/query/query_basic.json b/tests/army/community/query/query_basic.json
new file mode 100644
index 0000000000..e1865445ea
--- /dev/null
+++ b/tests/army/community/query/query_basic.json
@@ -0,0 +1,60 @@
+{
+    "filetype": "insert",
+    "cfgdir": "/etc/taos",
+    "host": "127.0.0.1",
+    "port": 6030,
+    "user": "root",
+    "password": "taosdata",
+    "connection_pool_size": 8,
+    "num_of_records_per_req": 4000,
+    "thread_count": 2,
+    "create_table_thread_count": 1,
+    "confirm_parameter_prompt": "no",
+    "databases": [
+        {
+            "dbinfo": {
+                "name": "db",
+                "drop": "yes",
+                "vgroups": 3,
+                "replica": 3,
+                "duration":"3d",
+                "wal_retention_period": 1,
+                "wal_retention_size": 1,
+                "stt_trigger": 1
+            },
+            "super_tables": [
+                {
+                    "name": "stb",
+                    "child_table_exists": "no",
+                    "childtable_count": 6,
+                    "insert_rows": 100000,
+                    "childtable_prefix": "d",
+                    "insert_mode": "taosc",
+                    "timestamp_step": 30000,
+                    "start_timestamp":"2023-10-01 10:00:00",
+                    "columns": [
+                        { "type": "bool",        "name": "bc"},
+                        { "type": "float",       "name": "fc" },
+                        { "type": "double",      "name": "dc"},
+                        { "type": "tinyint",     "name": "ti"},
+                        { "type": "smallint",    "name": "si" },
+                        { "type": "int",         "name": "ic" },
+                        { "type": "bigint",      "name": "bi" },
+                        { "type": "utinyint",    "name": "uti"},
+                        { "type": "usmallint",   "name": "usi"},
+                        { "type": "uint",        "name": "ui" },
+                        { "type": "ubigint",     "name": "ubi"},
+                        { "type": "binary",      "name": "bin", "len": 8},
+                        { "type": "nchar",       "name": "nch", "len": 16}
+                    ],
+                    "tags": [
+                        {"type": "tinyint", "name": "groupid","max": 10,"min": 1},
+                        {"name": "location","type": "binary", "len": 16, "values":
+                           ["San Francisco", "Los Angles", "San Diego", "San Jose", "Palo Alto", "Campbell", "Mountain View","Sunnyvale", "Santa Clara", "Cupertino"]
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}
diff --git a/tests/army/community/query/query_basic.py b/tests/army/community/query/query_basic.py
new file mode 100644
index 0000000000..07bf6093c0
--- /dev/null
+++ b/tests/army/community/query/query_basic.py
@@ -0,0 +1,79 @@
+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import time
+import random
+
+import taos
+import frame
+import frame.etool
+
+
+from frame.log import *
+from frame.cases import *
+from frame.sql import *
+from frame.caseBase import *
+from frame import *
+
+
+class TDTestCase(TBase):
+    updatecfgDict = {
+        "keepColumnName" : "1",
+        "ttlChangeOnWrite" : "1",
+        "querySmaOptimize": "1"
+    }
+
+    def insertData(self):
+        tdLog.info(f"insert data.")
+        # taosBenchmark run
+        jfile = etool.curFile(__file__, "query_basic.json")
+        etool.benchMark(json=jfile)
+
+        tdSql.execute(f"use {self.db}")
+        # set insert data information
+        self.childtable_count = 6
+        self.insert_rows      = 100000
+        self.timestamp_step   = 30000
+
+
+    def doQuery(self):
+        tdLog.info(f"do query.")
+        
+        # top bottom
+        sql = f"select top(uti, 5) from {self.stb} "
+        tdSql.execute(sql)
+
+
+    # run
+    def run(self):
+        tdLog.debug(f"start to excute {__file__}")
+
+        # insert data
+        self.insertData()
+
+        # check insert data correct
+        self.checkInsertCorrect()
+
+        # check 
+        self.checkConsistency("usi")
+
+        # do action
+        self.doQuery()
+
+        tdLog.success(f"{__file__} successfully executed")
+
+        
+
+tdCases.addLinux(__file__, TDTestCase())
+tdCases.addWindows(__file__, TDTestCase())
diff --git a/tests/army/frame/caseBase.py b/tests/army/frame/caseBase.py
index c9f3aa1880..32852934f8 100644
--- a/tests/army/frame/caseBase.py
+++ b/tests/army/frame/caseBase.py
@@ -153,6 +153,31 @@ class TBase:
         tdSql.checkAgg(self.sqlFirst, self.first)
         tdSql.checkAgg(self.sqlLast,  self.last)
 
+    # self check 
+    def checkConsistency(self, col):
+        # top with max
+        sql = f"select max({col}) from {self.stb}"
+        expect = tdSql.getFirstValue(sql)
+        sql = f"select top({col}, 5) from {self.stb}"
+        tdSql.checkFirstValue(sql, expect)
+
+        #bottom with min
+        sql = f"select min({col}) from {self.stb}"
+        expect = tdSql.getFirstValue(sql)
+        sql = f"select bottom({col}, 5) from {self.stb}"
+        tdSql.checkFirstValue(sql, expect)
+
+        # order by asc limit 1 with first
+        sql = f"select last({col}) from {self.stb}"
+        expect = tdSql.getFirstValue(sql)
+        sql = f"select {col} from {self.stb} order by {col} desc limit 1"
+        tdSql.checkFirstValue(sql, expect)
+
+        # order by desc limit 1 with last
+        sql = f"select first({col}) from {self.stb}"
+        expect = tdSql.getFirstValue(sql)
+        sql = f"select {col} from {self.stb} order by {col} asc limit 1"
+        tdSql.checkFirstValue(sql, expect)
 
 #
 #   get db information
diff --git a/tests/army/frame/sql.py b/tests/army/frame/sql.py
index 2e14f0c2f0..f93a51e45e 100644
--- a/tests/army/frame/sql.py
+++ b/tests/army/frame/sql.py
@@ -544,6 +544,12 @@ class TDSql:
     def getFirstValue(self, sql) :
         self.query(sql)
         return self.getData(0, 0)
+    
+    # expect first value
+    def checkFirstValue(self, sql, expect):
+        self.query(sql)
+        self.checkData(0, 0, expect)
+        
 
     def get_times(self, time_str, precision="ms"):
         caller = inspect.getframeinfo(inspect.stack()[1][0])
diff --git a/tests/system-test/2-query/sum.py b/tests/system-test/2-query/sum.py
index 90d9f50f87..1e428491a6 100644
--- a/tests/system-test/2-query/sum.py
+++ b/tests/system-test/2-query/sum.py
@@ -228,7 +228,7 @@ class TDTestCase:
 
             # query
             col = f"c{i}"
-            sql = f"select count({col}), sum({col}), avg({col}), max({col}), min({col}) from stb"
+            sql = f"select count({col}), sum({col}), avg({col}), max({col}), min({col}), stddev({col}, leastsquares({col},1,9)) from stb"
             tdSql.query(sql)
             # sum
             tdSql.checkData(0, 0, 4*10000, True)
@@ -240,6 +240,9 @@ class TDTestCase:
             tdSql.checkData(0, 3, 1, True)
             # min
             tdSql.checkData(0, 4, 1, True)
+            # stddev
+            tdSql.checkData(0, 5, 0, True)
+
             i += 1
 
 

From 07e68012377f964ba14fb7367adf96f07a5181f1 Mon Sep 17 00:00:00 2001
From: Alex Duan <417921451@qq.com>
Date: Sun, 14 Jan 2024 22:14:39 +0800
Subject: [PATCH 18/47] feat : add checkConsistency fun

---
 tests/army/community/query/query_basic.json | 3 ++-
 tests/army/frame/caseBase.py                | 4 ++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/tests/army/community/query/query_basic.json b/tests/army/community/query/query_basic.json
index e1865445ea..4190fbdd72 100644
--- a/tests/army/community/query/query_basic.json
+++ b/tests/army/community/query/query_basic.json
@@ -7,7 +7,8 @@
     "password": "taosdata",
     "connection_pool_size": 8,
     "num_of_records_per_req": 4000,
-    "thread_count": 2,
+    "prepared_rand": 1000,
+    "thread_count": 3,
     "create_table_thread_count": 1,
     "confirm_parameter_prompt": "no",
     "databases": [
diff --git a/tests/army/frame/caseBase.py b/tests/army/frame/caseBase.py
index 32852934f8..ca5539f75b 100644
--- a/tests/army/frame/caseBase.py
+++ b/tests/army/frame/caseBase.py
@@ -170,13 +170,13 @@ class TBase:
         # order by asc limit 1 with first
         sql = f"select last({col}) from {self.stb}"
         expect = tdSql.getFirstValue(sql)
-        sql = f"select {col} from {self.stb} order by {col} desc limit 1"
+        sql = f"select {col} from {self.stb} order by _c0 desc limit 1"
         tdSql.checkFirstValue(sql, expect)
 
         # order by desc limit 1 with last
         sql = f"select first({col}) from {self.stb}"
         expect = tdSql.getFirstValue(sql)
-        sql = f"select {col} from {self.stb} order by {col} asc limit 1"
+        sql = f"select {col} from {self.stb} order by _c0 asc limit 1"
         tdSql.checkFirstValue(sql, expect)
 
 #

From 6b257316001d2a7d1d38437de44cc7ce6b784bc7 Mon Sep 17 00:00:00 2001
From: Alex Duan <417921451@qq.com>
Date: Sun, 14 Jan 2024 22:17:56 +0800
Subject: [PATCH 19/47] fix: tweak prepare_rand

---
 tests/army/community/cluster/snapshot.json | 3 ++-
 tests/army/enterprise/s3/s3_basic.json     | 1 +
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/tests/army/community/cluster/snapshot.json b/tests/army/community/cluster/snapshot.json
index 64bb2aaf3c..d4f6f00d37 100644
--- a/tests/army/community/cluster/snapshot.json
+++ b/tests/army/community/cluster/snapshot.json
@@ -6,7 +6,8 @@
     "user": "root",
     "password": "taosdata",
     "connection_pool_size": 8,
-    "num_of_records_per_req": 2000,
+    "num_of_records_per_req": 3000,
+    "prepared_rand": 3000,
     "thread_count": 2,
     "create_table_thread_count": 1,
     "confirm_parameter_prompt": "no",
diff --git a/tests/army/enterprise/s3/s3_basic.json b/tests/army/enterprise/s3/s3_basic.json
index e56a18e757..d7544a897c 100644
--- a/tests/army/enterprise/s3/s3_basic.json
+++ b/tests/army/enterprise/s3/s3_basic.json
@@ -7,6 +7,7 @@
     "password": "taosdata",
     "connection_pool_size": 8,
     "num_of_records_per_req": 2000,
+    "prepared_rand": 1000,
     "thread_count": 2,
     "create_table_thread_count": 1,
     "confirm_parameter_prompt": "no",

From 0d56695d968cd25b84415a9eea186e78454b527c Mon Sep 17 00:00:00 2001
From: factosea <285808407@qq.com>
Date: Mon, 15 Jan 2024 02:31:04 +0800
Subject: [PATCH 20/47] delete unused code

---
 source/libs/parser/src/parTranslater.c | 37 +-------------------------
 tests/system-test/2-query/last_row.py  |  2 +-
 tests/system-test/2-query/orderBy.py   | 21 ++++++++++++++-
 3 files changed, 22 insertions(+), 38 deletions(-)

diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c
index b14efcd40b..13d95b1f56 100644
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@@ -3448,30 +3448,6 @@ static int32_t getPositionValue(const SValueNode* pVal) {
   return -1;
 }
 
-static int32_t checkOrderByAggForGroupBy(STranslateContext* pCxt, SSelectStmt* pSelect, SNodeList* pOrderByList) {
-  if (NULL != getGroupByList(pCxt) || NULL != pSelect->pWindow) {
-    return TSDB_CODE_SUCCESS;
-  }
-  SNode* pProject = NULL;
-  FOREACH(pProject, pSelect->pProjectionList) {
-    if(isAggFunc(pProject)) {
-      return TSDB_CODE_SUCCESS;
-    }
-  }
-  SNode* pNode = NULL;
-  WHERE_EACH(pNode, pOrderByList) {
-    SNode* pExpr = ((SOrderByExprNode*)pNode)->pExpr;
-    if ((QUERY_NODE_FUNCTION == nodeType(pExpr))) {
-      SFunctionNode* pFunc = (SFunctionNode*)pExpr;
-      if (fmIsAggFunc(pFunc->funcId)) {
-        return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_NOT_SINGLE_GROUP);
-      }
-    }
-    WHERE_NEXT;
-  }
-  return TSDB_CODE_SUCCESS;
-}
-
 static int32_t translateOrderByPosition(STranslateContext* pCxt, SNodeList* pProjectionList, SNodeList* pOrderByList,
                                         bool* pOther) {
   *pOther = false;
@@ -3490,15 +3466,7 @@ static int32_t translateOrderByPosition(STranslateContext* pCxt, SNodeList* pPro
       } else if (0 == pos || pos > LIST_LENGTH(pProjectionList)) {
         return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_WRONG_NUMBER_OF_SELECT);
       } else {
-        // SColumnRefNode* pCol = (SColumnRefNode*)nodesMakeNode(QUERY_NODE_COLUMN_REF);
-        // if (NULL == pCol) {
-        //   return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_OUT_OF_MEMORY);
-        // }
-        // strcpy(pCol->colName, ((SExprNode*)nodesListGetNode(pProjectionList, pos - 1))->aliasName);
-
-        // (SExprNode*)nodesListGetNode(pProjectionList, pos - 1);
-        // ((SOrderByExprNode*)pNode)->pExpr = (SNode*)pCol;
-        // nodesDestroyNode(pExpr);
+        // No longer using SColumnRefNode, processing in replaceOrderByAliasImpl function
       }
     } else {
       *pOther = true;
@@ -3525,9 +3493,6 @@ static int32_t translateOrderBy(STranslateContext* pCxt, SSelectStmt* pSelect) {
   if (TSDB_CODE_SUCCESS == code) {
     code = checkExprListForGroupBy(pCxt, pSelect, pSelect->pOrderByList);
   }
-  if (other && TSDB_CODE_SUCCESS == code) {
-    // code = checkOrderByAggForGroupBy(pCxt, pSelect, pSelect->pOrderByList);
-  }
   return code;
 }
 
diff --git a/tests/system-test/2-query/last_row.py b/tests/system-test/2-query/last_row.py
index b6cb468cf7..a6bcc2c5f1 100644
--- a/tests/system-test/2-query/last_row.py
+++ b/tests/system-test/2-query/last_row.py
@@ -507,7 +507,7 @@ class TDTestCase:
         tdSql.query(f"select last(*), last_row(*),last(c1), last_row(c1) from {dbname}.stb1 ")
         tdSql.query(f"select last(*), last_row(*),last(c1), last_row(c1) from {dbname}.ct1 ")
         tdSql.query(f"select last(*), last_row(*),last(c1+1)*max(c1), last_row(c1+2)/2 from {dbname}.t1 ")
-        # tdSql.query(f"select last_row(*) ,abs(c1/2)+100 from {dbname}.stb1 where tbname =\"ct1\" ")
+        tdSql.query(f"select last_row(*) ,abs(c1/2)+100 from {dbname}.stb1 where tbname =\"ct1\" ")
         tdSql.query(f"select c1, last_row(c5) from {dbname}.ct1 ")
         tdSql.error(f"select c1, last_row(c5) ,last(c1) from {dbname}.stb1 ")
 
diff --git a/tests/system-test/2-query/orderBy.py b/tests/system-test/2-query/orderBy.py
index 8ca44e49da..dedc57eab3 100644
--- a/tests/system-test/2-query/orderBy.py
+++ b/tests/system-test/2-query/orderBy.py
@@ -278,11 +278,30 @@ class TDTestCase:
 
     def queryOrderByAgg(self):
 
+        tdSql.query("SELECT COUNT(*) FROM t1 order by COUNT(*)")
+
+        tdSql.query("SELECT COUNT(*) FROM t1 order by last(c2)")
+
+        tdSql.query("SELECT c1 FROM t1 order by last(ts)")
+
+        tdSql.query("SELECT ts FROM t1 order by last(ts)")
+
+        tdSql.query("SELECT last(ts), ts, c1 FROM t1 order by 2")
+
+        tdSql.query("SELECT ts, last(ts) FROM t1 order by last(ts)")
+
         tdSql.query(f"SELECT * FROM t1 order by last(ts)")
 
-        tdSql.query(f"SELECT last(ts) FROM t1 order by last(ts)")
+        tdSql.query(f"SELECT last(ts) as t2, ts FROM t1 order by 1")
+        tdSql.checkRows(1)
 
         tdSql.query(f"SELECT last(ts), ts FROM t1 order by last(ts)")
+        tdSql.checkRows(1)
+
+        tdSql.error(f"SELECT first(ts), ts FROM t1 order by last(ts)")
+
+        tdSql.error(f"SELECT last(ts) as t2, ts FROM t1 order by last(t2)")
+
 
     # run
     def run(self):

From a7943918662ba7dc56e3c2a63efac17e043843f2 Mon Sep 17 00:00:00 2001
From: factosea <285808407@qq.com>
Date: Mon, 15 Jan 2024 02:40:50 +0800
Subject: [PATCH 21/47] unused code

---
 source/libs/executor/src/executil.c | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c
index 0a0502c7f5..9ac53a512c 100644
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@@ -1478,17 +1478,6 @@ void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) {
         pExp->base.pParam[j].type = FUNC_PARAM_TYPE_VALUE;
         nodesValueNodeToVariant(pvn, &pExp->base.pParam[j].param);
       } 
-      // else if (p1->type == QUERY_NODE_FUNCTION) {
-      //   if (strcmp(((SFunctionNode*)p1)->functionName, "_select_value") == 0 &&
-      //     ((SFunctionNode*)p1)->pParameterList->length == 1 &&
-      //     ((SFunctionNode*)p1)->pParameterList->pHead->pNode->type == QUERY_NODE_COLUMN) {
-      //       SColumnNode* pcn = (SColumnNode*)(((SFunctionNode*)p1)->pParameterList->pHead->pNode);
-      //       SValueNode* pvn = (SValueNode*)p1;
-      //       pExp->base.pParam[j].type = FUNC_PARAM_TYPE_COLUMN;
-      //       pExp->base.pParam[j].pCol =
-      //         createColumn(pcn->dataBlockId, pcn->slotId, pcn->colId, &pcn->node.resType, pcn->colType);
-      //   }
-      // }
     }
   } else if (type == QUERY_NODE_OPERATOR) {
     pExp->pExpr->nodeType = QUERY_NODE_OPERATOR;

From 10f1cbf734f655c1f86d3e38b422acea5a1a2ae6 Mon Sep 17 00:00:00 2001
From: Alex Duan <417921451@qq.com>
Date: Mon, 15 Jan 2024 09:21:03 +0800
Subject: [PATCH 22/47] fix: right parenthesis missing

---
 tests/system-test/2-query/sum.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/system-test/2-query/sum.py b/tests/system-test/2-query/sum.py
index 1e428491a6..b600387603 100644
--- a/tests/system-test/2-query/sum.py
+++ b/tests/system-test/2-query/sum.py
@@ -228,7 +228,7 @@ class TDTestCase:
 
             # query
             col = f"c{i}"
-            sql = f"select count({col}), sum({col}), avg({col}), max({col}), min({col}), stddev({col}, leastsquares({col},1,9)) from stb"
+            sql = f"select count({col}), sum({col}), avg({col}), max({col}), min({col}), stddev({col}), leastsquares({col},1,9)) from stb"
             tdSql.query(sql)
             # sum
             tdSql.checkData(0, 0, 4*10000, True)

From a53390415d71bb4c675fa09f57599c5fa60d75e6 Mon Sep 17 00:00:00 2001
From: kailixu <klxu@taosdata.com>
Date: Mon, 15 Jan 2024 10:22:23 +0800
Subject: [PATCH 23/47] fix: taos clean up

---
 source/client/src/clientMain.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/source/client/src/clientMain.c b/source/client/src/clientMain.c
index b99654172c..f6aef5aa26 100644
--- a/source/client/src/clientMain.c
+++ b/source/client/src/clientMain.c
@@ -57,10 +57,6 @@ void taos_cleanup(void) {
 
   tscStopCrashReport();
 
-  int32_t id = clientReqRefPool;
-  clientReqRefPool = -1;
-  taosCloseRef(id);
-
   hbMgrCleanUp();
 
   catalogDestroy();
@@ -70,6 +66,12 @@ void taos_cleanup(void) {
   qCleanupKeywordsTable();
   nodesDestroyAllocatorSet();
 
+  cleanupTaskQueue();
+
+  int32_t id = clientReqRefPool;
+  clientReqRefPool = -1;
+  taosCloseRef(id);
+
   id = clientConnRefPool;
   clientConnRefPool = -1;
   taosCloseRef(id);
@@ -77,8 +79,6 @@ void taos_cleanup(void) {
   rpcCleanup();
   tscDebug("rpc cleanup");
 
-  cleanupTaskQueue();
-
   taosConvDestroy();
 
   tscInfo("all local resources released");

From 062e5a339ee34db0b020cf9e64c2d5da67797079 Mon Sep 17 00:00:00 2001
From: Alex Duan <417921451@qq.com>
Date: Mon, 15 Jan 2024 11:23:04 +0800
Subject: [PATCH 24/47] fix: sum.py support -R

---
 tests/pytest/util/autogen.py     | 7 +++----
 tests/system-test/2-query/sum.py | 4 +++-
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/tests/pytest/util/autogen.py b/tests/pytest/util/autogen.py
index 243cb8c333..f1af5364d2 100644
--- a/tests/pytest/util/autogen.py
+++ b/tests/pytest/util/autogen.py
@@ -114,7 +114,6 @@ class AutoGen:
     def create_db(self, dbname, vgroups = 2, replica = 1):
         self.dbname  = dbname
         tdSql.execute(f'create database {dbname} vgroups {vgroups} replica {replica}')
-        tdSql.execute(f'use {dbname}')
         
     # create table or stable
     def create_stable(self, stbname, tag_cnt, column_cnt, binary_len, nchar_len):
@@ -124,7 +123,7 @@ class AutoGen:
         self.mtags, tags = self.gen_columns_sql("t", tag_cnt, binary_len, nchar_len)
         self.mcols, cols = self.gen_columns_sql("c", column_cnt - 1, binary_len, nchar_len)
 
-        sql = f"create table {stbname} (ts timestamp, {cols}) tags({tags})"
+        sql = f"create table {self.dbname}.{stbname} (ts timestamp, {cols}) tags({tags})"
         tdSql.execute(sql)
 
     # create child table 
@@ -133,7 +132,7 @@ class AutoGen:
         self.child_name = prename
         for i in range(cnt):
             tags_data = self.gen_data(i, self.mtags)
-            sql = f"create table {prename}{i} using {stbname} tags({tags_data})"
+            sql = f"create table {self.dbname}.{prename}{i} using {stbname} tags({tags_data})"
             tdSql.execute(sql)
 
         tdLog.info(f"create child tables {cnt} ok")
@@ -158,7 +157,7 @@ class AutoGen:
 
         # end batch
         if values != "":
-            sql = f"insert into {child_name} values {values}"
+            sql = f"insert into {self.dbname}.{child_name} values {values}"
             tdSql.execute(sql)
             tdLog.info(f" insert data i={i}")
             values = ""
diff --git a/tests/system-test/2-query/sum.py b/tests/system-test/2-query/sum.py
index b600387603..5e372bca20 100644
--- a/tests/system-test/2-query/sum.py
+++ b/tests/system-test/2-query/sum.py
@@ -211,9 +211,11 @@ class TDTestCase:
     def testAllTypes(self):
         # create stable and insert
         tdLog.info("test all types")
+        dbname  = "sumdb"
         stbname = "stb"
         colnum = 16
         self.autoGen.set_batch_size(1000)
+        self.autoGen.create_db(dbname)
         self.autoGen.create_stable(stbname, 16, colnum, 8, 16)
         self.autoGen.create_child(stbname, "d", 4)
         self.autoGen.insert_data(10000)
@@ -228,7 +230,7 @@ class TDTestCase:
 
             # query
             col = f"c{i}"
-            sql = f"select count({col}), sum({col}), avg({col}), max({col}), min({col}), stddev({col}), leastsquares({col},1,9)) from stb"
+            sql = f"select count({col}), sum({col}), avg({col}), max({col}), min({col}), stddev({col}), leastsquares({col},1,9) from {dbname}.{stbname}"
             tdSql.query(sql)
             # sum
             tdSql.checkData(0, 0, 4*10000, True)

From e012bc4bdeb58965a61f69101863893368caa19f Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Mon, 15 Jan 2024 11:28:36 +0800
Subject: [PATCH 25/47] refactor: do some internal refactor.

---
 include/libs/stream/tstream.h              |   7 +-
 source/dnode/vnode/src/tq/tq.c             |   2 -
 source/dnode/vnode/src/tqCommon/tqCommon.c |  35 +----
 source/libs/stream/inc/streamInt.h         |   2 +-
 source/libs/stream/src/stream.c            |  28 +---
 source/libs/stream/src/streamMeta.c        | 142 +++++++++++++-----
 source/libs/stream/src/streamStart.c       | 109 --------------
 source/libs/stream/src/streamTask.c        | 165 +++++++++++++--------
 8 files changed, 224 insertions(+), 266 deletions(-)

diff --git a/include/libs/stream/tstream.h b/include/libs/stream/tstream.h
index 04694b05fd..ba5219cf20 100644
--- a/include/libs/stream/tstream.h
+++ b/include/libs/stream/tstream.h
@@ -801,7 +801,7 @@ int32_t streamTaskCheckStatus(SStreamTask* pTask, int32_t upstreamTaskId, int32_
                               int64_t* oldStage);
 int32_t streamTaskUpdateEpsetInfo(SStreamTask* pTask, SArray* pNodeList);
 void    streamTaskResetUpstreamStageInfo(SStreamTask* pTask);
-bool    streamTaskAllUpstreamClosed(SStreamTask* pTask);
+bool    streamTaskIsAllUpstreamClosed(SStreamTask* pTask);
 bool    streamTaskSetSchedStatusWait(SStreamTask* pTask);
 int8_t  streamTaskSetSchedStatusActive(SStreamTask* pTask);
 int8_t  streamTaskSetSchedStatusInactive(SStreamTask* pTask);
@@ -826,8 +826,7 @@ int32_t streamQueueGetNumOfItems(const SStreamQueue* pQueue);
 
 // common
 int32_t streamRestoreParam(SStreamTask* pTask);
-int32_t streamResetParamForScanHistory(SStreamTask* pTask);
-void    streamTaskPause(SStreamTask* pTask, SStreamMeta* pMeta);
+void    streamTaskPause(SStreamMeta* pMeta, SStreamTask* pTask);
 void    streamTaskResume(SStreamTask* pTask);
 int32_t streamTaskSetUpstreamInfo(SStreamTask* pTask, const SStreamTask* pUpstreamTask);
 void    streamTaskUpdateUpstreamInfo(SStreamTask* pTask, int32_t nodeId, const SEpSet* pEpSet);
@@ -835,7 +834,7 @@ void    streamTaskUpdateDownstreamInfo(SStreamTask* pTask, int32_t nodeId, const
 void    streamTaskSetFixedDownstreamInfo(SStreamTask* pTask, const SStreamTask* pDownstreamTask);
 int32_t streamTaskReleaseState(SStreamTask* pTask);
 int32_t streamTaskReloadState(SStreamTask* pTask);
-void    streamTaskCloseUpstreamInput(SStreamTask* pTask, int32_t taskId);
+void    streamTaskCloseAllUpstreamInput(SStreamTask* pTask, int32_t taskId);
 void    streamTaskOpenAllUpstreamInput(SStreamTask* pTask);
 int32_t streamTaskSetDb(SStreamMeta* pMeta, void* pTask, char* key);
 
diff --git a/source/dnode/vnode/src/tq/tq.c b/source/dnode/vnode/src/tq/tq.c
index a53b322753..016e3e199e 100644
--- a/source/dnode/vnode/src/tq/tq.c
+++ b/source/dnode/vnode/src/tq/tq.c
@@ -742,8 +742,6 @@ int32_t tqExpandTask(STQ* pTq, SStreamTask* pTask, int64_t nextProcessVer) {
     return code;
   }
 
-  streamTaskOpenAllUpstreamInput(pTask);
-
   if (pTask->info.taskLevel == TASK_LEVEL__SOURCE) {
     STaskId taskId = {0};
     if (pTask->info.fillHistory) {
diff --git a/source/dnode/vnode/src/tqCommon/tqCommon.c b/source/dnode/vnode/src/tqCommon/tqCommon.c
index 5a92677462..358af0b083 100644
--- a/source/dnode/vnode/src/tqCommon/tqCommon.c
+++ b/source/dnode/vnode/src/tqCommon/tqCommon.c
@@ -76,33 +76,6 @@ int32_t tqStreamOneTaskStartAsync(SStreamMeta* pMeta, SMsgCb* cb, int64_t stream
   return 0;
 }
 
-int32_t tqUpdateNodeEpsetAsync(SStreamMeta* pMeta, SMsgCb* cb, int64_t streamId, int32_t taskId) {
-  int32_t vgId = pMeta->vgId;
-
-  int32_t numOfTasks = taosArrayGetSize(pMeta->pTaskList);
-  if (numOfTasks == 0) {
-    tqDebug("vgId:%d no stream tasks existed to run", vgId);
-    return 0;
-  }
-
-  SStreamTaskRunReq* pRunReq = rpcMallocCont(sizeof(SStreamTaskRunReq));
-  if (pRunReq == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    tqError("vgId:%d failed to create msg to start task:0x%x, code:%s", vgId, taskId, terrstr());
-    return -1;
-  }
-
-  tqDebug("vgId:%d update s-task:0x%x nodeEpset async", vgId, taskId);
-  pRunReq->head.vgId = vgId;
-  pRunReq->streamId = streamId;
-  pRunReq->taskId = taskId;
-  pRunReq->reqType = STREAM_EXEC_T_UPDATE_TASK_EPSET;
-
-  SRpcMsg msg = {.msgType = TDMT_STREAM_TASK_RUN, .pCont = pRunReq, .contLen = sizeof(SStreamTaskRunReq)};
-  tmsgPutToQueue(cb, STREAM_QUEUE, &msg);
-  return 0;
-}
-
 int32_t tqStreamTaskProcessUpdateReq(SStreamMeta* pMeta, SMsgCb* cb, SRpcMsg* pMsg, bool restored) {
   int32_t vgId = pMeta->vgId;
   char*   msg = POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead));
@@ -728,10 +701,6 @@ int32_t tqStreamTaskResetStatus(SStreamMeta* pMeta, int32_t* numOfTasks) {
     STaskId       id = {.streamId = pTaskId->streamId, .taskId = pTaskId->taskId};
     SStreamTask** pTask = taosHashGet(pMeta->pTasksMap, &id, sizeof(id));
     streamTaskResetStatus(*pTask);
-
-//    if ((*pTask)->info.fillHistory == 1) {
-//      streamResetParamForScanHistory(*pTask);
-//    }
   }
 
   return 0;
@@ -922,7 +891,7 @@ int32_t tqStreamTaskProcessTaskPauseReq(SStreamMeta* pMeta, char* pMsg){
   }
 
   tqDebug("s-task:%s receive pause msg from mnode", pTask->id.idStr);
-  streamTaskPause(pTask, pMeta);
+  streamTaskPause(pMeta, pTask);
 
   SStreamTask* pHistoryTask = NULL;
   if (HAS_RELATED_FILLHISTORY_TASK(pTask)) {
@@ -939,7 +908,7 @@ int32_t tqStreamTaskProcessTaskPauseReq(SStreamMeta* pMeta, char* pMsg){
 
     tqDebug("s-task:%s fill-history task handle paused along with related stream task", pHistoryTask->id.idStr);
 
-    streamTaskPause(pHistoryTask, pMeta);
+    streamTaskPause(pMeta, pHistoryTask);
     streamMetaReleaseTask(pMeta, pHistoryTask);
   }
 
diff --git a/source/libs/stream/inc/streamInt.h b/source/libs/stream/inc/streamInt.h
index 1d1eda74f6..1e4b8996b6 100644
--- a/source/libs/stream/inc/streamInt.h
+++ b/source/libs/stream/inc/streamInt.h
@@ -120,7 +120,7 @@ int32_t streamTaskSendCheckpointSourceRsp(SStreamTask* pTask);
 void    streamTaskSetCheckpointFailedId(SStreamTask* pTask);
 int32_t streamTaskGetNumOfDownstream(const SStreamTask* pTask);
 int32_t streamTaskInitTokenBucket(STokenBucket* pBucket, int32_t numCap, int32_t numRate, float quotaRate, const char*);
-STaskId streamTaskExtractKey(const SStreamTask* pTask);
+STaskId streamTaskGetTaskId(const SStreamTask* pTask);
 void    streamTaskInitForLaunchHTask(SHistoryTaskInfo* pInfo);
 void    streamTaskSetRetryInfoForLaunch(SHistoryTaskInfo* pInfo);
 int32_t streamTaskBuildScanhistoryRspMsg(SStreamTask* pTask, SStreamScanHistoryFinishReq* pReq, void** pBuffer,
diff --git a/source/libs/stream/src/stream.c b/source/libs/stream/src/stream.c
index 7d507a1394..32e724c156 100644
--- a/source/libs/stream/src/stream.c
+++ b/source/libs/stream/src/stream.c
@@ -243,18 +243,18 @@ int32_t streamProcessDispatchMsg(SStreamTask* pTask, SStreamDispatchReq* pReq, S
         // blocked. Note that there is no race condition here.
         if (pReq->type == STREAM_INPUT__CHECKPOINT_TRIGGER) {
           atomic_add_fetch_32(&pTask->upstreamInfo.numOfClosed, 1);
-          streamTaskCloseUpstreamInput(pTask, pReq->upstreamTaskId);
+          streamTaskCloseAllUpstreamInput(pTask, pReq->upstreamTaskId);
           stDebug("s-task:%s close inputQ for upstream:0x%x, msgId:%d", id, pReq->upstreamTaskId, pReq->msgId);
         } else if (pReq->type == STREAM_INPUT__TRANS_STATE) {
           atomic_add_fetch_32(&pTask->upstreamInfo.numOfClosed, 1);
-          streamTaskCloseUpstreamInput(pTask, pReq->upstreamTaskId);
+          streamTaskCloseAllUpstreamInput(pTask, pReq->upstreamTaskId);
 
           // disable the related stream task here to avoid it to receive the newly arrived data after the transfer-state
           STaskId* pRelTaskId = &pTask->streamTaskId;
           SStreamTask* pStreamTask = streamMetaAcquireTask(pMeta, pRelTaskId->streamId, pRelTaskId->taskId);
           if (pStreamTask != NULL) {
             atomic_add_fetch_32(&pStreamTask->upstreamInfo.numOfClosed, 1);
-            streamTaskCloseUpstreamInput(pStreamTask, pReq->upstreamRelTaskId);
+            streamTaskCloseAllUpstreamInput(pStreamTask, pReq->upstreamRelTaskId);
             streamMetaReleaseTask(pMeta, pStreamTask);
           }
 
@@ -300,28 +300,6 @@ int32_t streamProcessRetrieveReq(SStreamTask* pTask, SStreamRetrieveReq* pReq, S
 
 void streamTaskInputFail(SStreamTask* pTask) { atomic_store_8(&pTask->inputq.status, TASK_INPUT_STATUS__FAILED); }
 
-void streamTaskOpenAllUpstreamInput(SStreamTask* pTask) {
-  int32_t num = taosArrayGetSize(pTask->upstreamInfo.pList);
-  if (num == 0) {
-    return;
-  }
-
-  for (int32_t i = 0; i < num; ++i) {
-    SStreamChildEpInfo* pInfo = taosArrayGetP(pTask->upstreamInfo.pList, i);
-    pInfo->dataAllowed = true;
-  }
-
-  pTask->upstreamInfo.numOfClosed = 0;
-  stDebug("s-task:%s opening up inputQ from upstream tasks", pTask->id.idStr);
-}
-
-void streamTaskCloseUpstreamInput(SStreamTask* pTask, int32_t taskId) {
-  SStreamChildEpInfo* pInfo = streamTaskGetUpstreamTaskEpInfo(pTask, taskId);
-  if (pInfo != NULL) {
-    pInfo->dataAllowed = false;
-  }
-}
-
 SStreamChildEpInfo* streamTaskGetUpstreamTaskEpInfo(SStreamTask* pTask, int32_t taskId) {
   int32_t num = taosArrayGetSize(pTask->upstreamInfo.pList);
   for (int32_t i = 0; i < num; ++i) {
diff --git a/source/libs/stream/src/streamMeta.c b/source/libs/stream/src/streamMeta.c
index ee2b70eebe..20e7be0509 100644
--- a/source/libs/stream/src/streamMeta.c
+++ b/source/libs/stream/src/streamMeta.c
@@ -47,6 +47,12 @@ struct SMetaHbInfo {
   int64_t hbStart;
 };
 
+typedef struct STaskInitTs {
+  int64_t start;
+  int64_t end;
+  bool    success;
+} STaskInitTs;
+
 SMetaRefMgt gMetaRefMgt;
 
 void    metaRefMgtInit();
@@ -581,7 +587,7 @@ int32_t streamMetaRemoveTask(SStreamMeta* pMeta, STaskId* pTaskId) {
 int32_t streamMetaRegisterTask(SStreamMeta* pMeta, int64_t ver, SStreamTask* pTask, bool* pAdded) {
   *pAdded = false;
 
-  STaskId id = streamTaskExtractKey(pTask);
+  STaskId id = streamTaskGetTaskId(pTask);
   void*   p = taosHashGet(pMeta->pTasksMap, &id, sizeof(id));
   if (p != NULL) {
     return 0;
@@ -871,7 +877,7 @@ int32_t streamMetaLoadAllTasks(SStreamMeta* pMeta) {
       int32_t taskId = pTask->id.taskId;
       tFreeStreamTask(pTask);
 
-      STaskId id = streamTaskExtractKey(pTask);
+      STaskId id = streamTaskGetTaskId(pTask);
       taosArrayPush(pRecycleList, &id);
 
       int32_t total = taosArrayGetSize(pRecycleList);
@@ -1407,37 +1413,6 @@ void streamMetaUpdateStageRole(SStreamMeta* pMeta, int64_t stage, bool isLeader)
   }
 }
 
-int32_t streamMetaStopAllTasks(SStreamMeta* pMeta) {
-  streamMetaRLock(pMeta);
-
-  int32_t num = taosArrayGetSize(pMeta->pTaskList);
-  stDebug("vgId:%d stop all %d stream task(s)", pMeta->vgId, num);
-  if (num == 0) {
-    streamMetaRUnLock(pMeta);
-    return TSDB_CODE_SUCCESS;
-  }
-
-  // send hb msg to mnode before closing all tasks.
-  SArray* pTaskList = streamMetaSendMsgBeforeCloseTasks(pMeta);
-  int32_t numOfTasks = taosArrayGetSize(pTaskList);
-
-  for (int32_t i = 0; i < numOfTasks; ++i) {
-    SStreamTaskId* pTaskId = taosArrayGet(pTaskList, i);
-    SStreamTask*   pTask = streamMetaAcquireTaskNoLock(pMeta, pTaskId->streamId, pTaskId->taskId);
-    if (pTask == NULL) {
-      continue;
-    }
-
-    streamTaskStop(pTask);
-    streamMetaReleaseTask(pMeta, pTask);
-  }
-
-  taosArrayDestroy(pTaskList);
-
-  streamMetaRUnLock(pMeta);
-  return 0;
-}
-
 int32_t streamMetaStartAllTasks(SStreamMeta* pMeta) {
   int32_t code = TSDB_CODE_SUCCESS;
   int32_t vgId = pMeta->vgId;
@@ -1512,6 +1487,37 @@ int32_t streamMetaStartAllTasks(SStreamMeta* pMeta) {
   return code;
 }
 
+int32_t streamMetaStopAllTasks(SStreamMeta* pMeta) {
+  streamMetaRLock(pMeta);
+
+  int32_t num = taosArrayGetSize(pMeta->pTaskList);
+  stDebug("vgId:%d stop all %d stream task(s)", pMeta->vgId, num);
+  if (num == 0) {
+    streamMetaRUnLock(pMeta);
+    return TSDB_CODE_SUCCESS;
+  }
+
+  // send hb msg to mnode before closing all tasks.
+  SArray* pTaskList = streamMetaSendMsgBeforeCloseTasks(pMeta);
+  int32_t numOfTasks = taosArrayGetSize(pTaskList);
+
+  for (int32_t i = 0; i < numOfTasks; ++i) {
+    SStreamTaskId* pTaskId = taosArrayGet(pTaskList, i);
+    SStreamTask*   pTask = streamMetaAcquireTaskNoLock(pMeta, pTaskId->streamId, pTaskId->taskId);
+    if (pTask == NULL) {
+      continue;
+    }
+
+    streamTaskStop(pTask);
+    streamMetaReleaseTask(pMeta, pTask);
+  }
+
+  taosArrayDestroy(pTaskList);
+
+  streamMetaRUnLock(pMeta);
+  return 0;
+}
+
 int32_t streamMetaStartOneTask(SStreamMeta* pMeta, int64_t streamId, int32_t taskId) {
   int32_t vgId = pMeta->vgId;
   stInfo("vgId:%d start to task:0x%x by checking downstream status", vgId, taskId);
@@ -1547,4 +1553,74 @@ int32_t streamMetaStartOneTask(SStreamMeta* pMeta, int64_t streamId, int32_t tas
 
   streamMetaReleaseTask(pMeta, pTask);
   return ret;
+}
+
+static void displayStatusInfo(SStreamMeta* pMeta, SHashObj* pTaskSet, bool succ) {
+  int32_t vgId = pMeta->vgId;
+  void*   pIter = NULL;
+  size_t  keyLen = 0;
+
+  stInfo("vgId:%d %d tasks check-downstream completed %s", vgId, taosHashGetSize(pTaskSet),
+         succ ? "success" : "failed");
+
+  while ((pIter = taosHashIterate(pTaskSet, pIter)) != NULL) {
+    STaskInitTs* pInfo = pIter;
+    void*        key = taosHashGetKey(pIter, &keyLen);
+
+    SStreamTask** pTask1 = taosHashGet(pMeta->pTasksMap, key, sizeof(STaskId));
+    if (pTask1 == NULL) {
+      stInfo("s-task:0x%x is dropped already, %s", (int32_t)((STaskId*)key)->taskId, succ ? "success" : "failed");
+    } else {
+      stInfo("s-task:%s level:%d vgId:%d, init:%" PRId64 ", initEnd:%" PRId64 ", %s", (*pTask1)->id.idStr,
+             (*pTask1)->info.taskLevel, vgId, pInfo->start, pInfo->end, pInfo->success ? "success" : "failed");
+    }
+  }
+}
+
+int32_t streamMetaAddTaskLaunchResult(SStreamMeta* pMeta, int64_t streamId, int32_t taskId, int64_t startTs,
+                                      int64_t endTs, bool ready) {
+  STaskStartInfo* pStartInfo = &pMeta->startInfo;
+  STaskId         id = {.streamId = streamId, .taskId = taskId};
+
+  streamMetaWLock(pMeta);
+
+  if (pStartInfo->taskStarting != 1) {
+    int64_t el = endTs - startTs;
+    qDebug("vgId:%d not start all task(s), not record status, s-task:0x%x launch succ:%d elapsed time:%" PRId64 "ms",
+           pMeta->vgId, taskId, ready, el);
+    streamMetaWUnLock(pMeta);
+    return 0;
+  }
+
+  SHashObj* pDst = ready ? pStartInfo->pReadyTaskSet : pStartInfo->pFailedTaskSet;
+
+  STaskInitTs initTs = {.start = startTs, .end = endTs, .success = ready};
+  taosHashPut(pDst, &id, sizeof(id), &initTs, sizeof(STaskInitTs));
+
+  int32_t numOfTotal = streamMetaGetNumOfTasks(pMeta);
+  int32_t numOfRecv = taosHashGetSize(pStartInfo->pReadyTaskSet) + taosHashGetSize(pStartInfo->pFailedTaskSet);
+
+  if (numOfRecv == numOfTotal) {
+    pStartInfo->readyTs = taosGetTimestampMs();
+    pStartInfo->elapsedTime = (pStartInfo->startTs != 0) ? pStartInfo->readyTs - pStartInfo->startTs : 0;
+
+    stDebug("vgId:%d all %d task(s) check downstream completed, last completed task:0x%x (succ:%d) startTs:%" PRId64
+                ", readyTs:%" PRId64 " total elapsed time:%.2fs",
+            pMeta->vgId, numOfTotal, taskId, ready, pStartInfo->startTs, pStartInfo->readyTs,
+            pStartInfo->elapsedTime / 1000.0);
+
+    // print the initialization elapsed time and info
+    displayStatusInfo(pMeta, pStartInfo->pReadyTaskSet, true);
+    displayStatusInfo(pMeta, pStartInfo->pFailedTaskSet, false);
+    streamMetaResetStartInfo(pStartInfo);
+    streamMetaWUnLock(pMeta);
+
+    pStartInfo->completeFn(pMeta);
+  } else {
+    streamMetaWUnLock(pMeta);
+    stDebug("vgId:%d recv check downstream results, s-task:0x%x succ:%d, received:%d, total:%d", pMeta->vgId, taskId,
+            ready, numOfRecv, numOfTotal);
+  }
+
+  return TSDB_CODE_SUCCESS;
 }
\ No newline at end of file
diff --git a/source/libs/stream/src/streamStart.c b/source/libs/stream/src/streamStart.c
index 84f1dbb4d7..5e1566c1e1 100644
--- a/source/libs/stream/src/streamStart.c
+++ b/source/libs/stream/src/streamStart.c
@@ -35,12 +35,6 @@ typedef struct STaskRecheckInfo {
   void*               checkTimer;
 } STaskRecheckInfo;
 
-typedef struct STaskInitTs {
-  int64_t start;
-  int64_t end;
-  bool    success;
-} STaskInitTs;
-
 static int32_t           streamSetParamForScanHistory(SStreamTask* pTask);
 static void              streamTaskSetRangeStreamCalc(SStreamTask* pTask);
 static int32_t           initScanHistoryReq(SStreamTask* pTask, SStreamScanHistoryReq* pReq, int8_t igUntreated);
@@ -546,15 +540,6 @@ int32_t streamSetParamForScanHistory(SStreamTask* pTask) {
   return qSetStreamOperatorOptionForScanHistory(pTask->exec.pExecutor);
 }
 
-int32_t streamResetParamForScanHistory(SStreamTask* pTask) {
-  stDebug("s-task:%s reset operator option for scan-history data", pTask->id.idStr);
-  if (pTask->exec.pExecutor != NULL) {
-    return qResetStreamOperatorOptionForScanHistory(pTask->exec.pExecutor);
-  } else {
-    return TSDB_CODE_SUCCESS;
-  }
-}
-
 int32_t streamRestoreParam(SStreamTask* pTask) {
   stDebug("s-task:%s restore operator param after scan-history", pTask->id.idStr);
   return qRestoreStreamOperatorOption(pTask->exec.pExecutor);
@@ -1134,97 +1119,3 @@ void streamTaskSetRangeStreamCalc(SStreamTask* pTask) {
   }
 }
 
-void streamTaskPause(SStreamTask* pTask, SStreamMeta* pMeta) {
-  streamTaskHandleEvent(pTask->status.pSM, TASK_EVENT_PAUSE);
-
-  int32_t num = atomic_add_fetch_32(&pMeta->numOfPausedTasks, 1);
-  stInfo("vgId:%d s-task:%s pause stream task. pause task num:%d", pMeta->vgId, pTask->id.idStr, num);
-
-  // in case of fill-history task, stop the tsdb file scan operation.
-  if (pTask->info.fillHistory == 1) {
-    void* pExecutor = pTask->exec.pExecutor;
-    qKillTask(pExecutor, TSDB_CODE_SUCCESS);
-  }
-
-  stDebug("vgId:%d s-task:%s set pause flag and pause task", pMeta->vgId, pTask->id.idStr);
-}
-
-void streamTaskResume(SStreamTask* pTask) {
-  SStreamTaskState prevState = *streamTaskGetStatus(pTask);
-  SStreamMeta* pMeta = pTask->pMeta;
-
-  if (prevState.state == TASK_STATUS__PAUSE || prevState.state == TASK_STATUS__HALT) {
-    streamTaskRestoreStatus(pTask);
-
-    char* pNew = streamTaskGetStatus(pTask)->name;
-    if (prevState.state == TASK_STATUS__PAUSE) {
-      int32_t num = atomic_sub_fetch_32(&pMeta->numOfPausedTasks, 1);
-      stInfo("s-task:%s status:%s resume from %s, paused task(s):%d", pTask->id.idStr, pNew, prevState.name, num);
-    } else {
-      stInfo("s-task:%s status:%s resume from %s", pTask->id.idStr, pNew, prevState.name);
-    }
-  } else {
-    stDebug("s-task:%s status:%s not in pause/halt status, no need to resume", pTask->id.idStr, prevState.name);
-  }
-}
-
-static void displayStatusInfo(SStreamMeta* pMeta, SHashObj* pTaskSet, bool succ) {
-  int32_t vgId = pMeta->vgId;
-  void*   pIter = NULL;
-  size_t  keyLen = 0;
-
-  stInfo("vgId:%d %d tasks check-downstream completed %s", vgId, taosHashGetSize(pTaskSet),
-         succ ? "success" : "failed");
-
-  while ((pIter = taosHashIterate(pTaskSet, pIter)) != NULL) {
-    STaskInitTs* pInfo = pIter;
-    void*        key = taosHashGetKey(pIter, &keyLen);
-
-    SStreamTask** pTask1 = taosHashGet(pMeta->pTasksMap, key, sizeof(STaskId));
-    if (pTask1 == NULL) {
-      stInfo("s-task:0x%x is dropped already, %s", (int32_t)((STaskId*)key)->taskId, succ ? "success" : "failed");
-    } else {
-      stInfo("s-task:%s level:%d vgId:%d, init:%" PRId64 ", initEnd:%" PRId64 ", %s", (*pTask1)->id.idStr,
-             (*pTask1)->info.taskLevel, vgId, pInfo->start, pInfo->end, pInfo->success ? "success" : "failed");
-    }
-  }
-}
-
-int32_t streamMetaAddTaskLaunchResult(SStreamMeta* pMeta, int64_t streamId, int32_t taskId, int64_t startTs,
-                                             int64_t endTs, bool ready) {
-  STaskStartInfo* pStartInfo = &pMeta->startInfo;
-  STaskId         id = {.streamId = streamId, .taskId = taskId};
-
-  streamMetaWLock(pMeta);
-  SHashObj* pDst = ready ? pStartInfo->pReadyTaskSet : pStartInfo->pFailedTaskSet;
-
-  STaskInitTs initTs = {.start = startTs, .end = endTs, .success = ready};
-  taosHashPut(pDst, &id, sizeof(id), &initTs, sizeof(STaskInitTs));
-
-  int32_t numOfTotal = streamMetaGetNumOfTasks(pMeta);
-  int32_t numOfRecv = taosHashGetSize(pStartInfo->pReadyTaskSet) + taosHashGetSize(pStartInfo->pFailedTaskSet);
-
-  if (numOfRecv == numOfTotal) {
-    pStartInfo->readyTs = taosGetTimestampMs();
-    pStartInfo->elapsedTime = (pStartInfo->startTs != 0) ? pStartInfo->readyTs - pStartInfo->startTs : 0;
-
-    stDebug("vgId:%d all %d task(s) check downstream completed, last completed task:0x%x (succ:%d) startTs:%" PRId64
-            ", readyTs:%" PRId64 " total elapsed time:%.2fs",
-            pMeta->vgId, numOfTotal, taskId, ready, pStartInfo->startTs, pStartInfo->readyTs,
-            pStartInfo->elapsedTime / 1000.0);
-
-    // print the initialization elapsed time and info
-    displayStatusInfo(pMeta, pStartInfo->pReadyTaskSet, true);
-    displayStatusInfo(pMeta, pStartInfo->pFailedTaskSet, false);
-    streamMetaResetStartInfo(pStartInfo);
-    streamMetaWUnLock(pMeta);
-
-    pStartInfo->completeFn(pMeta);
-  } else {
-    streamMetaWUnLock(pMeta);
-    stDebug("vgId:%d recv check downstream results, s-task:0x%x succ:%d, received:%d, total:%d", pMeta->vgId, taskId,
-            ready, numOfRecv, numOfTotal);
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
diff --git a/source/libs/stream/src/streamTask.c b/source/libs/stream/src/streamTask.c
index c14d355dc8..881f10502c 100644
--- a/source/libs/stream/src/streamTask.c
+++ b/source/libs/stream/src/streamTask.c
@@ -30,6 +30,55 @@ static int32_t addToTaskset(SArray* pArray, SStreamTask* pTask) {
   return 0;
 }
 
+static int32_t doUpdateTaskEpset(SStreamTask* pTask, int32_t nodeId, SEpSet* pEpSet) {
+  char buf[512] = {0};
+
+  if (pTask->info.nodeId == nodeId) {  // execution task should be moved away
+    epsetAssign(&pTask->info.epSet, pEpSet);
+    EPSET_TO_STR(pEpSet, buf)
+    stDebug("s-task:0x%x (vgId:%d) self node epset is updated %s", pTask->id.taskId, nodeId, buf);
+  }
+
+  // check for the dispath info and the upstream task info
+  int32_t level = pTask->info.taskLevel;
+  if (level == TASK_LEVEL__SOURCE) {
+    streamTaskUpdateDownstreamInfo(pTask, nodeId, pEpSet);
+  } else if (level == TASK_LEVEL__AGG) {
+    streamTaskUpdateUpstreamInfo(pTask, nodeId, pEpSet);
+    streamTaskUpdateDownstreamInfo(pTask, nodeId, pEpSet);
+  } else {  // TASK_LEVEL__SINK
+    streamTaskUpdateUpstreamInfo(pTask, nodeId, pEpSet);
+  }
+
+  return 0;
+}
+
+static void freeItem(void* p) {
+  SStreamContinueExecInfo* pInfo = p;
+  rpcFreeCont(pInfo->msg.pCont);
+}
+
+static void freeUpstreamItem(void* p) {
+  SStreamChildEpInfo** pInfo = p;
+  taosMemoryFree(*pInfo);
+}
+
+static SStreamChildEpInfo* createStreamTaskEpInfo(const SStreamTask* pTask) {
+  SStreamChildEpInfo* pEpInfo = taosMemoryMalloc(sizeof(SStreamChildEpInfo));
+  if (pEpInfo == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
+
+  pEpInfo->childId = pTask->info.selfChildId;
+  pEpInfo->epSet = pTask->info.epSet;
+  pEpInfo->nodeId = pTask->info.nodeId;
+  pEpInfo->taskId = pTask->id.taskId;
+  pEpInfo->stage = -1;
+
+  return pEpInfo;
+}
+
 SStreamTask* tNewStreamTask(int64_t streamId, int8_t taskLevel, bool fillHistory, int64_t triggerParam,
                             SArray* pTaskList, bool hasFillhistory) {
   SStreamTask* pTask = (SStreamTask*)taosMemoryCalloc(1, sizeof(SStreamTask));
@@ -291,16 +340,6 @@ int32_t tDecodeStreamTaskId(SDecoder* pDecoder, STaskId* pTaskId) {
   return 0;
 }
 
-static void freeItem(void* p) {
-  SStreamContinueExecInfo* pInfo = p;
-  rpcFreeCont(pInfo->msg.pCont);
-}
-
-static void freeUpstreamItem(void* p) {
-  SStreamChildEpInfo** pInfo = p;
-  taosMemoryFree(*pInfo);
-}
-
 void tFreeStreamTask(SStreamTask* pTask) {
   char*                p = NULL;
   int32_t              taskId = pTask->id.taskId;
@@ -475,14 +514,6 @@ int32_t streamTaskInit(SStreamTask* pTask, SStreamMeta* pMeta, SMsgCb* pMsgCb, i
   }
 
   taosThreadMutexInit(&pTask->lock, &attr);
-  // if (pTask->info.fillHistory == 1) {
-  //   // 
-  // } else {
-
-  // }
-  // if (streamTaskSetDb(pMeta, pTask) != 0) {
-  //   return -1;
-  // }
   streamTaskOpenAllUpstreamInput(pTask);
 
   pTask->outputInfo.pDownstreamUpdateList = taosArrayInit(4, sizeof(SDownstreamTaskEpset));
@@ -509,22 +540,6 @@ int32_t streamTaskGetNumOfDownstream(const SStreamTask* pTask) {
   }
 }
 
-static SStreamChildEpInfo* createStreamTaskEpInfo(const SStreamTask* pTask) {
-  SStreamChildEpInfo* pEpInfo = taosMemoryMalloc(sizeof(SStreamChildEpInfo));
-  if (pEpInfo == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
-  }
-
-  pEpInfo->childId = pTask->info.selfChildId;
-  pEpInfo->epSet = pTask->info.epSet;
-  pEpInfo->nodeId = pTask->info.nodeId;
-  pEpInfo->taskId = pTask->id.taskId;
-  pEpInfo->stage = -1;
-
-  return pEpInfo;
-}
-
 int32_t streamTaskSetUpstreamInfo(SStreamTask* pTask, const SStreamTask* pUpstreamTask) {
   SStreamChildEpInfo* pEpInfo = createStreamTaskEpInfo(pUpstreamTask);
   if (pEpInfo == NULL) {
@@ -622,29 +637,6 @@ int32_t streamTaskStop(SStreamTask* pTask) {
   return 0;
 }
 
-int32_t doUpdateTaskEpset(SStreamTask* pTask, int32_t nodeId, SEpSet* pEpSet) {
-  char buf[512] = {0};
-
-  if (pTask->info.nodeId == nodeId) {  // execution task should be moved away
-    epsetAssign(&pTask->info.epSet, pEpSet);
-    EPSET_TO_STR(pEpSet, buf)
-    stDebug("s-task:0x%x (vgId:%d) self node epset is updated %s", pTask->id.taskId, nodeId, buf);
-  }
-
-  // check for the dispath info and the upstream task info
-  int32_t level = pTask->info.taskLevel;
-  if (level == TASK_LEVEL__SOURCE) {
-    streamTaskUpdateDownstreamInfo(pTask, nodeId, pEpSet);
-  } else if (level == TASK_LEVEL__AGG) {
-    streamTaskUpdateUpstreamInfo(pTask, nodeId, pEpSet);
-    streamTaskUpdateDownstreamInfo(pTask, nodeId, pEpSet);
-  } else {  // TASK_LEVEL__SINK
-    streamTaskUpdateUpstreamInfo(pTask, nodeId, pEpSet);
-  }
-
-  return 0;
-}
-
 int32_t streamTaskUpdateEpsetInfo(SStreamTask* pTask, SArray* pNodeList) {
   STaskExecStatisInfo* p = &pTask->execInfo;
 
@@ -677,7 +669,29 @@ void streamTaskResetUpstreamStageInfo(SStreamTask* pTask) {
   stDebug("s-task:%s reset all upstream tasks stage info", pTask->id.idStr);
 }
 
-bool streamTaskAllUpstreamClosed(SStreamTask* pTask) {
+void streamTaskOpenAllUpstreamInput(SStreamTask* pTask) {
+  int32_t num = taosArrayGetSize(pTask->upstreamInfo.pList);
+  if (num == 0) {
+    return;
+  }
+
+  for (int32_t i = 0; i < num; ++i) {
+    SStreamChildEpInfo* pInfo = taosArrayGetP(pTask->upstreamInfo.pList, i);
+    pInfo->dataAllowed = true;
+  }
+
+  pTask->upstreamInfo.numOfClosed = 0;
+  stDebug("s-task:%s opening up inputQ for %d upstream tasks", pTask->id.idStr, num);
+}
+
+void streamTaskCloseAllUpstreamInput(SStreamTask* pTask, int32_t taskId) {
+  SStreamChildEpInfo* pInfo = streamTaskGetUpstreamTaskEpInfo(pTask, taskId);
+  if (pInfo != NULL) {
+    pInfo->dataAllowed = false;
+  }
+}
+
+bool streamTaskIsAllUpstreamClosed(SStreamTask* pTask) {
   return pTask->upstreamInfo.numOfClosed == taosArrayGetSize(pTask->upstreamInfo.pList);
 }
 
@@ -760,7 +774,7 @@ int32_t streamBuildAndSendDropTaskMsg(SMsgCb* pMsgCb, int32_t vgId, SStreamTaskI
   return code;
 }
 
-STaskId streamTaskExtractKey(const SStreamTask* pTask) {
+STaskId streamTaskGetTaskId(const SStreamTask* pTask) {
   STaskId id = {.streamId = pTask->id.streamId, .taskId = pTask->id.taskId};
   return id;
 }
@@ -801,3 +815,36 @@ void streamTaskStatusCopy(STaskStatusEntry* pDst, const STaskStatusEntry* pSrc)
   pDst->chkpointTransId = pSrc->chkpointTransId;
 }
 
+void streamTaskPause(SStreamMeta* pMeta, SStreamTask* pTask) {
+  streamTaskHandleEvent(pTask->status.pSM, TASK_EVENT_PAUSE);
+
+  int32_t num = atomic_add_fetch_32(&pMeta->numOfPausedTasks, 1);
+  stInfo("vgId:%d s-task:%s pause stream task. pause task num:%d", pMeta->vgId, pTask->id.idStr, num);
+
+  // in case of fill-history task, stop the tsdb file scan operation.
+  if (pTask->info.fillHistory == 1) {
+    void* pExecutor = pTask->exec.pExecutor;
+    qKillTask(pExecutor, TSDB_CODE_SUCCESS);
+  }
+
+  stDebug("vgId:%d s-task:%s set pause flag and pause task", pMeta->vgId, pTask->id.idStr);
+}
+
+void streamTaskResume(SStreamTask* pTask) {
+  SStreamTaskState prevState = *streamTaskGetStatus(pTask);
+  SStreamMeta* pMeta = pTask->pMeta;
+
+  if (prevState.state == TASK_STATUS__PAUSE || prevState.state == TASK_STATUS__HALT) {
+    streamTaskRestoreStatus(pTask);
+
+    char* pNew = streamTaskGetStatus(pTask)->name;
+    if (prevState.state == TASK_STATUS__PAUSE) {
+      int32_t num = atomic_sub_fetch_32(&pMeta->numOfPausedTasks, 1);
+      stInfo("s-task:%s status:%s resume from %s, paused task(s):%d", pTask->id.idStr, pNew, prevState.name, num);
+    } else {
+      stInfo("s-task:%s status:%s resume from %s", pTask->id.idStr, pNew, prevState.name);
+    }
+  } else {
+    stDebug("s-task:%s status:%s not in pause/halt status, no need to resume", pTask->id.idStr, prevState.name);
+  }
+}

From 2e4b268f4cc4ef7e3c2481e9a3e715cbcdffd4fb Mon Sep 17 00:00:00 2001
From: Alex Duan <417921451@qq.com>
Date: Mon, 15 Jan 2024 12:42:41 +0800
Subject: [PATCH 26/47] fix: add dbname on using stb

---
 tests/pytest/util/autogen.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/pytest/util/autogen.py b/tests/pytest/util/autogen.py
index f1af5364d2..9c5378132f 100644
--- a/tests/pytest/util/autogen.py
+++ b/tests/pytest/util/autogen.py
@@ -132,7 +132,7 @@ class AutoGen:
         self.child_name = prename
         for i in range(cnt):
             tags_data = self.gen_data(i, self.mtags)
-            sql = f"create table {self.dbname}.{prename}{i} using {stbname} tags({tags_data})"
+            sql = f"create table {self.dbname}.{prename}{i} using {self.dbname}.{stbname} tags({tags_data})"
             tdSql.execute(sql)
 
         tdLog.info(f"create child tables {cnt} ok")

From 448ba5886117545896d418a53e621ff927e11ddf Mon Sep 17 00:00:00 2001
From: Alex Duan <417921451@qq.com>
Date: Mon, 15 Jan 2024 12:46:53 +0800
Subject: [PATCH 27/47] fix: insert child add dbname

---
 tests/army/frame/autogen.py  | 11 ++++-------
 tests/pytest/util/autogen.py |  2 +-
 2 files changed, 5 insertions(+), 8 deletions(-)

diff --git a/tests/army/frame/autogen.py b/tests/army/frame/autogen.py
index bb9ca163d7..1e041f633d 100644
--- a/tests/army/frame/autogen.py
+++ b/tests/army/frame/autogen.py
@@ -114,7 +114,6 @@ class AutoGen:
     def create_db(self, dbname, vgroups = 2, replica = 1):
         self.dbname  = dbname
         tdSql.execute(f'create database {dbname} vgroups {vgroups} replica {replica}')
-        tdSql.execute(f'use {dbname}')
         
     # create table or stable
     def create_stable(self, stbname, tag_cnt, column_cnt, binary_len, nchar_len):
@@ -124,7 +123,7 @@ class AutoGen:
         self.mtags, tags = self.gen_columns_sql("t", tag_cnt, binary_len, nchar_len)
         self.mcols, cols = self.gen_columns_sql("c", column_cnt - 1, binary_len, nchar_len)
 
-        sql = f"create table {stbname} (ts timestamp, {cols}) tags({tags})"
+        sql = f"create table {self.dbname}.{stbname} (ts timestamp, {cols}) tags({tags})"
         tdSql.execute(sql)
 
     # create child table 
@@ -133,7 +132,7 @@ class AutoGen:
         self.child_name = prename
         for i in range(cnt):
             tags_data = self.gen_data(i, self.mtags)
-            sql = f"create table {prename}{i} using {stbname} tags({tags_data})"
+            sql = f"create table {self.dbname}.{prename}{i} using {self.dbname}.{stbname} tags({tags_data})"
             tdSql.execute(sql)
 
         tdLog.info(f"create child tables {cnt} ok")
@@ -152,13 +151,13 @@ class AutoGen:
             ts += step
             values += f"({ts},{value}) "
             if batch_size == 1 or (i > 0 and i % batch_size == 0) :
-                sql = f"insert into {child_name} values {values}"
+                sql = f"insert into {self.dbname}.{child_name} values {values}"
                 tdSql.execute(sql)
                 values = ""
 
         # end batch
         if values != "":
-            sql = f"insert into {child_name} values {values}"
+            sql = f"insert into {self.dbname}.{child_name} values {values}"
             tdSql.execute(sql)
             tdLog.info(f" insert data i={i}")
             values = ""
@@ -180,5 +179,3 @@ class AutoGen:
             self.insert_data_child(name, cnt, self.batch_size, 0)
 
         tdLog.info(f" insert same timestamp ok, child table={self.child_cnt} insert rows={cnt}")         
-
-
diff --git a/tests/pytest/util/autogen.py b/tests/pytest/util/autogen.py
index 9c5378132f..4a09395f51 100644
--- a/tests/pytest/util/autogen.py
+++ b/tests/pytest/util/autogen.py
@@ -151,7 +151,7 @@ class AutoGen:
             ts += step
             values += f"({ts},{value}) "
             if batch_size == 1 or (i > 0 and i % batch_size == 0) :
-                sql = f"insert into {child_name} values {values}"
+                sql = f"insert into {self.dbname}.{child_name} values {values}"
                 tdSql.execute(sql)
                 values = ""
 

From 1191902d380d99cef345a7fa9b513c8430ed878b Mon Sep 17 00:00:00 2001
From: facetosea <25808407@qq.com>
Date: Mon, 15 Jan 2024 13:06:22 +0800
Subject: [PATCH 28/47] fix error code and delete unused code

---
 source/libs/executor/src/aggregateoperator.c |  4 +--
 source/libs/executor/src/executil.c          |  2 +-
 source/libs/nodes/src/nodesUtilFuncs.c       | 27 --------------------
 3 files changed, 3 insertions(+), 30 deletions(-)

diff --git a/source/libs/executor/src/aggregateoperator.c b/source/libs/executor/src/aggregateoperator.c
index 63156de881..a3adb02ab9 100644
--- a/source/libs/executor/src/aggregateoperator.c
+++ b/source/libs/executor/src/aggregateoperator.c
@@ -282,7 +282,7 @@ int32_t doAggregateImpl(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx) {
       }
 
       if ((&pCtx[k])->input.pData[0] == NULL) {
-        code = TSDB_CODE_PAR_NOT_SINGLE_GROUP;
+        code = TSDB_CODE_PAR_INTERNAL_ERROR;
         qError("%s aggregate function error happens, input data is NULL.", GET_TASKID(pOperator->pTaskInfo));
       } else {
         code = pCtx[k].fpSet.process(&pCtx[k]);
@@ -570,7 +570,7 @@ void applyAggFunctionOnPartialTuples(SExecTaskInfo* taskInfo, SqlFunctionCtx* pC
       int32_t code = TSDB_CODE_SUCCESS;
       if (functionNeedToExecute(&pCtx[k]) && pCtx[k].fpSet.process != NULL) {
         if ((&pCtx[k])->input.pData[0] == NULL) {
-          code = TSDB_CODE_PAR_NOT_SINGLE_GROUP;
+          code = TSDB_CODE_PAR_INTERNAL_ERROR;
           qError("%s apply functions error, input data is NULL.", GET_TASKID(taskInfo));
         } else {
           code = pCtx[k].fpSet.process(&pCtx[k]);
diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c
index 9ac53a512c..825d716926 100644
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@@ -1477,7 +1477,7 @@ void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) {
         SValueNode* pvn = (SValueNode*)p1;
         pExp->base.pParam[j].type = FUNC_PARAM_TYPE_VALUE;
         nodesValueNodeToVariant(pvn, &pExp->base.pParam[j].param);
-      } 
+      }
     }
   } else if (type == QUERY_NODE_OPERATOR) {
     pExp->pExpr->nodeType = QUERY_NODE_OPERATOR;
diff --git a/source/libs/nodes/src/nodesUtilFuncs.c b/source/libs/nodes/src/nodesUtilFuncs.c
index 446b29d7f2..dc16345916 100644
--- a/source/libs/nodes/src/nodesUtilFuncs.c
+++ b/source/libs/nodes/src/nodesUtilFuncs.c
@@ -2122,33 +2122,6 @@ static EDealRes collectFuncs(SNode* pNode, void* pContext) {
   return DEAL_RES_CONTINUE;
 }
 
-static EDealRes collectSelectFuncs(SNode* pNode, void* pContext) {
-  SCollectFuncsCxt* pCxt = (SCollectFuncsCxt*)pContext;
-  if (QUERY_NODE_FUNCTION == nodeType(pNode) && pCxt->classifier(((SFunctionNode*)pNode)->funcId)) {   
-    SFunctionNode* pFunc = (SFunctionNode*)pNode;
-    if (FUNCTION_TYPE_TBNAME == pFunc->funcType && pCxt->tableAlias) {
-      SValueNode* pVal = (SValueNode*)nodesListGetNode(pFunc->pParameterList, 0);
-      if (pVal && strcmp(pVal->literal, pCxt->tableAlias)) {
-        return DEAL_RES_CONTINUE;
-      }
-    }
-    SExprNode* pExpr = (SExprNode*)pNode;
-    bool bFound = false;
-    SNode* pn = NULL;
-    FOREACH(pn, pCxt->pFuncs) {
-      if (nodesEqualNode(pn, pNode)) {
-        bFound = true;
-        break;
-      }
-    }
-    if (!bFound) {
-      pCxt->errCode = nodesListStrictAppend(pCxt->pFuncs, nodesCloneNode(pNode));
-    }
-    return (TSDB_CODE_SUCCESS == pCxt->errCode ? DEAL_RES_IGNORE_CHILD : DEAL_RES_ERROR);
-  }
-  return DEAL_RES_CONTINUE;
-}
-
 static uint32_t funcNodeHash(const char* pKey, uint32_t len) {
   SExprNode* pExpr = *(SExprNode**)pKey;
   return MurmurHash3_32(pExpr->aliasName, strlen(pExpr->aliasName));

From 6eb79ea8eec27d05bbafbdad30b7d5b19da3ddbd Mon Sep 17 00:00:00 2001
From: Alex Duan <417921451@qq.com>
Date: Mon, 15 Jan 2024 13:56:33 +0800
Subject: [PATCH 29/47] fix: add user db

---
 tests/pytest/util/autogen.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/pytest/util/autogen.py b/tests/pytest/util/autogen.py
index 4a09395f51..72e64dc448 100644
--- a/tests/pytest/util/autogen.py
+++ b/tests/pytest/util/autogen.py
@@ -114,6 +114,7 @@ class AutoGen:
     def create_db(self, dbname, vgroups = 2, replica = 1):
         self.dbname  = dbname
         tdSql.execute(f'create database {dbname} vgroups {vgroups} replica {replica}')
+        tdSql.execute(f"use {dbname}")
         
     # create table or stable
     def create_stable(self, stbname, tag_cnt, column_cnt, binary_len, nchar_len):

From 318293edf182c21f5837b6571dc165c53b6aa9fe Mon Sep 17 00:00:00 2001
From: Alex Duan <417921451@qq.com>
Date: Mon, 15 Jan 2024 14:14:25 +0800
Subject: [PATCH 30/47] fix: countAlways return is 0

---
 tests/army/community/cluster/snapshot.py | 4 ++--
 tests/army/frame/caseBase.py             | 5 +++--
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/tests/army/community/cluster/snapshot.py b/tests/army/community/cluster/snapshot.py
index 8543101300..8d15530061 100644
--- a/tests/army/community/cluster/snapshot.py
+++ b/tests/army/community/cluster/snapshot.py
@@ -72,8 +72,8 @@ class TDTestCase(TBase):
 
         # check count always return value
         sql = f"select count(*) from {self.db}.ta"
-        tdSql.waitedQuery(sql, 0, 2)        
-
+        tdSql.query()
+        tdSql.checkRows(0) # countAlwaysReturnValue is false
 
     # run
     def run(self):
diff --git a/tests/army/frame/caseBase.py b/tests/army/frame/caseBase.py
index ca5539f75b..aca2b524da 100644
--- a/tests/army/frame/caseBase.py
+++ b/tests/army/frame/caseBase.py
@@ -132,8 +132,9 @@ class TBase:
         tdSql.checkAgg(sql, self.childtable_count)
 
         # check step
-        sql = f"select count(*) from (select diff(ts) as dif from {self.stb} partition by tbname) where dif != {self.timestamp_step}"
-        tdSql.checkAgg(sql, 0)
+        sql = f"select * from (select diff(ts) as dif from {self.stb} partition by tbname) where dif != {self.timestamp_step}"
+        tdSql.query(sql)
+        tdSql.checkRows(0)
 
     # save agg result
     def snapshotAgg(self):        

From b44f3c10e6b62fd5dda659237cd0a8f1d1e33292 Mon Sep 17 00:00:00 2001
From: Alex Duan <417921451@qq.com>
Date: Mon, 15 Jan 2024 14:20:36 +0800
Subject: [PATCH 31/47] fix: correct argment sql

---
 tests/army/community/cluster/snapshot.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/army/community/cluster/snapshot.py b/tests/army/community/cluster/snapshot.py
index 8d15530061..5b5457be75 100644
--- a/tests/army/community/cluster/snapshot.py
+++ b/tests/army/community/cluster/snapshot.py
@@ -72,7 +72,7 @@ class TDTestCase(TBase):
 
         # check count always return value
         sql = f"select count(*) from {self.db}.ta"
-        tdSql.query()
+        tdSql.query(sql)
         tdSql.checkRows(0) # countAlwaysReturnValue is false
 
     # run

From 143e6a13af81d98d92011985f3753323650d4c4a Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Mon, 15 Jan 2024 14:37:24 +0800
Subject: [PATCH 32/47] fix(stream): fix deadlock in pause.

---
 include/libs/stream/tstream.h              | 1 +
 source/dnode/vnode/src/tqCommon/tqCommon.c | 4 ++--
 source/libs/stream/src/streamExec.c        | 8 +++++++-
 source/libs/stream/src/streamQueue.c       | 1 -
 source/libs/stream/src/streamTask.c        | 4 ++++
 5 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/include/libs/stream/tstream.h b/include/libs/stream/tstream.h
index ba5219cf20..32d8ce72f0 100644
--- a/include/libs/stream/tstream.h
+++ b/include/libs/stream/tstream.h
@@ -837,6 +837,7 @@ int32_t streamTaskReloadState(SStreamTask* pTask);
 void    streamTaskCloseAllUpstreamInput(SStreamTask* pTask, int32_t taskId);
 void    streamTaskOpenAllUpstreamInput(SStreamTask* pTask);
 int32_t streamTaskSetDb(SStreamMeta* pMeta, void* pTask, char* key);
+bool    streamTaskIsSinkTask(const SStreamTask* pTask);
 
 void streamTaskStatusInit(STaskStatusEntry* pEntry, const SStreamTask* pTask);
 void streamTaskStatusCopy(STaskStatusEntry* pDst, const STaskStatusEntry* pSrc);
diff --git a/source/dnode/vnode/src/tqCommon/tqCommon.c b/source/dnode/vnode/src/tqCommon/tqCommon.c
index 358af0b083..eb5efe07f2 100644
--- a/source/dnode/vnode/src/tqCommon/tqCommon.c
+++ b/source/dnode/vnode/src/tqCommon/tqCommon.c
@@ -813,8 +813,8 @@ int32_t tqStreamTaskProcessRunReq(SStreamMeta* pMeta, SRpcMsg* pMsg, bool isLead
   if (pTask != NULL) {  // even in halt status, the data in inputQ must be processed
     char* p = NULL;
     if (streamTaskReadyToRun(pTask, &p)) {
-      tqDebug("vgId:%d s-task:%s start to process block from inputQ, next checked ver:%" PRId64, vgId, pTask->id.idStr,
-              pTask->chkInfo.nextProcessVer);
+      tqDebug("vgId:%d s-task:%s status:%s start to process block from inputQ, next checked ver:%" PRId64, vgId, pTask->id.idStr,
+              p, pTask->chkInfo.nextProcessVer);
       streamExecTask(pTask);
     } else {
       int8_t status = streamTaskSetSchedStatusInactive(pTask);
diff --git a/source/libs/stream/src/streamExec.c b/source/libs/stream/src/streamExec.c
index c69fe2a79c..1eb66a82ab 100644
--- a/source/libs/stream/src/streamExec.c
+++ b/source/libs/stream/src/streamExec.c
@@ -713,7 +713,13 @@ bool streamTaskReadyToRun(const SStreamTask* pTask, char** pStatus) {
     *pStatus = pState->name;
   }
 
-  return (st == TASK_STATUS__READY || st == TASK_STATUS__SCAN_HISTORY || st == TASK_STATUS__CK);
+  // pause & halt will still run for sink tasks.
+  if (streamTaskIsSinkTask(pTask)) {
+    return (st == TASK_STATUS__READY || st == TASK_STATUS__SCAN_HISTORY || st == TASK_STATUS__CK ||
+            st == TASK_STATUS__PAUSE || st == TASK_STATUS__HALT);
+  } else {
+    return (st == TASK_STATUS__READY || st == TASK_STATUS__SCAN_HISTORY || st == TASK_STATUS__CK);
+  }
 }
 
 static void doStreamExecTaskHelper(void* param, void* tmrId) {
diff --git a/source/libs/stream/src/streamQueue.c b/source/libs/stream/src/streamQueue.c
index 90823cd937..78929c365e 100644
--- a/source/libs/stream/src/streamQueue.c
+++ b/source/libs/stream/src/streamQueue.c
@@ -154,7 +154,6 @@ int32_t streamTaskGetDataFromInputQ(SStreamTask* pTask, SStreamQueueItem** pInpu
   *numOfBlocks = 0;
   *blockSize = 0;
 
-  // todo remove it
   // no available token in bucket for sink task, let's wait for a little bit
   if (taskLevel == TASK_LEVEL__SINK && (!streamTaskExtractAvailableToken(pTask->outputInfo.pTokenBucket, pTask->id.idStr))) {
     stDebug("s-task:%s no available token in bucket for sink data, wait for 10ms", id);
diff --git a/source/libs/stream/src/streamTask.c b/source/libs/stream/src/streamTask.c
index 881f10502c..9e981a79c7 100644
--- a/source/libs/stream/src/streamTask.c
+++ b/source/libs/stream/src/streamTask.c
@@ -848,3 +848,7 @@ void streamTaskResume(SStreamTask* pTask) {
     stDebug("s-task:%s status:%s not in pause/halt status, no need to resume", pTask->id.idStr, prevState.name);
   }
 }
+
+bool streamTaskIsSinkTask(const SStreamTask* pTask) {
+  return pTask->info.taskLevel == TASK_LEVEL__SINK;
+}

From cb2ab749b5fb6bb1daf41546c89cdeea921191d9 Mon Sep 17 00:00:00 2001
From: fullhonest <fullhon@sohu.com>
Date: Sun, 14 Jan 2024 13:44:40 +0800
Subject: [PATCH 33/47] Fix TD-27003: use last row scan when select last_row,
 last

---
 include/libs/executor/storageapi.h            |   3 +-
 include/libs/nodes/nodes.h                    |   2 +
 include/libs/nodes/plannodes.h                |   2 +
 source/dnode/vnode/inc/vnode.h                |   3 +-
 source/dnode/vnode/src/tsdb/tsdbCache.c       |  70 +-
 source/dnode/vnode/src/tsdb/tsdbCacheRead.c   |  68 +-
 source/dnode/vnode/src/tsdb/tsdbReadUtil.h    |   1 +
 source/libs/executor/inc/executil.h           |   1 +
 source/libs/executor/src/cachescanoperator.c  |  15 +-
 source/libs/executor/src/executil.c           |   1 -
 source/libs/executor/src/executor.c           |   4 +
 source/libs/function/src/builtinsimpl.c       |   2 +-
 source/libs/nodes/src/nodesCloneFuncs.c       |  24 +
 source/libs/nodes/src/nodesCodeFuncs.c        |  24 +
 source/libs/nodes/src/nodesEqualFuncs.c       |  18 +
 source/libs/nodes/src/nodesMsgFuncs.c         | 100 ++-
 source/libs/nodes/src/nodesUtilFuncs.c        |   4 +
 source/libs/planner/src/planOptimizer.c       | 188 ++++-
 source/libs/planner/src/planPhysiCreater.c    |  29 +-
 tests/parallel_test/cases.task                |   5 +
 tests/script/tsim/query/cache_last.sim        |   2 +-
 .../system-test/2-query/last_and_last_row.py  | 660 ++++++++++++++++++
 tests/system-test/2-query/last_cache_scan.py  |   2 +-
 23 files changed, 1172 insertions(+), 56 deletions(-)
 create mode 100644 tests/system-test/2-query/last_and_last_row.py

diff --git a/include/libs/executor/storageapi.h b/include/libs/executor/storageapi.h
index 1dbc8f2f76..669340f9e5 100644
--- a/include/libs/executor/storageapi.h
+++ b/include/libs/executor/storageapi.h
@@ -189,7 +189,8 @@ typedef struct TsdReader {
 
 typedef struct SStoreCacheReader {
   int32_t  (*openReader)(void *pVnode, int32_t type, void *pTableIdList, int32_t numOfTables, int32_t numOfCols,
-                         SArray *pCidList, int32_t *pSlotIds, uint64_t suid, void **pReader, const char *idstr);
+                         SArray *pCidList, int32_t *pSlotIds, uint64_t suid, void **pReader, const char *idstr,
+                         SArray *pFuncTypeList);
   void    *(*closeReader)(void *pReader);
   int32_t  (*retrieveRows)(void *pReader, SSDataBlock *pResBlock, const int32_t *slotIds, const int32_t *dstSlotIds,
                            SArray *pTableUidList);
diff --git a/include/libs/nodes/nodes.h b/include/libs/nodes/nodes.h
index 7fbdbfb211..891084419b 100644
--- a/include/libs/nodes/nodes.h
+++ b/include/libs/nodes/nodes.h
@@ -149,6 +149,8 @@ void nodesRewriteExprPostOrder(SNode** pNode, FNodeRewriter rewriter, void* pCon
 void nodesRewriteExprsPostOrder(SNodeList* pList, FNodeRewriter rewriter, void* pContext);
 
 bool nodesEqualNode(const SNode* a, const SNode* b);
+bool nodeListNodeEqual(const SNodeList* a, const SNode* b);
+
 bool nodesMatchNode(const SNode* pSub, const SNode* pNode);
 
 SNode*     nodesCloneNode(const SNode* pNode);
diff --git a/include/libs/nodes/plannodes.h b/include/libs/nodes/plannodes.h
index f0383e8168..6cb83ebb51 100644
--- a/include/libs/nodes/plannodes.h
+++ b/include/libs/nodes/plannodes.h
@@ -120,6 +120,7 @@ typedef struct SScanLogicNode {
   bool          onlyMetaCtbIdx; // for tag scan with no tbname
   bool          filesetDelimited; // returned blocks delimited by fileset
   bool          isCountByTag;  // true if selectstmt hasCountFunc & part by tag/tbname
+  SArray*       pFuncTypes; // for last, last_row
 } SScanLogicNode;
 
 typedef struct SJoinLogicNode {
@@ -401,6 +402,7 @@ typedef struct SLastRowScanPhysiNode {
   bool           groupSort;
   bool           ignoreNull;
   SNodeList*     pTargets;
+  SArray*        pFuncTypes;
 } SLastRowScanPhysiNode;
 
 typedef SLastRowScanPhysiNode STableCountScanPhysiNode;
diff --git a/source/dnode/vnode/inc/vnode.h b/source/dnode/vnode/inc/vnode.h
index 9a4e2edf8d..97cf0ffebc 100644
--- a/source/dnode/vnode/inc/vnode.h
+++ b/source/dnode/vnode/inc/vnode.h
@@ -175,7 +175,8 @@ void         tsdbReaderSetNotifyCb(STsdbReader* pReader, TsdReaderNotifyCbFn not
 
 int32_t tsdbReuseCacherowsReader(void *pReader, void *pTableIdList, int32_t numOfTables);
 int32_t tsdbCacherowsReaderOpen(void *pVnode, int32_t type, void *pTableIdList, int32_t numOfTables, int32_t numOfCols,
-                                SArray *pCidList, int32_t *pSlotIds, uint64_t suid, void **pReader, const char *idstr);
+                                SArray *pCidList, int32_t *pSlotIds, uint64_t suid, void **pReader, const char *idstr,
+                                SArray* pFuncTypeList);
 int32_t tsdbRetrieveCacheRows(void *pReader, SSDataBlock *pResBlock, const int32_t *slotIds, const int32_t *dstSlotIds,
                               SArray *pTableUids);
 void   *tsdbCacherowsReaderClose(void *pReader);
diff --git a/source/dnode/vnode/src/tsdb/tsdbCache.c b/source/dnode/vnode/src/tsdb/tsdbCache.c
index 9b29329cf3..d86219542f 100644
--- a/source/dnode/vnode/src/tsdb/tsdbCache.c
+++ b/source/dnode/vnode/src/tsdb/tsdbCache.c
@@ -13,6 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 #include "cos.h"
+#include "functionMgt.h"
 #include "tsdb.h"
 #include "tsdbDataFileRW.h"
 #include "tsdbReadUtil.h"
@@ -894,19 +895,56 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr
   }
 
   int      num_keys = TARRAY_SIZE(remainCols);
-  int16_t *aCols = taosMemoryMalloc(num_keys * sizeof(int16_t));
   int16_t *slotIds = taosMemoryMalloc(num_keys * sizeof(int16_t));
 
+  int16_t *lastColIds = taosMemoryMalloc(num_keys * sizeof(int16_t));
+  int16_t *lastSlotIds = taosMemoryMalloc(num_keys * sizeof(int16_t));
+  int16_t *lastrowColIds = taosMemoryMalloc(num_keys * sizeof(int16_t));
+  int16_t *lastrowSlotIds = taosMemoryMalloc(num_keys * sizeof(int16_t));
+  SArray* lastTmpColArray = NULL;
+  SArray* lastTmpIndexArray = NULL;
+  SArray* lastrowTmpColArray = NULL;
+  SArray* lastrowTmpIndexArray = NULL;
+
+  int lastIndex = 0;
+  int lastrowIndex = 0;
+
   for (int i = 0; i < num_keys; ++i) {
     SIdxKey *idxKey = taosArrayGet(remainCols, i);
-    aCols[i] = idxKey->key.cid;
     slotIds[i] = pr->pSlotIds[idxKey->idx];
+    if (idxKey->key.ltype == CACHESCAN_RETRIEVE_LAST >> 3) {
+      if(NULL == lastTmpIndexArray) {
+        lastTmpIndexArray = taosArrayInit(num_keys, sizeof(int32_t));
+      }
+      taosArrayPush(lastTmpIndexArray, &(i));
+      lastColIds[lastIndex] = idxKey->key.cid;
+      lastSlotIds[lastIndex] = pr->pSlotIds[idxKey->idx];
+      lastIndex++;
+    } else {
+      if(NULL == lastrowTmpIndexArray) {
+        lastrowTmpIndexArray = taosArrayInit(num_keys, sizeof(int32_t));
+      }
+      taosArrayPush(lastrowTmpIndexArray, &(i));
+      lastrowColIds[lastrowIndex] = idxKey->key.cid;
+      lastrowSlotIds[lastrowIndex] = pr->pSlotIds[idxKey->idx];
+      lastrowIndex++;
+    }
   }
 
-  if (ltype) {
-    mergeLastCid(uid, pTsdb, &pTmpColArray, pr, aCols, num_keys, slotIds);
-  } else {
-    mergeLastRowCid(uid, pTsdb, &pTmpColArray, pr, aCols, num_keys, slotIds);
+  pTmpColArray = taosArrayInit(lastIndex + lastrowIndex, sizeof(SLastCol));
+
+  if(lastTmpIndexArray != NULL) {
+    mergeLastCid(uid, pTsdb, &lastTmpColArray, pr, lastColIds, lastIndex, lastSlotIds);
+    for(int i = 0; i < taosArrayGetSize(lastTmpColArray); i++) {
+      taosArrayInsert(pTmpColArray, *(int32_t*)taosArrayGet(lastTmpIndexArray, i), taosArrayGet(lastTmpColArray, i));
+    }
+  }
+
+  if(lastrowTmpIndexArray != NULL) {
+    mergeLastCid(uid, pTsdb, &lastrowTmpColArray, pr, lastrowColIds, lastrowIndex, lastrowSlotIds);
+    for(int i = 0; i < taosArrayGetSize(lastrowTmpColArray); i++) {
+      taosArrayInsert(pTmpColArray, *(int32_t*)taosArrayGet(lastrowTmpIndexArray, i), taosArrayGet(lastrowTmpColArray, i));
+    }
   }
 
   SLRUCache *pCache = pTsdb->lruCache;
@@ -965,9 +1003,18 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr
     rocksMayWrite(pTsdb, false, true, false);
   }
 
+  taosArrayDestroy(lastrowTmpIndexArray);
+  taosArrayDestroy(lastrowTmpColArray);
+  taosArrayDestroy(lastTmpIndexArray);
+  taosArrayDestroy(lastTmpColArray);
+
+  taosMemoryFree(lastColIds);
+  taosMemoryFree(lastSlotIds);
+  taosMemoryFree(lastrowColIds);
+  taosMemoryFree(lastrowSlotIds);
+
   taosArrayDestroy(pTmpColArray);
 
-  taosMemoryFree(aCols);
   taosMemoryFree(slotIds);
 
   return code;
@@ -1057,6 +1104,15 @@ int32_t tsdbCacheGetBatch(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArray, SCache
     int16_t cid = ((int16_t *)TARRAY_DATA(pCidList))[i];
 
     SLastKey *key = &(SLastKey){.ltype = ltype, .uid = uid, .cid = cid};
+    // for select last_row, last case
+    int32_t funcType = FUNCTION_TYPE_CACHE_LAST;
+    if (pr->pFuncTypeList != NULL && taosArrayGetSize(pr->pFuncTypeList) > i) {
+      funcType = ((int32_t *)TARRAY_DATA(pr->pFuncTypeList))[i];
+    }
+    if (((pr->type & CACHESCAN_RETRIEVE_LAST) == CACHESCAN_RETRIEVE_LAST) && FUNCTION_TYPE_CACHE_LAST_ROW == funcType) {
+      int8_t tempType = CACHESCAN_RETRIEVE_LAST_ROW | (pr->type ^ CACHESCAN_RETRIEVE_LAST);
+      key->ltype = (tempType & CACHESCAN_RETRIEVE_LAST) >> 3;
+    }
 
     LRUHandle *h = taosLRUCacheLookup(pCache, key, ROCKS_KEY_LEN);
     if (h) {
diff --git a/source/dnode/vnode/src/tsdb/tsdbCacheRead.c b/source/dnode/vnode/src/tsdb/tsdbCacheRead.c
index f668ea5f72..3df2bb20d0 100644
--- a/source/dnode/vnode/src/tsdb/tsdbCacheRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbCacheRead.c
@@ -13,6 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "functionMgt.h"
 #include "taoserror.h"
 #include "tarray.h"
 #include "tcommon.h"
@@ -33,31 +34,69 @@ static void setFirstLastResColToNull(SColumnInfoData* pCol, int32_t row) {
   taosMemoryFree(buf);
 }
 
+static void saveOneRowForLastRaw(SLastCol* pColVal, SCacheRowsReader* pReader, const int32_t slotId,
+                                 SColumnInfoData* pColInfoData, int32_t numOfRows) {
+  SColVal*  pVal = &pColVal->colVal;
+
+  // allNullRow = false;
+  if (IS_VAR_DATA_TYPE(pColVal->colVal.type)) {
+    if (!COL_VAL_IS_VALUE(&pColVal->colVal)) {
+      colDataSetNULL(pColInfoData, numOfRows);
+    } else {
+      varDataSetLen(pReader->transferBuf[slotId], pVal->value.nData);
+
+      memcpy(varDataVal(pReader->transferBuf[slotId]), pVal->value.pData, pVal->value.nData);
+      colDataSetVal(pColInfoData, numOfRows, pReader->transferBuf[slotId], false);
+    }
+  } else {
+    colDataSetVal(pColInfoData, numOfRows, (const char*)&pVal->value.val, !COL_VAL_IS_VALUE(pVal));
+  }
+  return;
+}
+
 static int32_t saveOneRow(SArray* pRow, SSDataBlock* pBlock, SCacheRowsReader* pReader, const int32_t* slotIds,
                           const int32_t* dstSlotIds, void** pRes, const char* idStr) {
   int32_t numOfRows = pBlock->info.rows;
   // bool    allNullRow = true;
 
   if (HASTYPE(pReader->type, CACHESCAN_RETRIEVE_LAST)) {
+
     uint64_t ts = TSKEY_MIN;
     SFirstLastRes* p = NULL;
     col_id_t colId = -1;
+
+    SArray* funcTypeBlockArray = taosArrayInit(pReader->numOfCols, sizeof(int32_t));
     for (int32_t i = 0; i < pReader->numOfCols; ++i) {
       SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, dstSlotIds[i]);
+      int32_t funcType = FUNCTION_TYPE_CACHE_LAST;
+      if (pReader->pFuncTypeList != NULL && taosArrayGetSize(pReader->pFuncTypeList) > i) {
+        funcType = *(int32_t*)taosArrayGet(pReader->pFuncTypeList, i);
+      }
+      taosArrayInsert(funcTypeBlockArray, dstSlotIds[i], taosArrayGet(pReader->pFuncTypeList, i));
+
       if (slotIds[i] == -1) {
+        if (FUNCTION_TYPE_CACHE_LAST_ROW == funcType) {
+          colDataSetNULL(pColInfoData, numOfRows);
+          continue;
+        }
         setFirstLastResColToNull(pColInfoData, numOfRows);
         continue;
       }
       int32_t   slotId = slotIds[i];
       SLastCol* pColVal = (SLastCol*)taosArrayGet(pRow, i);
       colId = pColVal->colVal.cid;
+
+      if (FUNCTION_TYPE_CACHE_LAST_ROW == funcType) {
+        saveOneRowForLastRaw(pColVal, pReader, slotId, pColInfoData, numOfRows);
+        continue;
+      }
+
       p = (SFirstLastRes*)varDataVal(pRes[i]);
 
       p->ts = pColVal->ts;
       ts = p->ts;
       p->isNull = !COL_VAL_IS_VALUE(&pColVal->colVal);
       // allNullRow = p->isNull & allNullRow;
-
       if (!p->isNull) {
         if (IS_VAR_DATA_TYPE(pColVal->colVal.type)) {
           varDataSetLen(p->buf, pColVal->colVal.value.nData);
@@ -77,6 +116,13 @@ static int32_t saveOneRow(SArray* pRow, SSDataBlock* pBlock, SCacheRowsReader* p
     }
     for (int32_t idx = 0; idx < taosArrayGetSize(pBlock->pDataBlock); ++idx) {
       SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, idx);
+      if (idx < funcTypeBlockArray->size) {
+			  int32_t funcType = *(int32_t*)taosArrayGet(funcTypeBlockArray, idx);
+        if (FUNCTION_TYPE_CACHE_LAST_ROW == funcType) {
+          continue;
+        }
+      }
+
       if (pCol->info.colId == PRIMARYKEY_TIMESTAMP_COL_ID && pCol->info.type == TSDB_DATA_TYPE_TIMESTAMP) {
         if (ts == TSKEY_MIN) {
           colDataSetNULL(pCol, numOfRows);
@@ -95,6 +141,7 @@ static int32_t saveOneRow(SArray* pRow, SSDataBlock* pBlock, SCacheRowsReader* p
 
     // pBlock->info.rows += allNullRow ? 0 : 1;
     ++pBlock->info.rows;
+    taosArrayDestroy(funcTypeBlockArray);
   } else if (HASTYPE(pReader->type, CACHESCAN_RETRIEVE_LAST_ROW)) {
     for (int32_t i = 0; i < pReader->numOfCols; ++i) {
       SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, dstSlotIds[i]);
@@ -105,21 +152,8 @@ static int32_t saveOneRow(SArray* pRow, SSDataBlock* pBlock, SCacheRowsReader* p
         continue;
       }
       SLastCol* pColVal = (SLastCol*)taosArrayGet(pRow, i);
-      SColVal*  pVal = &pColVal->colVal;
 
-      // allNullRow = false;
-      if (IS_VAR_DATA_TYPE(pColVal->colVal.type)) {
-        if (!COL_VAL_IS_VALUE(&pColVal->colVal)) {
-          colDataSetNULL(pColInfoData, numOfRows);
-        } else {
-          varDataSetLen(pReader->transferBuf[slotId], pVal->value.nData);
-
-          memcpy(varDataVal(pReader->transferBuf[slotId]), pVal->value.pData, pVal->value.nData);
-          colDataSetVal(pColInfoData, numOfRows, pReader->transferBuf[slotId], false);
-        }
-      } else {
-        colDataSetVal(pColInfoData, numOfRows, (const char*)&pVal->value.val, !COL_VAL_IS_VALUE(pVal));
-      }
+      saveOneRowForLastRaw(pColVal, pReader, slotId, pColInfoData, numOfRows);
     }
 
     // pBlock->info.rows += allNullRow ? 0 : 1;
@@ -175,7 +209,8 @@ int32_t tsdbReuseCacherowsReader(void* reader, void* pTableIdList, int32_t numOf
 }
 
 int32_t tsdbCacherowsReaderOpen(void* pVnode, int32_t type, void* pTableIdList, int32_t numOfTables, int32_t numOfCols,
-                                SArray* pCidList, int32_t* pSlotIds, uint64_t suid, void** pReader, const char* idstr) {
+                                SArray* pCidList, int32_t* pSlotIds, uint64_t suid, void** pReader, const char* idstr,
+                                SArray* pFuncTypeList) {
   *pReader = NULL;
   SCacheRowsReader* p = taosMemoryCalloc(1, sizeof(SCacheRowsReader));
   if (p == NULL) {
@@ -190,6 +225,7 @@ int32_t tsdbCacherowsReaderOpen(void* pVnode, int32_t type, void* pTableIdList,
   p->numOfCols = numOfCols;
   p->pCidList = pCidList;
   p->pSlotIds = pSlotIds;
+  p->pFuncTypeList = pFuncTypeList;
 
   if (numOfTables == 0) {
     *pReader = p;
diff --git a/source/dnode/vnode/src/tsdb/tsdbReadUtil.h b/source/dnode/vnode/src/tsdb/tsdbReadUtil.h
index 16ee90823b..c27e9ebe04 100644
--- a/source/dnode/vnode/src/tsdb/tsdbReadUtil.h
+++ b/source/dnode/vnode/src/tsdb/tsdbReadUtil.h
@@ -348,6 +348,7 @@ typedef struct SCacheRowsReader {
   STsdbReadSnap*          pReadSnap;
   char*                   idstr;
   int64_t                 lastTs;
+  SArray*                 pFuncTypeList;
 } SCacheRowsReader;
 
 int32_t tsdbCacheGetBatch(STsdb* pTsdb, tb_uid_t uid, SArray* pLastArray, SCacheRowsReader* pr, int8_t ltype);
diff --git a/source/libs/executor/inc/executil.h b/source/libs/executor/inc/executil.h
index 640ed2f2f9..92de5c4364 100644
--- a/source/libs/executor/inc/executil.h
+++ b/source/libs/executor/inc/executil.h
@@ -82,6 +82,7 @@ typedef struct SColMatchItem {
   int32_t   dstSlotId;
   bool      needOutput;
   SDataType dataType;
+  int32_t   funcType;
 } SColMatchItem;
 
 typedef struct SColMatchInfo {
diff --git a/source/libs/executor/src/cachescanoperator.c b/source/libs/executor/src/cachescanoperator.c
index 9d4c20493a..63fcfba7c1 100644
--- a/source/libs/executor/src/cachescanoperator.c
+++ b/source/libs/executor/src/cachescanoperator.c
@@ -21,6 +21,7 @@
 #include "tmsg.h"
 
 #include "executorInt.h"
+#include "functionMgt.h"
 #include "operator.h"
 #include "querytask.h"
 #include "tcompare.h"
@@ -44,6 +45,7 @@ typedef struct SCacheRowsScanInfo {
   SArray*         pCidList;
   int32_t         indexOfBufferedRes;
   STableListInfo* pTableList;
+  SArray*         pFuncTypeList;
 } SCacheRowsScanInfo;
 
 static SSDataBlock* doScanCache(SOperatorInfo* pOperator);
@@ -105,9 +107,15 @@ SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SRe
   }
 
   SArray* pCidList = taosArrayInit(numOfCols, sizeof(int16_t));
+  pInfo->pFuncTypeList = taosArrayInit(taosArrayGetSize(pScanNode->pFuncTypes), sizeof(int32_t));
+  taosArrayAddAll(pInfo->pFuncTypeList, pScanNode->pFuncTypes);
+
   for (int i = 0; i < TARRAY_SIZE(pInfo->matchInfo.pList); ++i) {
     SColMatchItem* pColInfo = taosArrayGet(pInfo->matchInfo.pList, i);
     taosArrayPush(pCidList, &pColInfo->colId);
+    if (pInfo->pFuncTypeList != NULL && taosArrayGetSize(pInfo->pFuncTypeList) > i) {
+      pColInfo->funcType = *(int32_t*)taosArrayGet(pInfo->pFuncTypeList, i);
+    }
   }
   pInfo->pCidList = pCidList;
 
@@ -132,7 +140,7 @@ SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SRe
     uint64_t suid = tableListGetSuid(pTableListInfo);
     code = pInfo->readHandle.api.cacheFn.openReader(pInfo->readHandle.vnode, pInfo->retrieveType, pList, totalTables,
                                                     taosArrayGetSize(pInfo->matchInfo.pList), pCidList, pInfo->pSlotIds,
-                                                    suid, &pInfo->pLastrowReader, pTaskInfo->id.str);
+                                                    suid, &pInfo->pLastrowReader, pTaskInfo->id.str, pScanNode->pFuncTypes);
     if (code != TSDB_CODE_SUCCESS) {
       goto _error;
     }
@@ -274,7 +282,7 @@ SSDataBlock* doScanCache(SOperatorInfo* pOperator) {
       if (NULL == pInfo->pLastrowReader) {
         code = pInfo->readHandle.api.cacheFn.openReader(pInfo->readHandle.vnode, pInfo->retrieveType, pList, num,
                                        taosArrayGetSize(pInfo->matchInfo.pList), pInfo->pCidList, pInfo->pSlotIds, suid, &pInfo->pLastrowReader,
-                                       pTaskInfo->id.str);
+                                       pTaskInfo->id.str, pInfo->pFuncTypeList);
         if (code != TSDB_CODE_SUCCESS) {
           pInfo->currentGroupIndex += 1;
           taosArrayClear(pInfo->pUidList);
@@ -333,6 +341,7 @@ void destroyCacheScanOperator(void* param) {
   taosMemoryFree(pInfo->pSlotIds);
   taosMemoryFree(pInfo->pDstSlotIds);
   taosArrayDestroy(pInfo->pCidList);
+  taosArrayDestroy(pInfo->pFuncTypeList);
   taosArrayDestroy(pInfo->pUidList);
   taosArrayDestroy(pInfo->matchInfo.pList);
   tableListDestroy(pInfo->pTableList);
@@ -405,6 +414,8 @@ int32_t removeRedundantTsCol(SLastRowScanPhysiNode* pScanNode, SColMatchInfo* pC
     SSlotDescNode* pDesc = (SSlotDescNode*)nodesListGetNode(pList, slotId);
     if (pDesc->dataType.type != TSDB_DATA_TYPE_TIMESTAMP) {
       taosArrayPush(pMatchInfo, pColInfo);
+    } else if (FUNCTION_TYPE_CACHE_LAST_ROW == pColInfo->funcType){
+      taosArrayPush(pMatchInfo, pColInfo);
     }
   }
 
diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c
index efab09f02b..1da7818c3c 100644
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@@ -1343,7 +1343,6 @@ int32_t extractColMatchInfo(SNodeList* pNodeList, SDataBlockDescNode* pOutputNod
       c.colId = pColNode->colId;
       c.srcSlotId = pColNode->slotId;
       c.dstSlotId = pNode->slotId;
-      c.dataType = pColNode->node.resType;
       taosArrayPush(pList, &c);
     }
   }
diff --git a/source/libs/executor/src/executor.c b/source/libs/executor/src/executor.c
index d27daad550..eb84cb0639 100644
--- a/source/libs/executor/src/executor.c
+++ b/source/libs/executor/src/executor.c
@@ -621,6 +621,10 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bo
   } else {
     pRes = pTaskInfo->pRoot->fpSet.getNextFn(pTaskInfo->pRoot);
   }
+
+  if(pRes == NULL) {
+    st = taosGetTimestampUs();
+  }
   
   int32_t rowsThreshold = pTaskInfo->pSubplan->rowsThreshold;
   if (!pTaskInfo->pSubplan->dynamicRowThreshold || 4096 <= pTaskInfo->pSubplan->rowsThreshold) {
diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c
index 390190e8db..daf409070a 100644
--- a/source/libs/function/src/builtinsimpl.c
+++ b/source/libs/function/src/builtinsimpl.c
@@ -2125,7 +2125,7 @@ bool getGroupKeyFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
 }
 
 static FORCE_INLINE TSKEY getRowPTs(SColumnInfoData* pTsColInfo, int32_t rowIndex) {
-  if (pTsColInfo == NULL) {
+  if (pTsColInfo == NULL || pTsColInfo->pData == NULL) {
     return 0;
   }
 
diff --git a/source/libs/nodes/src/nodesCloneFuncs.c b/source/libs/nodes/src/nodesCloneFuncs.c
index c68fd81d22..c090cb4b63 100644
--- a/source/libs/nodes/src/nodesCloneFuncs.c
+++ b/source/libs/nodes/src/nodesCloneFuncs.c
@@ -241,6 +241,29 @@ static SVgroupsInfo* vgroupsInfoClone(const SVgroupsInfo* pSrc) {
   return pDst;
 }
 
+static SArray* functParamClone(const SArray* pSrc) {
+  int32_t       len = sizeof(SArray) + pSrc->capacity * pSrc->elemSize;
+
+  SArray* pDst = taosArrayInit(pSrc->capacity, pSrc->elemSize);
+  if (NULL == pDst) {
+    return NULL;
+  }
+  for (int i = 0; i < TARRAY_SIZE(pSrc); ++i) {
+    SFunctParam* pFunctParam = taosArrayGet(pSrc, i);
+    SFunctParam* pNewFunctParam = (SFunctParam*)taosArrayPush(pDst, pFunctParam);
+
+    if (NULL == pNewFunctParam) {
+      return NULL;
+    }
+    pNewFunctParam->type = pFunctParam->type;
+    pNewFunctParam->pCol = taosMemoryCalloc(1, sizeof(SColumn));
+    memcpy(pNewFunctParam->pCol, pFunctParam->pCol, sizeof(SColumn));
+  }
+
+  return pDst;
+}
+
+
 static int32_t realTableNodeCopy(const SRealTableNode* pSrc, SRealTableNode* pDst) {
   COPY_BASE_OBJECT_FIELD(table, tableNodeCopy);
   CLONE_OBJECT_FIELD(pMeta, tableMetaClone);
@@ -425,6 +448,7 @@ static int32_t logicScanCopy(const SScanLogicNode* pSrc, SScanLogicNode* pDst) {
   COPY_SCALAR_FIELD(onlyMetaCtbIdx);
   COPY_SCALAR_FIELD(filesetDelimited);
   COPY_SCALAR_FIELD(isCountByTag);
+  CLONE_OBJECT_FIELD(pFuncTypes, functParamClone);
   return TSDB_CODE_SUCCESS;
 }
 
diff --git a/source/libs/nodes/src/nodesCodeFuncs.c b/source/libs/nodes/src/nodesCodeFuncs.c
index 402a6c6e3d..6696aab4c1 100644
--- a/source/libs/nodes/src/nodesCodeFuncs.c
+++ b/source/libs/nodes/src/nodesCodeFuncs.c
@@ -1784,6 +1784,24 @@ static int32_t jsonToPhysiTagScanNode(const SJson* pJson, void* pObj) {
 static const char* jkLastRowScanPhysiPlanGroupTags = "GroupTags";
 static const char* jkLastRowScanPhysiPlanGroupSort = "GroupSort";
 static const char* jkLastRowScanPhysiPlanTargets = "Targets";
+static const char* jkLastRowScanPhysiPlanFuncType = "FuncType";
+static const char* jkLastRowScanPhysiPlanFuncTypes = "FuncTypes";
+
+static int32_t funcTypeToJson(const void* pObj, SJson* pJson) {
+  const int32_t* pNode = (const int32_t*)pObj;
+
+  int32_t code = tjsonAddIntegerToObject(pJson, jkLastRowScanPhysiPlanFuncType, *pNode);
+  return code;
+}
+
+static int32_t jsonToFuncType(const SJson* pJson, void* pObj) {
+  int32_t* pNode = (int32_t*)pObj;
+
+  int32_t code = tjsonGetIntValue(pJson, jkLastRowScanPhysiPlanFuncType, pNode);
+  return code;
+}
+
+
 
 static int32_t physiLastRowScanNodeToJson(const void* pObj, SJson* pJson) {
   const SLastRowScanPhysiNode* pNode = (const SLastRowScanPhysiNode*)pObj;
@@ -1798,6 +1816,9 @@ static int32_t physiLastRowScanNodeToJson(const void* pObj, SJson* pJson) {
   if (TSDB_CODE_SUCCESS == code) {
     code = nodeListToJson(pJson, jkLastRowScanPhysiPlanTargets, pNode->pTargets);
   }
+    if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonAddTArray(pJson, jkLastRowScanPhysiPlanFuncTypes, funcTypeToJson, pNode->pFuncTypes);
+  }
 
   return code;
 }
@@ -1815,6 +1836,9 @@ static int32_t jsonToPhysiLastRowScanNode(const SJson* pJson, void* pObj) {
   if (TSDB_CODE_SUCCESS == code) {
     code = jsonToNodeList(pJson, jkLastRowScanPhysiPlanTargets, &pNode->pTargets);
   }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonToTArray(pJson, jkLastRowScanPhysiPlanFuncTypes, jsonToFuncType, &pNode->pFuncTypes, sizeof(int32_t));
+  }
 
   return code;
 }
diff --git a/source/libs/nodes/src/nodesEqualFuncs.c b/source/libs/nodes/src/nodesEqualFuncs.c
index f755b8cb8c..241da85267 100644
--- a/source/libs/nodes/src/nodesEqualFuncs.c
+++ b/source/libs/nodes/src/nodesEqualFuncs.c
@@ -194,3 +194,21 @@ bool nodesEqualNode(const SNode* a, const SNode* b) {
 
   return false;
 }
+
+ bool nodeListNodeEqual(const SNodeList* a, const SNode* b) {
+  if (NULL == a || NULL == b) {
+    return false;
+  }
+
+  if (LIST_LENGTH(a) < 1) {
+    return false;
+  }
+
+  SNode *na;
+  FOREACH(na, a) {
+    if (nodesEqualNode(na, b)) {
+      return true;
+    }
+  }
+  return false;
+}
diff --git a/source/libs/nodes/src/nodesMsgFuncs.c b/source/libs/nodes/src/nodesMsgFuncs.c
index b36e2695f6..3cff7c76aa 100644
--- a/source/libs/nodes/src/nodesMsgFuncs.c
+++ b/source/libs/nodes/src/nodesMsgFuncs.c
@@ -65,10 +65,14 @@ typedef int32_t (*FSetObject)(STlv* pTlv, void* pObj);
 
 static int32_t nodeToMsg(const void* pObj, STlvEncoder* pEncoder);
 static int32_t nodeListToMsg(const void* pObj, STlvEncoder* pEncoder);
+static int32_t SArrayToMsg(const void* pObj, STlvEncoder* pEncoder);
+
 static int32_t msgToNode(STlvDecoder* pDecoder, void** pObj);
 static int32_t msgToNodeFromTlv(STlv* pTlv, void** pObj);
 static int32_t msgToNodeList(STlvDecoder* pDecoder, void** pObj);
 static int32_t msgToNodeListFromTlv(STlv* pTlv, void** pObj);
+static int32_t msgToSArray(STlv* pTlv, void** pObj);
+
 
 static int32_t initTlvEncoder(STlvEncoder* pEncoder) {
   pEncoder->allocSize = NODES_MSG_DEFAULT_LEN;
@@ -2053,7 +2057,8 @@ enum {
   PHY_LAST_ROW_SCAN_CODE_GROUP_TAGS,
   PHY_LAST_ROW_SCAN_CODE_GROUP_SORT,
   PHY_LAST_ROW_SCAN_CODE_IGNULL,
-  PHY_LAST_ROW_SCAN_CODE_TARGETS
+  PHY_LAST_ROW_SCAN_CODE_TARGETS,
+  PHY_LAST_ROW_SCAN_CODE_FUNCTYPES
 };
 
 static int32_t physiLastRowScanNodeToMsg(const void* pObj, STlvEncoder* pEncoder) {
@@ -2072,6 +2077,9 @@ static int32_t physiLastRowScanNodeToMsg(const void* pObj, STlvEncoder* pEncoder
   if (TSDB_CODE_SUCCESS == code) {
     code = tlvEncodeObj(pEncoder, PHY_LAST_ROW_SCAN_CODE_TARGETS, nodeListToMsg, pNode->pTargets);
   }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tlvEncodeObj(pEncoder, PHY_LAST_ROW_SCAN_CODE_FUNCTYPES, SArrayToMsg, pNode->pFuncTypes);
+  }
 
   return code;
 }
@@ -2098,6 +2106,10 @@ static int32_t msgToPhysiLastRowScanNode(STlvDecoder* pDecoder, void* pObj) {
       case PHY_LAST_ROW_SCAN_CODE_TARGETS:
         code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pTargets);
         break;
+      case PHY_LAST_ROW_SCAN_CODE_FUNCTYPES:
+        code = msgToSArray(pTlv, (void**)&pNode->pFuncTypes);
+        break;
+
       default:
         break;
     }
@@ -4391,6 +4403,31 @@ static int32_t nodeListToMsg(const void* pObj, STlvEncoder* pEncoder) {
 
   return TSDB_CODE_SUCCESS;
 }
+enum {
+  SARRAY_CODE_CAPACITY = 1,
+  SARRAY_CODE_ELEMSIZE,
+  SARRAY_CODE_SIZE,
+  SARRAY_CODE_PDATA
+};
+
+static int32_t SArrayToMsg(const void* pObj, STlvEncoder* pEncoder) {
+  const SArray* pArray = (const SArray*)pObj;
+  int32_t code = TSDB_CODE_SUCCESS;
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tlvEncodeI32(pEncoder, SARRAY_CODE_CAPACITY, pArray->capacity);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tlvEncodeI32(pEncoder, SARRAY_CODE_ELEMSIZE, pArray->elemSize);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tlvEncodeI32(pEncoder, SARRAY_CODE_SIZE, pArray->size);
+  }
+  if (TSDB_CODE_SUCCESS == code && pArray->capacity * pArray->elemSize > 0 && pArray->pData != NULL) {
+    code = tlvEncodeBinary(pEncoder, SARRAY_CODE_PDATA, pArray->pData, pArray->capacity * pArray->elemSize);
+  }
+  return code;
+}
+
 
 static int32_t msgToNodeList(STlvDecoder* pDecoder, void** pObj) {
   SNodeList* pList = nodesMakeList();
@@ -4411,6 +4448,67 @@ static int32_t msgToNodeList(STlvDecoder* pDecoder, void** pObj) {
   return code;
 }
 
+static int32_t msgToSArray(STlv* pTlv, void** pObj){
+  SArray* pArray = NULL;
+  uint32_t capacity = 0;
+  uint32_t elemSize = 0;
+  uint32_t actualSize;
+  int32_t decodeFieldNum = 0;;
+  int32_t code = TSDB_CODE_SUCCESS;
+  STlvDecoder decoder = {.bufSize = pTlv->len, .offset = 0, .pBuf = pTlv->value};
+  STlv*   pTlvTemp = NULL;
+  STlv*   pDataTlv = NULL;
+
+  tlvForEach(&decoder, pTlvTemp, code) {
+    switch (pTlvTemp->type) {
+      case SARRAY_CODE_CAPACITY:
+        code = tlvDecodeI32(pTlvTemp, &capacity);
+        break;
+      case SARRAY_CODE_ELEMSIZE:
+        code = tlvDecodeI32(pTlvTemp, &elemSize);
+        break;
+      case SARRAY_CODE_SIZE:
+        code = tlvDecodeI32(pTlvTemp, &actualSize);
+        break;
+      case SARRAY_CODE_PDATA:
+        if (decodeFieldNum < 3) {
+          pDataTlv = pTlvTemp;
+          break;
+        }
+        pArray = taosArrayInit(capacity, elemSize);
+        if (NULL == pArray) {
+          return TSDB_CODE_OUT_OF_MEMORY;
+        }
+        pArray->size = actualSize;
+        if (TSDB_CODE_SUCCESS != code || pTlvTemp == NULL) {
+          taosArrayDestroy(pArray);
+          return TSDB_CODE_OUT_OF_MEMORY;
+        }
+        code = tlvDecodeBinary(pTlvTemp, pArray->pData);
+        break;
+      default:
+        break;
+    }
+    decodeFieldNum++;
+  }
+
+  if (pDataTlv != NULL) {
+    pArray = taosArrayInit(capacity, elemSize);
+    if (NULL == pArray) {
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
+    pArray->size = actualSize;
+    if (TSDB_CODE_SUCCESS != code || pTlvTemp == NULL) {
+      taosArrayDestroy(pArray);
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
+    code = tlvDecodeBinary(pDataTlv, pArray->pData);
+  }
+  *pObj = pArray;
+  return code;
+}
+
+
 static int32_t msgToNodeListFromTlv(STlv* pTlv, void** pObj) {
   STlvDecoder decoder = {.bufSize = pTlv->len, .offset = 0, .pBuf = pTlv->value};
   return msgToNodeList(&decoder, pObj);
diff --git a/source/libs/nodes/src/nodesUtilFuncs.c b/source/libs/nodes/src/nodesUtilFuncs.c
index 8f2e82385b..5bd466af43 100644
--- a/source/libs/nodes/src/nodesUtilFuncs.c
+++ b/source/libs/nodes/src/nodesUtilFuncs.c
@@ -674,6 +674,8 @@ static void destroyTableCfg(STableCfg* pCfg) {
 
 static void destroySmaIndex(void* pIndex) { taosMemoryFree(((STableIndexInfo*)pIndex)->expr); }
 
+static void destroyFuncParam(void* pValue) { taosMemoryFree(((SFunctParam*)pValue)->pCol); }
+
 static void destroyHintValue(EHintOption option, void* value) {
   switch (option) {
     default:
@@ -1173,6 +1175,7 @@ void nodesDestroyNode(SNode* pNode) {
       nodesDestroyList(pLogicNode->pGroupTags);
       nodesDestroyList(pLogicNode->pTags);
       nodesDestroyNode(pLogicNode->pSubtable);
+      taosArrayDestroyEx(pLogicNode->pFuncTypes, destroyFuncParam);
       break;
     }
     case QUERY_NODE_LOGIC_PLAN_JOIN: {
@@ -1300,6 +1303,7 @@ void nodesDestroyNode(SNode* pNode) {
       destroyScanPhysiNode((SScanPhysiNode*)pNode);
       nodesDestroyList(pPhyNode->pGroupTags);
       nodesDestroyList(pPhyNode->pTargets);
+      taosArrayDestroy(pPhyNode->pFuncTypes);
       break;
     }
     case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN:
diff --git a/source/libs/planner/src/planOptimizer.c b/source/libs/planner/src/planOptimizer.c
index 035377d22e..af1475aea2 100644
--- a/source/libs/planner/src/planOptimizer.c
+++ b/source/libs/planner/src/planOptimizer.c
@@ -2501,17 +2501,30 @@ static bool lastRowScanOptCheckColNum(int32_t lastColNum, col_id_t lastColId,
   return true;
 }
 
-static bool lastRowScanOptCheckFuncList(SLogicNode* pNode, bool* hasOtherFunc) {
+static bool isNeedSplitCacheLastFunc(SFunctionNode* pFunc, SScanLogicNode* pScan) {
+  int32_t funcType = pFunc->funcType;
+  if ((FUNCTION_TYPE_LAST_ROW != funcType || (FUNCTION_TYPE_LAST_ROW == funcType && TSDB_CACHE_MODEL_LAST_VALUE == pScan->cacheLastMode)) &&
+       (FUNCTION_TYPE_LAST != funcType || (FUNCTION_TYPE_LAST == funcType && (TSDB_CACHE_MODEL_LAST_ROW == pScan->cacheLastMode ||
+         QUERY_NODE_OPERATOR == nodeType(nodesListGetNode(pFunc->pParameterList, 0)) || QUERY_NODE_VALUE == nodeType(nodesListGetNode(pFunc->pParameterList, 0))))) &&
+        FUNCTION_TYPE_SELECT_VALUE != funcType && FUNCTION_TYPE_GROUP_KEY != funcType) {
+    return true;
+  }
+  return false;
+}
+
+static bool lastRowScanOptCheckFuncList(SLogicNode* pNode, int8_t cacheLastModel, bool* hasOtherFunc) {
   bool     hasNonPKSelectFunc = false;
   SNode*   pFunc = NULL;
   int32_t  lastColNum = 0, selectNonPKColNum = 0;
   col_id_t lastColId = -1, selectNonPKColId = -1;
+  SScanLogicNode* pScan = (SScanLogicNode*)nodesListGetNode(((SAggLogicNode*)pNode)->node.pChildren, 0);
+  uint32_t needSplitFuncCount = 0;
   FOREACH(pFunc, ((SAggLogicNode*)pNode)->pAggFuncs) {
     SFunctionNode* pAggFunc = (SFunctionNode*)pFunc;
+    SNode* pParam = nodesListGetNode(pAggFunc->pParameterList, 0);
     if (FUNCTION_TYPE_LAST == pAggFunc->funcType) {
-      SNode* pPar = nodesListGetNode(pAggFunc->pParameterList, 0);
-      if (QUERY_NODE_COLUMN == nodeType(pPar)) {
-        SColumnNode* pCol = (SColumnNode*)pPar;
+      if (QUERY_NODE_COLUMN == nodeType(pParam)) {
+        SColumnNode* pCol = (SColumnNode*)pParam;
         if (pCol->colType != COLUMN_TYPE_COLUMN) {
           return false;
         }
@@ -2520,13 +2533,18 @@ static bool lastRowScanOptCheckFuncList(SLogicNode* pNode, bool* hasOtherFunc) {
           lastColNum++;
         }
       }
-      if (QUERY_NODE_VALUE == nodeType(nodesListGetNode(pAggFunc->pParameterList, 0))) {
+      else if (QUERY_NODE_VALUE == nodeType(pParam) || QUERY_NODE_OPERATOR == nodeType(pParam)) {
+        needSplitFuncCount++;
+        *hasOtherFunc = true;
+      }
+      if (!lastRowScanOptCheckColNum(lastColNum, lastColId, selectNonPKColNum, selectNonPKColId)) {
         return false;
       }
-      if (!lastRowScanOptCheckColNum(lastColNum, lastColId, selectNonPKColNum, selectNonPKColId))
-        return false;
+      if (TSDB_CACHE_MODEL_LAST_ROW == cacheLastModel) {
+        needSplitFuncCount++;
+        *hasOtherFunc = true;
+      }
     } else if (FUNCTION_TYPE_SELECT_VALUE == pAggFunc->funcType) {
-      SNode* pParam = nodesListGetNode(pAggFunc->pParameterList, 0);
       if (QUERY_NODE_COLUMN == nodeType(pParam)) {
         SColumnNode* pCol = (SColumnNode*)pParam;
         if (COLUMN_TYPE_COLUMN == pCol->colType && PRIMARYKEY_TIMESTAMP_COL_ID != pCol->colId) {
@@ -2548,15 +2566,21 @@ static bool lastRowScanOptCheckFuncList(SLogicNode* pNode, bool* hasOtherFunc) {
       }
     } else if (FUNCTION_TYPE_LAST_ROW != pAggFunc->funcType) {
       *hasOtherFunc = true;
+      needSplitFuncCount++;
+    } else if (FUNCTION_TYPE_LAST_ROW == pAggFunc->funcType && TSDB_CACHE_MODEL_LAST_VALUE == cacheLastModel) {
+      *hasOtherFunc = true;
+      needSplitFuncCount++;
     }
   }
+  if (needSplitFuncCount >= ((SAggLogicNode*)pNode)->pAggFuncs->length) {
+    return false;
+  }
 
   return true;
 }
 
 static bool lastRowScanOptCheckLastCache(SAggLogicNode* pAgg, SScanLogicNode* pScan) {
-  // Only one of LAST and LASTROW can appear
-  if (pAgg->hasLastRow == pAgg->hasLast || (!pAgg->hasLast && !pAgg->hasLastRow) || NULL != pAgg->pGroupKeys || NULL != pScan->node.pConditions ||
+  if ((pAgg->hasLastRow == pAgg->hasLast && !pAgg->hasLastRow) || (!pAgg->hasLast && !pAgg->hasLastRow) || NULL != pAgg->pGroupKeys || NULL != pScan->node.pConditions ||
       !hasSuitableCache(pScan->cacheLastMode, pAgg->hasLastRow, pAgg->hasLast) ||
       IS_TSWINDOW_SPECIFIED(pScan->scanRange)) {
     return false;
@@ -2578,7 +2602,7 @@ static bool lastRowScanOptMayBeOptimized(SLogicNode* pNode) {
   }
   
   bool hasOtherFunc = false;
-  if (!lastRowScanOptCheckFuncList(pNode, &hasOtherFunc)) {
+  if (!lastRowScanOptCheckFuncList(pNode, pScan->cacheLastMode, &hasOtherFunc)) {
     return false;
   }
 
@@ -2593,6 +2617,7 @@ typedef struct SLastRowScanOptSetColDataTypeCxt {
   bool       doAgg;
   SNodeList* pLastCols;
   SNodeList* pOtherCols;
+  int32_t    funcType;
 } SLastRowScanOptSetColDataTypeCxt;
 
 static EDealRes lastRowScanOptSetColDataType(SNode* pNode, void* pContext) {
@@ -2615,7 +2640,7 @@ static EDealRes lastRowScanOptSetColDataType(SNode* pNode, void* pContext) {
   return DEAL_RES_CONTINUE;
 }
 
-static void lastRowScanOptSetLastTargets(SNodeList* pTargets, SNodeList* pLastCols, bool erase) {
+static void lastRowScanOptSetLastTargets(SNodeList* pTargets, SNodeList* pLastCols, SNodeList* pLastRowCols, bool erase) {
   SNode* pTarget = NULL;
   WHERE_EACH(pTarget, pTargets) {
     bool   found = false;
@@ -2627,6 +2652,10 @@ static void lastRowScanOptSetLastTargets(SNodeList* pTargets, SNodeList* pLastCo
         break;
       }
     }
+    if (!found && nodeListNodeEqual(pLastRowCols, pTarget)) {
+      found = true;
+    }
+
     if (!found && erase) {
       ERASE_NODE(pTargets);
       continue;
@@ -2635,7 +2664,7 @@ static void lastRowScanOptSetLastTargets(SNodeList* pTargets, SNodeList* pLastCo
   }
 }
 
-static void lastRowScanOptRemoveUslessTargets(SNodeList* pTargets, SNodeList* pList1, SNodeList* pList2) {
+static void lastRowScanOptRemoveUslessTargets(SNodeList* pTargets, SNodeList* pList1, SNodeList* pList2, SNodeList* pList3) {
   SNode* pTarget = NULL;
   WHERE_EACH(pTarget, pTargets) {
     bool   found = false;
@@ -2654,6 +2683,11 @@ static void lastRowScanOptRemoveUslessTargets(SNodeList* pTargets, SNodeList* pL
         }
       }
     }
+
+    if (!found && nodeListNodeEqual(pList3, pTarget)) {
+      found = true;
+    }
+
     if (!found) {
       ERASE_NODE(pTargets);
       continue;
@@ -2662,6 +2696,33 @@ static void lastRowScanOptRemoveUslessTargets(SNodeList* pTargets, SNodeList* pL
   }
 }
 
+static int32_t lastRowScanBuildFuncTypes(SScanLogicNode* pScan, SColumnNode* pColNode, int32_t funcType) {
+  SFunctParam* pFuncTypeParam = taosMemoryCalloc(1, sizeof(SFunctParam));
+  if (NULL == pFuncTypeParam) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+  pFuncTypeParam->type = funcType;
+  if (NULL == pScan->pFuncTypes) {
+    pScan->pFuncTypes = taosArrayInit(pScan->pScanCols->length, sizeof(SFunctParam));
+    if (NULL == pScan->pFuncTypes) {
+      taosMemoryFree(pFuncTypeParam);
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
+  }
+ 
+  pFuncTypeParam->pCol = taosMemoryCalloc(1, sizeof(SColumn));
+  if (NULL == pFuncTypeParam->pCol) {
+    taosMemoryFree(pFuncTypeParam);
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+  pFuncTypeParam->pCol->colId = pColNode->colId;
+  strcpy(pFuncTypeParam->pCol->name, pColNode->colName);
+  taosArrayPush(pScan->pFuncTypes, pFuncTypeParam);
+
+  taosMemoryFree(pFuncTypeParam);
+  return TSDB_CODE_SUCCESS;
+}
+
 static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
   SAggLogicNode* pAgg = (SAggLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, lastRowScanOptMayBeOptimized);
 
@@ -2673,10 +2734,16 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic
   SNode*                           pNode = NULL;
   SColumnNode*                     pPKTsCol = NULL;
   SColumnNode*                     pNonPKCol = NULL;
+  SScanLogicNode* pScan = (SScanLogicNode*)nodesListGetNode(pAgg->node.pChildren, 0);
+  pScan->scanType = SCAN_TYPE_LAST_ROW;
+  pScan->igLastNull = pAgg->hasLast ? true : false;
+  SArray* isDuplicateCol = taosArrayInit(pScan->pScanCols->length, sizeof(bool));
+  SNodeList* pLastRowCols = NULL;
 
   FOREACH(pNode, pAgg->pAggFuncs) {
     SFunctionNode* pFunc = (SFunctionNode*)pNode;
     int32_t        funcType = pFunc->funcType;
+    SNode* pParamNode = nodesListGetNode(pFunc->pParameterList, 0);
     if (FUNCTION_TYPE_LAST_ROW == funcType || FUNCTION_TYPE_LAST == funcType) {
       int32_t len = snprintf(pFunc->functionName, sizeof(pFunc->functionName),
                              FUNCTION_TYPE_LAST_ROW == funcType ? "_cache_last_row" : "_cache_last");
@@ -2686,6 +2753,61 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic
         nodesClearList(cxt.pLastCols);
         return code;
       }
+      cxt.funcType = pFunc->funcType;
+      // add duplicate cols which be removed for both last_row, last
+      if (pAgg->hasLast && pAgg->hasLastRow) {
+        if (QUERY_NODE_COLUMN == nodeType(pParamNode)) {
+          SNode* pColNode = NULL;
+          int i = 0;
+          FOREACH(pColNode, pScan->pScanCols) {
+            bool isDup = false;
+            bool* isDuplicate = taosArrayGet(isDuplicateCol, i);
+            if (NULL == isDuplicate) {
+              taosArrayInsert(isDuplicateCol, i, &isDup);
+              isDuplicate = taosArrayGet(isDuplicateCol, i);
+            }
+            i++;
+            if (nodesEqualNode(pParamNode, pColNode)) {
+              if (*isDuplicate) {
+                if (0 == strncmp(((SColumnNode*)pColNode)->colName, "#dup_col.", 9)) {
+                  continue;
+                }
+                SNode* newColNode = nodesCloneNode(pColNode);
+                sprintf(((SColumnNode*)newColNode)->colName, "#dup_col.%p", newColNode);
+                sprintf(((SColumnNode*)pParamNode)->colName, "#dup_col.%p", newColNode);
+
+                nodesListAppend(pScan->pScanCols, newColNode);
+                isDup = true;
+                taosArrayInsert(isDuplicateCol, pScan->pScanCols->length, &isDup);
+                nodesListAppend(pScan->node.pTargets, nodesCloneNode(newColNode));
+                if (funcType != FUNCTION_TYPE_LAST) {
+                  nodesListMakeAppend(&pLastRowCols, nodesCloneNode(newColNode));
+                }
+
+                lastRowScanBuildFuncTypes(pScan, (SColumnNode*)newColNode, pFunc->funcType);
+              } else {
+                isDup = true;
+                *isDuplicate = isDup;
+                if (funcType != FUNCTION_TYPE_LAST && !nodeListNodeEqual(cxt.pLastCols, pColNode)) {
+                  nodesListMakeAppend(&pLastRowCols, nodesCloneNode(pColNode));
+                }
+                lastRowScanBuildFuncTypes(pScan, (SColumnNode*)pColNode, pFunc->funcType);
+              }
+              continue;
+            }else if (nodeListNodeEqual(pFunc->pParameterList, pColNode)) {
+              if (funcType != FUNCTION_TYPE_LAST && ((SColumnNode*)pColNode)->colId == PRIMARYKEY_TIMESTAMP_COL_ID &&
+                  !nodeListNodeEqual(pLastRowCols, pColNode)) {
+                nodesListMakeAppend(&pLastRowCols, nodesCloneNode(pColNode));
+
+                lastRowScanBuildFuncTypes(pScan, (SColumnNode*)pColNode, pFunc->funcType);
+                isDup = true;
+                *isDuplicate = isDup;
+              }
+            }
+          }
+        }
+      }
+
       if (FUNCTION_TYPE_LAST == funcType) {
         nodesWalkExpr(nodesListGetNode(pFunc->pParameterList, 0), lastRowScanOptSetColDataType, &cxt);
         nodesListErase(pFunc->pParameterList, nodesListGetCell(pFunc->pParameterList, 1));
@@ -2707,15 +2829,13 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic
     }
   }
 
-  SScanLogicNode* pScan = (SScanLogicNode*)nodesListGetNode(pAgg->node.pChildren, 0);
-  pScan->scanType = SCAN_TYPE_LAST_ROW;
-  pScan->igLastNull = pAgg->hasLast ? true : false;
   if (NULL != cxt.pLastCols) {
     cxt.doAgg = false;
-    lastRowScanOptSetLastTargets(pScan->pScanCols, cxt.pLastCols, true);
+    cxt.funcType = FUNCTION_TYPE_CACHE_LAST;
+    lastRowScanOptSetLastTargets(pScan->pScanCols, cxt.pLastCols, pLastRowCols, true);
     nodesWalkExprs(pScan->pScanPseudoCols, lastRowScanOptSetColDataType, &cxt);
-    lastRowScanOptSetLastTargets(pScan->node.pTargets, cxt.pLastCols, false);
-    lastRowScanOptRemoveUslessTargets(pScan->node.pTargets, cxt.pLastCols, cxt.pOtherCols);
+    lastRowScanOptSetLastTargets(pScan->node.pTargets, cxt.pLastCols, pLastRowCols, false);
+    lastRowScanOptRemoveUslessTargets(pScan->node.pTargets, cxt.pLastCols, cxt.pOtherCols, pLastRowCols);
     if (pPKTsCol && pScan->node.pTargets->length == 1) {
       // when select last(ts),ts from ..., we add another ts to targets
       sprintf(pPKTsCol->colName, "#sel_val.%p", pPKTsCol);
@@ -2728,10 +2848,12 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic
     }
     nodesClearList(cxt.pLastCols);
   }
+
   pAgg->hasLastRow = false;
   pAgg->hasLast = false;
 
   pCxt->optimized = true;
+  taosArrayDestroy(isDuplicateCol);
   return TSDB_CODE_SUCCESS;
 }
 
@@ -2749,7 +2871,7 @@ static bool splitCacheLastFuncOptMayBeOptimized(SLogicNode* pNode) {
   }
 
   bool hasOtherFunc = false;
-  if (!lastRowScanOptCheckFuncList(pNode, &hasOtherFunc)) {
+  if (!lastRowScanOptCheckFuncList(pNode, pScan->cacheLastMode, &hasOtherFunc)) {
     return false;
   }
 
@@ -2770,6 +2892,16 @@ static int32_t splitCacheLastFuncOptCreateAggLogicNode(SAggLogicNode** pNewAgg,
 
   pNew->hasLastRow = false;
   pNew->hasLast = false;
+  SNode* pFuncNode = NULL;
+  FOREACH(pFuncNode, pFunc) {
+    SFunctionNode* pFunc = (SFunctionNode*)pFuncNode;
+    if (FUNCTION_TYPE_LAST_ROW == pFunc->funcType) {
+      pNew->hasLastRow = true;
+    } else if (FUNCTION_TYPE_LAST == pFunc->funcType) {
+      pNew->hasLast = true;
+    }
+  }
+
   pNew->hasTimeLineFunc = pAgg->hasTimeLineFunc;
   pNew->hasGroupKeyOptimized = false;
   pNew->onlyHasKeepOrderFunc = pAgg->onlyHasKeepOrderFunc;
@@ -2894,21 +3026,31 @@ static int32_t splitCacheLastFuncOptimize(SOptimizeContext* pCxt, SLogicSubplan*
   if (NULL == pAgg) {
     return TSDB_CODE_SUCCESS;
   }
-
+  SScanLogicNode* pScan = (SScanLogicNode*)nodesListGetNode(pAgg->node.pChildren, 0);
   SNode* pNode = NULL;
   SNodeList* pAggFuncList = NULL;
+
   {
+    bool hasLast = false;
+    bool hasLastRow = false;
     WHERE_EACH(pNode, pAgg->pAggFuncs) {
       SFunctionNode* pFunc = (SFunctionNode*)pNode;
       int32_t        funcType = pFunc->funcType;
-      if (FUNCTION_TYPE_LAST_ROW != funcType && FUNCTION_TYPE_LAST != funcType && 
-          FUNCTION_TYPE_SELECT_VALUE != funcType && FUNCTION_TYPE_GROUP_KEY != funcType) {
+
+      if (isNeedSplitCacheLastFunc(pFunc, pScan)) {
         nodesListMakeStrictAppend(&pAggFuncList, nodesCloneNode(pNode));
         ERASE_NODE(pAgg->pAggFuncs);
         continue;
       }
+      if (FUNCTION_TYPE_LAST_ROW == funcType ) {
+        hasLastRow = true;
+      } else if (FUNCTION_TYPE_LAST == funcType) {
+        hasLast = true;
+      }
       WHERE_NEXT;    
     }
+    pAgg->hasLast = hasLast;
+    pAgg->hasLastRow = hasLastRow;
   }
 
   if (NULL == pAggFuncList) {
diff --git a/source/libs/planner/src/planPhysiCreater.c b/source/libs/planner/src/planPhysiCreater.c
index e266c55425..21c698fda5 100644
--- a/source/libs/planner/src/planPhysiCreater.c
+++ b/source/libs/planner/src/planPhysiCreater.c
@@ -562,9 +562,36 @@ static int32_t createLastRowScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* pSu
 
   pScan->groupSort = pScanLogicNode->groupSort;
   pScan->ignoreNull = pScanLogicNode->igLastNull;
+
   vgroupInfoToNodeAddr(pScanLogicNode->pVgroupList->vgroups, &pSubplan->execNode);
 
-  return createScanPhysiNodeFinalize(pCxt, pSubplan, pScanLogicNode, (SScanPhysiNode*)pScan, pPhyNode);
+  int32_t code = createScanPhysiNodeFinalize(pCxt, pSubplan, pScanLogicNode, (SScanPhysiNode*)pScan, pPhyNode);
+
+  if (TSDB_CODE_SUCCESS == code && pScanLogicNode->pFuncTypes != NULL) {
+    pScan->pFuncTypes = taosArrayInit(taosArrayGetSize(pScanLogicNode->pFuncTypes), sizeof(int32_t));
+    if (NULL == pScan->pFuncTypes) {
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
+    SNode* pTargetNode = NULL;
+    int funcTypeIndex = 0;
+    FOREACH(pTargetNode, ((SScanPhysiNode*)pScan)->pScanCols) {
+      if (((STargetNode*)pTargetNode)->pExpr->type != QUERY_NODE_COLUMN) {
+        continue;
+      }
+      SColumnNode* pColNode = (SColumnNode*)((STargetNode*)pTargetNode)->pExpr;
+
+      for (int i = 0; i < TARRAY_SIZE(pScanLogicNode->pFuncTypes); ++i) {
+        SFunctParam* pFunctParam = taosArrayGet(pScanLogicNode->pFuncTypes, i);
+        if (pColNode->colId == pFunctParam->pCol->colId &&
+             0 == strncmp(pColNode->colName, pFunctParam->pCol->name, strlen(pColNode->colName))) {
+          taosArrayInsert(pScan->pFuncTypes, funcTypeIndex, &pFunctParam->type);
+          break;
+        }
+      }
+      funcTypeIndex++;
+    }
+  }
+  return code;
 }
 
 static int32_t createTableCountScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* pSubplan,
diff --git a/tests/parallel_test/cases.task b/tests/parallel_test/cases.task
index 63745f75ab..b6aff95571 100644
--- a/tests/parallel_test/cases.task
+++ b/tests/parallel_test/cases.task
@@ -422,6 +422,11 @@ e
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/last_row.py -R
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/last.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/last.py -R
+,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/last_and_last_row.py
+,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/last_and_last_row.py -R
+,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/last_and_last_row.py -Q 2
+,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/last_and_last_row.py -Q 3
+,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/last_and_last_row.py -Q 4
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/leastsquares.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/leastsquares.py -R
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/length.py
diff --git a/tests/script/tsim/query/cache_last.sim b/tests/script/tsim/query/cache_last.sim
index 8247a2f723..65eb46de69 100644
--- a/tests/script/tsim/query/cache_last.sim
+++ b/tests/script/tsim/query/cache_last.sim
@@ -55,7 +55,7 @@ if $rows != 1 then
   return -1
 endi
 sql explain select count(*), last_row(f1), last(f1) from sta;
-if $data00 != @-> Aggragate (functions=3 width=24 input_order=desc )@ then
+if $data00 != @-> Merge (columns=3 width=24 input_order=unknown output_order=unknown mode=column)@ then
   return -1
 endi
 sql_error select count(*), last_row(f1), min(f1), f1 from sta;
diff --git a/tests/system-test/2-query/last_and_last_row.py b/tests/system-test/2-query/last_and_last_row.py
new file mode 100644
index 0000000000..b04b3a75f3
--- /dev/null
+++ b/tests/system-test/2-query/last_and_last_row.py
@@ -0,0 +1,660 @@
+import datetime
+import sys
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import tdDnodes
+from math import inf
+
+
+class TDTestCase:
+    def init(self, conn, logSql, replicaVer=1):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor(), True)
+
+    def check_explain_res_has_row(self, plan_str_expect: str, rows, sql):
+        plan_found = False
+        for row in rows:
+            if str(row).find(plan_str_expect) >= 0:
+                tdLog.debug("plan: [%s] found in: [%s]" % (plan_str_expect, str(row)))
+                plan_found = True
+                break
+        if not plan_found:
+            tdLog.exit("plan: %s not found in res: [%s] in sql: %s" % (plan_str_expect, str(rows), sql))
+
+    def check_explain_res_no_row(self, plan_str_not_expect: str, res, sql):
+        for row in res:
+            if str(row).find(plan_str_not_expect) >= 0:
+                tdLog.exit('plan: [%s] found in: [%s] for sql: %s' % (plan_str_not_expect, str(row), sql))
+
+    def explain_sql(self, sql: str):
+        sql = "explain " + sql
+        tdSql.query(sql, queryTimes=1)
+        return tdSql.queryResult
+
+    def explain_and_check_res(self, sqls, hasLastRowScanRes):
+        for sql, has_last in zip(sqls, hasLastRowScanRes):
+            res = self.explain_sql(sql)
+            if has_last == 1:
+                self.check_explain_res_has_row("Last Row Scan", res, sql)
+            else:
+                self.check_explain_res_no_row("Last Row Scan", res, sql)
+
+    def none_model_test(self):
+        tdSql.execute("drop database if exists last_test_none_model ;")
+        tdSql.execute("create database last_test_none_model cachemodel 'none';")
+        tdSql.execute("use last_test_none_model;")
+        tdSql.execute("create stable last_test_none_model.st(ts timestamp, id int) tags(tid int);")
+        tdSql.execute("create table last_test_none_model.test_t1 using last_test_none_model.st tags(1);")
+        tdSql.execute("create table last_test_none_model.test_t2 using last_test_none_model.st tags(2);")
+        tdSql.execute("create table last_test_none_model.test_t3 using last_test_none_model.st tags(3);")
+        tdSql.execute("create table last_test_none_model.test_t4 using last_test_none_model.st tags(4);")
+        
+        maxRange = 100
+        # 2023-11-13 00:00:00.000
+        startTs = 1699804800000
+        for i in range(maxRange):
+            insertSqlString = "insert into last_test_none_model.test_t1 values(%d, %d);" % (startTs + i, i)
+            tdSql.execute(insertSqlString)
+        
+        last_ts = startTs + maxRange
+        tdSql.execute("insert into last_test_none_model.test_t1 (ts) values(%d)" % (last_ts))
+        sql = f'select last_row(ts), last(*)  from last_test_none_model.test_t1;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts)     
+        tdSql.checkData(0, 1, last_ts)     
+        tdSql.checkData(0, 2, maxRange - 1)  
+
+        explain_res = self.explain_sql(sql)
+        self.check_explain_res_no_row("Last Row Scan", explain_res, sql)
+        
+        sql = f'select last_row(ts), last(ts), last_row(id), last(id) from last_test_none_model.test_t1;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts)     
+        tdSql.checkData(0, 1, last_ts)  
+        tdSql.checkData(0, 2, None)    
+        tdSql.checkData(0, 3, maxRange - 1)  
+
+        explain_res = self.explain_sql(sql)
+        self.check_explain_res_no_row("Last Row Scan", explain_res, sql)
+
+        sql = f'select last(*), last_row(ts), count(*) from last_test_none_model.test_t1;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts)     
+        tdSql.checkData(0, 1, maxRange - 1)  
+        tdSql.checkData(0, 2, last_ts)    
+        tdSql.checkData(0, 3, maxRange + 1)
+
+        explain_res = self.explain_sql(sql)
+        self.check_explain_res_no_row("Last Row Scan", explain_res, sql)
+
+        tdSql.error(f'select last(*), last_row(ts), ts from last_test_none_model.test_t1;')
+
+        sql = f'select last_row(ts), last(ts), count(*) , last_row(id), last(id), last(*) from last_test_none_model.test_t1;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts)     
+        tdSql.checkData(0, 1, last_ts)  
+        tdSql.checkData(0, 2, maxRange + 1) 
+        tdSql.checkData(0, 3, None)    
+        tdSql.checkData(0, 4, maxRange - 1)
+        tdSql.checkData(0, 5, last_ts)  
+        tdSql.checkData(0, 6, maxRange - 1)  
+
+       
+        startTs2 = startTs + 86400000
+        for i in range(maxRange):
+            i = i + 2 * maxRange
+            insertSqlString = "insert into last_test_none_model.test_t2 values(%d, %d);" % (startTs2 + i, i)
+            tdSql.execute(insertSqlString)
+        last_ts2 = startTs2 + maxRange
+
+        startTs3 = startTs + 2 * 86400000
+        for i in range(maxRange):
+            i = i + 3 * maxRange
+            insertSqlString = "insert into last_test_none_model.test_t3 values(%d, %d);" % (startTs3 + i, i)
+            tdSql.execute(insertSqlString)
+        last_ts3 = startTs3 + 4 * maxRange - 1
+
+        startTs4 = startTs + 3 * 86400000
+        for i in range(maxRange):
+            i = i + 4 * maxRange
+            insertSqlString = "insert into last_test_none_model.test_t4 values(%d, %d);" % (startTs4 + i, i)
+            tdSql.execute(insertSqlString)
+
+        last_ts4 = startTs4 + 5 * maxRange - 1
+        sql = f'select last_row(ts), last(*)  from last_test_none_model.st;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts4)     
+        tdSql.checkData(0, 1, last_ts4)     
+        tdSql.checkData(0, 2, 5 * maxRange - 1)  
+
+        explain_res = self.explain_sql(sql)
+        self.check_explain_res_no_row("Last Row Scan", explain_res, sql)
+        
+        sql = f'select last_row(ts), last(ts), last_row(id), last(id) from last_test_none_model.st;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts4)     
+        tdSql.checkData(0, 1, last_ts4)  
+        tdSql.checkData(0, 2, 5 * maxRange - 1)    
+        tdSql.checkData(0, 3, 5 * maxRange - 1)  
+
+        explain_res = self.explain_sql(sql)
+        self.check_explain_res_no_row("Last Row Scan", explain_res, sql)
+
+        sql = f'select last(*), last_row(ts), count(*) from last_test_none_model.st;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts4)     
+        tdSql.checkData(0, 1, 5 * maxRange - 1)  
+        tdSql.checkData(0, 2, last_ts4)    
+        tdSql.checkData(0, 3, 4 * maxRange + 1)
+
+        explain_res = self.explain_sql(sql)
+        self.check_explain_res_no_row("Last Row Scan", explain_res, sql)
+
+        tdSql.error(f'select last(*), last_row(ts), ts from last_test_none_model.st;')
+
+        sql = f'select last_row(ts), last(ts), count(*) , last_row(id), last(id), last(*) from last_test_none_model.st;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts4)     
+        tdSql.checkData(0, 1, last_ts4)  
+        tdSql.checkData(0, 2, 4 * maxRange + 1) 
+        tdSql.checkData(0, 3, 5 * maxRange - 1)    
+        tdSql.checkData(0, 4, 5 * maxRange - 1)
+        tdSql.checkData(0, 5, last_ts4)  
+        tdSql.checkData(0, 6, 5 * maxRange - 1)  
+
+        sql = f'select last_row(1), last(2), count(*) , last_row(id), last(id), last(*) from last_test_none_model.st;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, 1)     
+        tdSql.checkData(0, 1, 2)  
+        tdSql.checkData(0, 2, 4 * maxRange + 1) 
+        tdSql.checkData(0, 3, 5 * maxRange - 1)    
+        tdSql.checkData(0, 4, 5 * maxRange - 1)
+        tdSql.checkData(0, 5, last_ts4)  
+        tdSql.checkData(0, 6, 5 * maxRange - 1) 
+
+        tdSql.execute("drop table if exists last_test_none_model.test_t4 ;")
+        tdSql.execute("drop table if exists last_test_none_model.test_t3 ;")
+        tdSql.execute("drop table if exists last_test_none_model.test_t2 ;")
+        tdSql.execute("drop table if exists last_test_none_model.test_t1 ;")
+        tdSql.execute("drop stable if exists last_test_none_model.st;")
+        tdSql.execute("drop database if exists last_test_none_model;")
+
+    def last_value_model_test(self):
+        tdSql.execute("create database last_test_last_value_model cachemodel 'last_value' ;")
+        tdSql.execute("use last_test_last_value_model;")
+        tdSql.execute("create stable last_test_last_value_model.st(ts timestamp, id int) tags(tid int);")
+        tdSql.execute("create table last_test_last_value_model.test_t1 using last_test_last_value_model.st tags(1);")
+        tdSql.execute("create table last_test_last_value_model.test_t2 using last_test_last_value_model.st tags(2);")
+        tdSql.execute("create table last_test_last_value_model.test_t3 using last_test_last_value_model.st tags(3);")
+        tdSql.execute("create table last_test_last_value_model.test_t4 using last_test_last_value_model.st tags(4);")
+
+        maxRange = 100
+        # 2023-11-13 00:00:00.000
+        startTs = 1699804800000
+        for i in range(maxRange):
+            insertSqlString = "insert into last_test_last_value_model.test_t1 values(%d, %d);" % (startTs + i, i)
+            tdSql.execute(insertSqlString)
+        
+        last_ts = startTs + maxRange
+        tdSql.execute("insert into last_test_last_value_model.test_t1 (ts) values(%d)" % (last_ts))
+        sql = f'select last_row(ts), last(*)  from last_test_last_value_model.test_t1;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts)     
+        tdSql.checkData(0, 1, last_ts)     
+        tdSql.checkData(0, 2, maxRange - 1)  
+
+        explain_res = self.explain_sql(sql)
+        self.check_explain_res_has_row("Last Row Scan", explain_res, sql)
+        self.check_explain_res_has_row("Table Scan", explain_res, sql)
+        
+        sql = f'select last_row(ts), last(ts), last_row(id), last(id) from last_test_last_value_model.test_t1;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts)     
+        tdSql.checkData(0, 1, last_ts)  
+        tdSql.checkData(0, 2, None)    
+        tdSql.checkData(0, 3, maxRange - 1)  
+
+        explain_res = self.explain_sql(sql)
+        self.check_explain_res_has_row("Last Row Scan", explain_res, sql)
+        self.check_explain_res_has_row("Table Scan", explain_res, sql)
+
+        sql = f'select last(*), last_row(ts), count(*) from last_test_last_value_model.test_t1;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts)     
+        tdSql.checkData(0, 1, maxRange - 1)  
+        tdSql.checkData(0, 2, last_ts)    
+        tdSql.checkData(0, 3, maxRange + 1)
+
+        explain_res = self.explain_sql(sql)
+        self.check_explain_res_has_row("Last Row Scan", explain_res, sql)
+        self.check_explain_res_has_row("Table Scan", explain_res, sql)
+
+        sql = f'select last_row(ts), last(ts), count(*) , last_row(id), last(id), last(*) from last_test_last_value_model.test_t1;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts)     
+        tdSql.checkData(0, 1, last_ts)  
+        tdSql.checkData(0, 2, maxRange + 1) 
+        tdSql.checkData(0, 3, None)    
+        tdSql.checkData(0, 4, maxRange - 1)
+        tdSql.checkData(0, 5, last_ts)  
+        tdSql.checkData(0, 6, maxRange - 1)  
+
+        startTs2 = startTs + 86400000
+        for i in range(maxRange):
+            i = i + 2 * maxRange
+            insertSqlString = "insert into last_test_last_value_model.test_t2 values(%d, %d);" % (startTs2 + i, i)
+            tdSql.execute(insertSqlString)
+        last_ts2 = startTs2 + maxRange
+
+        startTs3 = startTs + 2 * 86400000
+        for i in range(maxRange):
+            i = i + 3 * maxRange
+            insertSqlString = "insert into last_test_last_value_model.test_t3 values(%d, %d);" % (startTs3 + i, i)
+            tdSql.execute(insertSqlString)
+        last_ts3 = startTs3 + 4 * maxRange - 1
+
+        startTs4 = startTs + 3 * 86400000
+        for i in range(maxRange):
+            i = i + 4 * maxRange
+            insertSqlString = "insert into last_test_last_value_model.test_t4 values(%d, %d);" % (startTs4 + i, i)
+            tdSql.execute(insertSqlString)
+
+        last_ts4 = startTs4 + 5 * maxRange - 1
+        sql = f'select last_row(ts), last(*)  from last_test_last_value_model.st;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts4)     
+        tdSql.checkData(0, 1, last_ts4)     
+        tdSql.checkData(0, 2, 5 * maxRange - 1)  
+
+        explain_res = self.explain_sql(sql)
+        self.check_explain_res_has_row("Last Row Scan", explain_res, sql)
+        self.check_explain_res_has_row("Table Scan", explain_res, sql)
+        
+        sql = f'select last_row(ts), last(ts), last_row(id), last(id) from last_test_last_value_model.st;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts4)     
+        tdSql.checkData(0, 1, last_ts4)  
+        tdSql.checkData(0, 2, 5 * maxRange - 1)    
+        tdSql.checkData(0, 3, 5 * maxRange - 1)  
+
+        explain_res = self.explain_sql(sql)
+        self.check_explain_res_has_row("Last Row Scan", explain_res, sql)
+        self.check_explain_res_has_row("Table Scan", explain_res, sql)
+
+        sql = f'select last(*), last_row(ts), count(*) from last_test_last_value_model.st;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts4)     
+        tdSql.checkData(0, 1, 5 * maxRange - 1)  
+        tdSql.checkData(0, 2, last_ts4)    
+        tdSql.checkData(0, 3, 4 * maxRange + 1)
+
+        explain_res = self.explain_sql(sql)
+        self.check_explain_res_has_row("Last Row Scan", explain_res, sql)
+        self.check_explain_res_has_row("Table Scan", explain_res, sql)
+
+        tdSql.error(f'select last(*), last_row(ts), ts from last_test_last_value_model.st;')
+
+        sql = f'select last_row(ts), last(ts), count(*) , last_row(id), last(id), last(*) from last_test_last_value_model.st;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts4)     
+        tdSql.checkData(0, 1, last_ts4)  
+        tdSql.checkData(0, 2, 4 * maxRange + 1) 
+        tdSql.checkData(0, 3, 5 * maxRange - 1)    
+        tdSql.checkData(0, 4, 5 * maxRange - 1)
+        tdSql.checkData(0, 5, last_ts4)  
+        tdSql.checkData(0, 6, 5 * maxRange - 1) 
+
+        sql = f'select last_row(1), last(2), count(*) , last_row(id), last(id), last(*) from last_test_last_value_model.st;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, 1)     
+        tdSql.checkData(0, 1, 2)  
+        tdSql.checkData(0, 2, 4 * maxRange + 1) 
+        tdSql.checkData(0, 3, 5 * maxRange - 1)    
+        tdSql.checkData(0, 4, 5 * maxRange - 1)
+        tdSql.checkData(0, 5, last_ts4)  
+        tdSql.checkData(0, 6, 5 * maxRange - 1) 
+
+        tdSql.execute("drop table if exists last_test_last_value_model.test_t4 ;")
+        tdSql.execute("drop table if exists last_test_last_value_model.test_t3 ;")
+        tdSql.execute("drop table if exists last_test_last_value_model.test_t2 ;")
+        tdSql.execute("drop table if exists last_test_last_value_model.test_t1 ;")
+        tdSql.execute("drop stable if exists last_test_last_value_model.st;")
+        tdSql.execute("drop database if exists last_test_last_value_model;")
+    
+    def last_row_model_test(self):
+        tdSql.execute("create database last_test_last_row_model cachemodel 'last_row';")
+        tdSql.execute("use last_test_last_row_model;")
+        tdSql.execute("create stable last_test_last_row_model.st(ts timestamp, id int) tags(tid int);")
+        tdSql.execute("create table last_test_last_row_model.test_t1 using last_test_last_row_model.st tags(1);")
+        tdSql.execute("create table last_test_last_row_model.test_t2 using last_test_last_row_model.st tags(2);")
+        tdSql.execute("create table last_test_last_row_model.test_t3 using last_test_last_row_model.st tags(3);")
+        tdSql.execute("create table last_test_last_row_model.test_t4 using last_test_last_row_model.st tags(4);")
+
+        maxRange = 100
+        # 2023-11-13 00:00:00.000
+        startTs = 1699804800000
+        for i in range(maxRange):
+            insertSqlString = "insert into last_test_last_row_model.test_t1 values(%d, %d);" % (startTs + i, i)
+            tdSql.execute(insertSqlString)
+        
+        last_ts = startTs + maxRange
+        tdSql.execute("insert into last_test_last_row_model.test_t1 (ts) values(%d)" % (last_ts))
+        sql = f'select last_row(ts), last(*)  from last_test_last_row_model.test_t1;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts)     
+        tdSql.checkData(0, 1, last_ts)     
+        tdSql.checkData(0, 2, maxRange - 1)  
+
+        explain_res = self.explain_sql(sql)
+        self.check_explain_res_has_row("Last Row Scan", explain_res, sql)
+        self.check_explain_res_has_row("Table Scan", explain_res, sql)
+        
+        sql = f'select last_row(ts), last(ts), last_row(id), last(id) from last_test_last_row_model.test_t1;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts)     
+        tdSql.checkData(0, 1, last_ts)  
+        tdSql.checkData(0, 2, None)    
+        tdSql.checkData(0, 3, maxRange - 1)  
+
+        explain_res = self.explain_sql(sql)
+        self.check_explain_res_has_row("Last Row Scan", explain_res, sql)
+        self.check_explain_res_has_row("Table Scan", explain_res, sql)
+
+        sql = f'select last(*), last_row(ts), count(*) from last_test_last_row_model.test_t1;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts)     
+        tdSql.checkData(0, 1, maxRange - 1)  
+        tdSql.checkData(0, 2, last_ts)    
+        tdSql.checkData(0, 3, maxRange + 1)
+
+        explain_res = self.explain_sql(sql)
+        self.check_explain_res_has_row("Last Row Scan", explain_res, sql)
+        self.check_explain_res_has_row("Table Scan", explain_res, sql)
+
+        sql = f'select last_row(ts), last(ts), count(*) , last_row(id), last(id), last(*) from last_test_last_row_model.test_t1;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts)     
+        tdSql.checkData(0, 1, last_ts)  
+        tdSql.checkData(0, 2, maxRange + 1) 
+        tdSql.checkData(0, 3, None)    
+        tdSql.checkData(0, 4, maxRange - 1)
+        tdSql.checkData(0, 5, last_ts)  
+        tdSql.checkData(0, 6, maxRange - 1)  
+
+        startTs2 = startTs + 86400000
+        for i in range(maxRange):
+            i = i + 2 * maxRange
+            insertSqlString = "insert into last_test_last_row_model.test_t2 values(%d, %d);" % (startTs2 + i, i)
+            tdSql.execute(insertSqlString)
+        last_ts2 = startTs2 + maxRange
+
+        startTs3 = startTs + 2 * 86400000
+        for i in range(maxRange):
+            i = i + 3 * maxRange
+            insertSqlString = "insert into last_test_last_row_model.test_t3 values(%d, %d);" % (startTs3 + i, i)
+            tdSql.execute(insertSqlString)
+        last_ts3 = startTs3 + 4 * maxRange - 1
+
+        startTs4 = startTs + 3 * 86400000
+        for i in range(maxRange):
+            i = i + 4 * maxRange
+            insertSqlString = "insert into last_test_last_row_model.test_t4 values(%d, %d);" % (startTs4 + i, i)
+            tdSql.execute(insertSqlString)
+
+        last_ts4 = startTs4 + 5 * maxRange - 1
+        sql = f'select last_row(ts), last(*)  from last_test_last_row_model.st;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts4)     
+        tdSql.checkData(0, 1, last_ts4)     
+        tdSql.checkData(0, 2, 5 * maxRange - 1)  
+
+        explain_res = self.explain_sql(sql)
+        self.check_explain_res_has_row("Last Row Scan", explain_res, sql)
+        self.check_explain_res_has_row("Table Scan", explain_res, sql)
+        
+        sql = f'select last_row(ts), last(ts), last_row(id), last(id) from last_test_last_row_model.st;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts4)     
+        tdSql.checkData(0, 1, last_ts4)  
+        tdSql.checkData(0, 2, 5 * maxRange - 1)    
+        tdSql.checkData(0, 3, 5 * maxRange - 1)  
+
+        explain_res = self.explain_sql(sql)
+        self.check_explain_res_has_row("Last Row Scan", explain_res, sql)
+        self.check_explain_res_has_row("Table Scan", explain_res, sql)
+
+        sql = f'select last(*), last_row(ts), count(*) from last_test_last_row_model.st;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts4)     
+        tdSql.checkData(0, 1, 5 * maxRange - 1)  
+        tdSql.checkData(0, 2, last_ts4)    
+        tdSql.checkData(0, 3, 4 * maxRange + 1)
+
+        explain_res = self.explain_sql(sql)
+        self.check_explain_res_has_row("Last Row Scan", explain_res, sql)
+        self.check_explain_res_has_row("Table Scan", explain_res, sql)
+
+        tdSql.error(f'select last(*), last_row(ts), ts from last_test_last_row_model.st;')
+
+        sql = f'select last_row(ts), last(ts), count(*) , last_row(id), last(id), last(*) from last_test_last_row_model.st;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts4)     
+        tdSql.checkData(0, 1, last_ts4)  
+        tdSql.checkData(0, 2, 4 * maxRange + 1) 
+        tdSql.checkData(0, 3, 5 * maxRange - 1)    
+        tdSql.checkData(0, 4, 5 * maxRange - 1)
+        tdSql.checkData(0, 5, last_ts4)  
+        tdSql.checkData(0, 6, 5 * maxRange - 1) 
+
+        sql = f'select last_row(1), last(2), count(*) , last_row(id), last(id), last(*) from last_test_last_row_model.st;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, 1)     
+        tdSql.checkData(0, 1, 2)  
+        tdSql.checkData(0, 2, 4 * maxRange + 1) 
+        tdSql.checkData(0, 3, 5 * maxRange - 1)    
+        tdSql.checkData(0, 4, 5 * maxRange - 1)
+        tdSql.checkData(0, 5, last_ts4)  
+        tdSql.checkData(0, 6, 5 * maxRange - 1) 
+
+        tdSql.execute("drop table if exists last_test_last_row_model.test_t4 ;")
+        tdSql.execute("drop table if exists last_test_last_row_model.test_t3 ;")
+        tdSql.execute("drop table if exists last_test_last_row_model.test_t2 ;")
+        tdSql.execute("drop table if exists last_test_last_row_model.test_t1 ;")
+        tdSql.execute("drop stable if exists last_test_last_row_model.st;")
+        tdSql.execute("drop database if exists last_test_last_row_model;")
+
+    def both_model_test(self):
+        tdSql.execute("create database last_test_both_model cachemodel 'both';")
+        tdSql.execute("use last_test_both_model;")
+        tdSql.execute("create stable last_test_both_model.st(ts timestamp, id int) tags(tid int);")
+        tdSql.execute("create table last_test_both_model.test_t1 using last_test_both_model.st tags(1);")
+        tdSql.execute("create table last_test_both_model.test_t2 using last_test_both_model.st tags(2);")
+        tdSql.execute("create table last_test_both_model.test_t3 using last_test_both_model.st tags(3);")
+        tdSql.execute("create table last_test_both_model.test_t4 using last_test_both_model.st tags(4);")
+
+        maxRange = 100
+        # 2023-11-13 00:00:00.000
+        startTs = 1699804800000
+        for i in range(maxRange):
+            insertSqlString = "insert into last_test_both_model.test_t1 values(%d, %d);" % (startTs + i, i)
+            tdSql.execute(insertSqlString)
+        
+        last_ts = startTs + maxRange
+        tdSql.execute("insert into last_test_both_model.test_t1 (ts) values(%d)" % (last_ts))
+        sql = f'select last_row(ts), last(*)  from last_test_both_model.test_t1;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts)     
+        tdSql.checkData(0, 1, last_ts)     
+        tdSql.checkData(0, 2, maxRange - 1)  
+
+        explain_res = self.explain_sql(sql)
+        self.check_explain_res_has_row("Last Row Scan", explain_res, sql)
+        self.check_explain_res_no_row("Table Scan", explain_res, sql)
+        
+        sql = f'select last_row(ts), last(ts), last_row(id), last(id) from last_test_both_model.test_t1;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts)     
+        tdSql.checkData(0, 1, last_ts)  
+        tdSql.checkData(0, 2, None)    
+        tdSql.checkData(0, 3, maxRange - 1)  
+
+        explain_res = self.explain_sql(sql)
+        self.check_explain_res_has_row("Last Row Scan", explain_res, sql)
+        self.check_explain_res_no_row("Table Scan", explain_res, sql)
+
+        sql = f'select last(*), last_row(ts), count(*) from last_test_both_model.test_t1;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts)     
+        tdSql.checkData(0, 1, maxRange - 1)  
+        tdSql.checkData(0, 2, last_ts)    
+        tdSql.checkData(0, 3, maxRange + 1)
+
+        explain_res = self.explain_sql(sql)
+        self.check_explain_res_has_row("Last Row Scan", explain_res, sql)
+
+        sql = f'select last_row(ts), last(ts), count(*) , last_row(id), last(id), last(*) from last_test_both_model.test_t1;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts)     
+        tdSql.checkData(0, 1, last_ts)  
+        tdSql.checkData(0, 2, maxRange + 1) 
+        tdSql.checkData(0, 3, None)    
+        tdSql.checkData(0, 4, maxRange - 1)
+        tdSql.checkData(0, 5, last_ts)  
+        tdSql.checkData(0, 6, maxRange - 1)  
+
+        tdSql.error(f'select last(*), last_row(ts), ts from last_test_both_model.test_t1;')
+
+        startTs2 = startTs + 86400000
+        for i in range(maxRange):
+            i = i + 2 * maxRange
+            insertSqlString = "insert into last_test_both_model.test_t2 values(%d, %d);" % (startTs2 + i, i)
+            tdSql.execute(insertSqlString)
+        last_ts2 = startTs2 + maxRange
+
+        startTs3 = startTs + 2 * 86400000
+        for i in range(maxRange):
+            i = i + 3 * maxRange
+            insertSqlString = "insert into last_test_both_model.test_t3 values(%d, %d);" % (startTs3 + i, i)
+            tdSql.execute(insertSqlString)
+        last_ts3 = startTs3 + 4 * maxRange - 1
+
+        startTs4 = startTs + 3 * 86400000
+        for i in range(maxRange):
+            i = i + 4 * maxRange
+            insertSqlString = "insert into last_test_both_model.test_t4 values(%d, %d);" % (startTs4 + i, i)
+            tdSql.execute(insertSqlString)
+
+        last_ts4 = startTs4 + 5 * maxRange - 1
+        
+        sql = f'select last_row(ts), last(*)  from last_test_both_model.st;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts4)     
+        tdSql.checkData(0, 1, last_ts4)     
+        tdSql.checkData(0, 2, 5 * maxRange - 1)  
+
+        explain_res = self.explain_sql(sql)
+        self.check_explain_res_has_row("Last Row Scan", explain_res, sql)
+        self.check_explain_res_no_row("Table Scan", explain_res, sql)
+        
+        sql = f'select last_row(ts), last(ts), last_row(id), last(id) from last_test_both_model.st;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts4)     
+        tdSql.checkData(0, 1, last_ts4)  
+        tdSql.checkData(0, 2, 5 * maxRange - 1)    
+        tdSql.checkData(0, 3, 5 * maxRange - 1)  
+
+        explain_res = self.explain_sql(sql)
+        self.check_explain_res_has_row("Last Row Scan", explain_res, sql)
+        self.check_explain_res_no_row("Table Scan", explain_res, sql)
+
+        sql = f'select last(*), last_row(ts), count(*) from last_test_both_model.st;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts4)     
+        tdSql.checkData(0, 1, 5 * maxRange - 1)  
+        #tdSql.checkData(0, 2, last_ts4)   
+        tdSql.checkData(0, 3, 4 * maxRange + 1)
+
+        explain_res = self.explain_sql(sql)
+        self.check_explain_res_has_row("Last Row Scan", explain_res, sql)
+
+        tdSql.error(f'select last(*), last_row(ts), ts from last_test_both_model.st;')
+
+        sql = f'select last_row(ts), last(ts), count(*) , last_row(id), last(id), last(*) from last_test_both_model.st;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, last_ts4)     
+        tdSql.checkData(0, 1, last_ts4)  
+        tdSql.checkData(0, 2, 4 * maxRange + 1) 
+        tdSql.checkData(0, 3, 5 * maxRange - 1)    
+        tdSql.checkData(0, 4, 5 * maxRange - 1)
+        tdSql.checkData(0, 5, last_ts4)  
+        tdSql.checkData(0, 6, 5 * maxRange - 1) 
+
+        sql = f'select last_row(1), last(2), count(*) , last_row(id), last(id), last(*) from last_test_both_model.st;'
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, 1)     
+        tdSql.checkData(0, 1, 2)  
+        tdSql.checkData(0, 2, 4 * maxRange + 1) 
+        tdSql.checkData(0, 3, 5 * maxRange - 1)    
+        tdSql.checkData(0, 4, 5 * maxRange - 1)
+        tdSql.checkData(0, 5, last_ts4)  
+        tdSql.checkData(0, 6, 5 * maxRange - 1) 
+
+        tdSql.execute("drop table if exists last_test_both_model.test_t4 ;")
+        tdSql.execute("drop table if exists last_test_both_model.test_t3 ;")
+        tdSql.execute("drop table if exists last_test_both_model.test_t2 ;")
+        tdSql.execute("drop table if exists last_test_both_model.test_t1 ;")
+        tdSql.execute("drop stable if exists last_test_both_model.st;")
+        tdSql.execute("drop database if exists last_test_both_model;")
+
+    def run(self):
+        self.none_model_test()
+
+        self.last_value_model_test()
+
+        self.last_row_model_test()
+
+        self.both_model_test()
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
diff --git a/tests/system-test/2-query/last_cache_scan.py b/tests/system-test/2-query/last_cache_scan.py
index 3881607437..3efa8b8b74 100644
--- a/tests/system-test/2-query/last_cache_scan.py
+++ b/tests/system-test/2-query/last_cache_scan.py
@@ -250,7 +250,7 @@ class TDTestCase:
                 "last_row(c1), last(c1)",
                 "last_row(c1), c1,c3, ts"
                 ]
-        has_last_row_scan_res = [0,0,1]
+        has_last_row_scan_res = [1,1,1]
         sqls = self.format_sqls(sql_template, select_items)
         self.explain_and_check_res(sqls, has_last_row_scan_res)
         #res_expect = [None, None, [999, 999, 499, "2018-11-25 19:30:00.000"]]

From 3ebad9521f67c7c414cdb2cdac0474f4b221c611 Mon Sep 17 00:00:00 2001
From: Alex Duan <417921451@qq.com>
Date: Mon, 15 Jan 2024 15:38:54 +0800
Subject: [PATCH 34/47] fix: check run mode

---
 tests/army/community/cmdline/fullopt.py | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/tests/army/community/cmdline/fullopt.py b/tests/army/community/cmdline/fullopt.py
index 22667149ae..99c7095a38 100644
--- a/tests/army/community/cmdline/fullopt.py
+++ b/tests/army/community/cmdline/fullopt.py
@@ -75,7 +75,6 @@ class TDTestCase(TBase):
 
         # others
         etool.exeBinFile("taos", f'-N 200 -l 2048 -s "{sql}" ', wait=False)
-        etool.exeBinFile("taos", f'-n server', wait=False)
 
 
     def doTaosd(self):
@@ -86,11 +85,11 @@ class TDTestCase(TBase):
         # -s
         sdb = "./sdb.json"
         eos.delFile(sdb)
-        etool.runBinFile("taosd", f"-s -c {cfg}")
-        self.checkFileExist(sdb)
+        etool.exeBinFile("taosd", f"-s -c {cfg}")
+        
 
         # -C
-        etool.runBinFile("taosd", "-C")
+        etool.exeBinFile("taosd", "-C")
         # -k 
         rets = etool.runBinFile("taosd", "-C")
         self.checkListNotEmpty(rets)

From 8d24a340157dd26466785ffb25a87bc2a2d9f664 Mon Sep 17 00:00:00 2001
From: Yihao Deng <luomoxyz@126.com>
Date: Mon, 15 Jan 2024 07:46:30 +0000
Subject: [PATCH 35/47] add hard link

---
 include/os/osFile.h                           |  2 +
 source/libs/stream/src/streamBackendRocksdb.c | 95 ++++++++++++++++++-
 source/os/src/osFile.c                        | 46 +++++----
 3 files changed, 126 insertions(+), 17 deletions(-)

diff --git a/include/os/osFile.h b/include/os/osFile.h
index 503535a454..4d760a791f 100644
--- a/include/os/osFile.h
+++ b/include/os/osFile.h
@@ -117,6 +117,8 @@ int32_t taosCompressFile(char *srcFileName, char *destFileName);
 
 int32_t taosSetFileHandlesLimit();
 
+int32_t taosLinkFile(char *src, char *dst);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/libs/stream/src/streamBackendRocksdb.c b/source/libs/stream/src/streamBackendRocksdb.c
index 4b2a9e4a65..6b1bd759da 100644
--- a/source/libs/stream/src/streamBackendRocksdb.c
+++ b/source/libs/stream/src/streamBackendRocksdb.c
@@ -382,6 +382,99 @@ int32_t rebuildFromRemoteChkp(char* key, char* chkpPath, int64_t chkpId, char* d
   return -1;
 }
 
+int32_t copyFiles_create(char* src, char* dst, int8_t type) {
+  // create and copy file
+  return taosCopyFile(src, dst);
+}
+int32_t copyFiles_hardlink(char* src, char* dst, int8_t type) {
+  // same fs and hard link
+  return taosLinkFile(src, dst);
+}
+
+int32_t backendFileCopyFilesImpl(char* src, char* dst) {
+  int32_t code = 0;
+  int32_t sLen = strlen(src);
+  int32_t dLen = strlen(dst);
+  char*   srcName = taosMemoryCalloc(1, sLen + 64);
+  char*   dstName = taosMemoryCalloc(1, dLen + 64);
+  // copy file to dst
+
+  TdDirPtr pDir = taosOpenDir(src);
+  if (pDir == NULL) {
+    taosMemoryFree(srcName);
+    taosMemoryFree(dstName);
+    return -1;
+  }
+  TdDirEntryPtr de = NULL;
+  while ((de = taosReadDir(pDir)) != NULL) {
+    char* name = taosGetDirEntryName(de);
+    if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) continue;
+
+    sprintf(srcName, "%s%s%s", src, TD_DIRSEP, name);
+    sprintf(dstName, "%s%s%s", dst, TD_DIRSEP, name);
+
+    if (strcmp(name, "CURRENT") == 0) {
+      code = copyFiles_create(srcName, dstName, 0);
+    } else {
+      code = copyFiles_hardlink(srcName, dstName, 0);
+    }
+    if (code != 0) {
+      goto _ERROR;
+    }
+    memset(srcName, 0, sLen + 64);
+    memset(dstName, 0, dLen + 64);
+  }
+
+  taosCloseDir(&pDir);
+  return 0;
+_ERROR:
+  taosMemoryFreeClear(srcName);
+  taosMemoryFreeClear(dstName);
+  taosCloseDir(&pDir);
+  return -1;
+}
+int32_t backendCopyFiles(char* src, char* dst) {
+  return backendFileCopyFilesImpl(src, dst);
+  // // opt later, just hard link
+  // int32_t sLen = strlen(src);
+  // int32_t dLen = strlen(dst);
+  // char*   srcName = taosMemoryCalloc(1, sLen + 64);
+  // char*   dstName = taosMemoryCalloc(1, dLen + 64);
+
+  // TdDirPtr pDir = taosOpenDir(src);
+  // if (pDir == NULL) {
+  //   taosMemoryFree(srcName);
+  //   taosMemoryFree(dstName);
+  //   return -1;
+  // }
+
+  // TdDirEntryPtr de = NULL;
+  // while ((de = taosReadDir(pDir)) != NULL) {
+  //   char* name = taosGetDirEntryName(de);
+  //   if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) continue;
+
+  //   sprintf(srcName, "%s%s%s", src, TD_DIRSEP, name);
+  //   sprintf(dstName, "%s%s%s", dst, TD_DIRSEP, name);
+  //   // if (!taosDirEntryIsDir(de)) {
+  //   //   // code = taosCopyFile(srcName, dstName);
+  //   //   if (code == -1) {
+  //   //     goto _err;
+  //   //   }
+  //   // }
+  //   return backendFileCopyFilesImpl(src, dst);
+
+  //   memset(srcName, 0, sLen + 64);
+  //   memset(dstName, 0, dLen + 64);
+  // }
+
+  // _err:
+  //   taosMemoryFreeClear(srcName);
+  //   taosMemoryFreeClear(dstName);
+  //   taosCloseDir(&pDir);
+  //   return code >= 0 ? 0 : -1;
+
+  // return 0;
+}
 int32_t rebuildFromLocalChkp(char* key, char* chkpPath, int64_t chkpId, char* defaultPath) {
   int32_t code = -1;
   int32_t len = strlen(defaultPath) + 32;
@@ -396,7 +489,7 @@ int32_t rebuildFromLocalChkp(char* key, char* chkpPath, int64_t chkpId, char* de
       taosRemoveDir(tmp);
     }
     taosMkDir(defaultPath);
-    code = copyFiles(chkpPath, defaultPath);
+    code = backendCopyFiles(chkpPath, defaultPath);
     if (code != 0) {
       stError("failed to restart stream backend from %s, reason: %s", chkpPath, tstrerror(TAOS_SYSTEM_ERROR(errno)));
     } else {
diff --git a/source/os/src/osFile.c b/source/os/src/osFile.c
index 39de117339..74ce5e5aa6 100644
--- a/source/os/src/osFile.c
+++ b/source/os/src/osFile.c
@@ -18,8 +18,8 @@
 #include "zlib.h"
 
 #ifdef WINDOWS
-#include <io.h>
 #include <WinBase.h>
+#include <io.h>
 #include <ktmw32.h>
 #include <windows.h>
 #define F_OK 0
@@ -50,7 +50,7 @@ typedef struct TdFile {
   TdThreadRwlock rwlock;
   int            refId;
   HANDLE         hFile;
-  FILE*          fp;
+  FILE          *fp;
   int32_t        tdFileOptions;
 } TdFile;
 #else
@@ -230,7 +230,7 @@ int32_t taosStatFile(const char *path, int64_t *size, int32_t *mtime, int32_t *a
   int32_t         code = _stati64(path, &fileStat);
 #else
   struct stat fileStat;
-  int32_t code = stat(path, &fileStat);
+  int32_t     code = stat(path, &fileStat);
 #endif
   if (code < 0) {
     return code;
@@ -274,7 +274,7 @@ int32_t taosDevInoFile(TdFilePtr pFile, int64_t *stDev, int64_t *stIno) {
     return -1;
   }
   struct stat fileStat;
-  int32_t code = fstat(pFile->fd, &fileStat);
+  int32_t     code = fstat(pFile->fd, &fileStat);
   if (code < 0) {
     printf("taosFStatFile run fstat fail.");
     return code;
@@ -374,7 +374,7 @@ int64_t taosReadFile(TdFilePtr pFile, void *buf, int64_t count) {
   DWORD bytesRead;
   if (!ReadFile(pFile->hFile, buf, count, &bytesRead, NULL)) {
     bytesRead = -1;
-  } 
+  }
 #if FILE_WITH_LOCK
   taosThreadRwlockUnlock(&(pFile->rwlock));
 #endif
@@ -389,7 +389,7 @@ int64_t taosWriteFile(TdFilePtr pFile, const void *buf, int64_t count) {
   taosThreadRwlockWrlock(&(pFile->rwlock));
 #endif
 
-  DWORD   bytesWritten;
+  DWORD bytesWritten;
   if (!WriteFile(pFile->hFile, buf, count, &bytesWritten, NULL)) {
     bytesWritten = -1;
   }
@@ -666,7 +666,7 @@ int64_t taosReadFile(TdFilePtr pFile, void *buf, int64_t count) {
   }
   int64_t leftbytes = count;
   int64_t readbytes;
-  char *  tbuf = (char *)buf;
+  char   *tbuf = (char *)buf;
 
   while (leftbytes > 0) {
 #ifdef WINDOWS
@@ -716,7 +716,7 @@ int64_t taosWriteFile(TdFilePtr pFile, const void *buf, int64_t count) {
 
   int64_t nleft = count;
   int64_t nwritten = 0;
-  char *  tbuf = (char *)buf;
+  char   *tbuf = (char *)buf;
 
   while (nleft > 0) {
     nwritten = write(pFile->fd, (void *)tbuf, (uint32_t)nleft);
@@ -1028,7 +1028,7 @@ int64_t taosFSendFile(TdFilePtr pFileOut, TdFilePtr pFileIn, int64_t *offset, in
 #endif
 }
 
-#endif   // WINDOWS
+#endif  // WINDOWS
 
 TdFilePtr taosOpenFile(const char *path, int32_t tdFileOptions) {
   FILE *fp = NULL;
@@ -1056,7 +1056,7 @@ TdFilePtr taosOpenFile(const char *path, int32_t tdFileOptions) {
     if (hFile != NULL) CloseHandle(hFile);
 #else
     if (fd >= 0) close(fd);
-#endif   
+#endif
     if (fp != NULL) fclose(fp);
     return NULL;
   }
@@ -1067,7 +1067,7 @@ TdFilePtr taosOpenFile(const char *path, int32_t tdFileOptions) {
   pFile->fp = fp;
   pFile->refId = 0;
 
-  #ifdef WINDOWS
+#ifdef WINDOWS
   pFile->hFile = hFile;
   pFile->tdFileOptions = tdFileOptions;
   // do nothing, since the property of pmode is set with _O_TEMPORARY; the OS will recycle
@@ -1137,7 +1137,7 @@ int64_t taosPReadFile(TdFilePtr pFile, void *buf, int64_t count, int64_t offset)
 #endif
     return -1;
   }
-  DWORD     ret = 0;
+  DWORD      ret = 0;
   OVERLAPPED ol = {0};
   ol.OffsetHigh = (uint32_t)((offset & 0xFFFFFFFF00000000LL) >> 0x20);
   ol.Offset = (uint32_t)(offset & 0xFFFFFFFFLL);
@@ -1179,7 +1179,7 @@ int32_t taosFsyncFile(TdFilePtr pFile) {
   if (pFile->hFile != NULL) {
     if (pFile->tdFileOptions & TD_FILE_WRITE_THROUGH) {
       return 0;
-    } 
+    }
     return !FlushFileBuffers(pFile->hFile);
 #else
   if (pFile->fd >= 0) {
@@ -1204,7 +1204,7 @@ bool taosValidFile(TdFilePtr pFile) {
   return pFile != NULL && pFile->hFile != NULL;
 #else
   return pFile != NULL && pFile->fd > 0;
-#endif   
+#endif
 }
 
 int32_t taosUmaskFile(int32_t maskVal) {
@@ -1249,7 +1249,7 @@ int64_t taosGetLineFile(TdFilePtr pFile, char **__restrict ptrBuf) {
     }
 
     bufferSize += 512;
-    void* newBuf = taosMemoryRealloc(*ptrBuf, bufferSize);
+    void *newBuf = taosMemoryRealloc(*ptrBuf, bufferSize);
     if (newBuf == NULL) {
       taosMemoryFreeClear(*ptrBuf);
       return -1;
@@ -1363,7 +1363,7 @@ int32_t taosCompressFile(char *srcFileName, char *destFileName) {
 
 cmp_end:
   if (pFile) {
-     taosCloseFile(&pFile);
+    taosCloseFile(&pFile);
   }
   if (pSrcFile) {
     taosCloseFile(&pSrcFile);
@@ -1386,3 +1386,17 @@ int32_t taosSetFileHandlesLimit() {
 #endif
   return 0;
 }
+
+int32_t taosLinkFile(char *src, char *dst) {
+#ifdef WINDOWS
+  // don nothing
+  return 0;
+#endif
+  if (link(src, dst) != 0) {
+    if (errno == EXDEV || errno == ENOTSUP) {
+      return -1;
+    }
+    return errno;
+  }
+  return 0;
+}

From 43081b540b1c59dac2d4568235d40c79657ffdf8 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Mon, 15 Jan 2024 16:16:28 +0800
Subject: [PATCH 36/47] fix(stream): reset restart counter to be 0 if all tasks
 are ready.

---
 include/libs/stream/tstream.h              |  1 +
 source/dnode/vnode/src/tqCommon/tqCommon.c | 16 ++++++++++++----
 source/libs/stream/src/streamMeta.c        | 17 +++++++++++++++++
 3 files changed, 30 insertions(+), 4 deletions(-)

diff --git a/include/libs/stream/tstream.h b/include/libs/stream/tstream.h
index 32d8ce72f0..5bdf3ab75f 100644
--- a/include/libs/stream/tstream.h
+++ b/include/libs/stream/tstream.h
@@ -885,6 +885,7 @@ int32_t      streamMetaLoadAllTasks(SStreamMeta* pMeta);
 int32_t      streamMetaStartAllTasks(SStreamMeta* pMeta);
 int32_t      streamMetaStopAllTasks(SStreamMeta* pMeta);
 int32_t      streamMetaStartOneTask(SStreamMeta* pMeta, int64_t streamId, int32_t taskId);
+bool         streamMetaAllTasksReady(const SStreamMeta* pMeta);
 
 // checkpoint
 int32_t streamProcessCheckpointSourceReq(SStreamTask* pTask, SStreamCheckpointSourceReq* pReq);
diff --git a/source/dnode/vnode/src/tqCommon/tqCommon.c b/source/dnode/vnode/src/tqCommon/tqCommon.c
index eb5efe07f2..e2dc9fa679 100644
--- a/source/dnode/vnode/src/tqCommon/tqCommon.c
+++ b/source/dnode/vnode/src/tqCommon/tqCommon.c
@@ -833,23 +833,31 @@ int32_t tqStreamTaskProcessRunReq(SStreamMeta* pMeta, SRpcMsg* pMsg, bool isLead
 
 int32_t tqStartTaskCompleteCallback(SStreamMeta* pMeta) {
   STaskStartInfo* pStartInfo = &pMeta->startInfo;
-  int32_t vgId = pMeta->vgId;
+  int32_t         vgId = pMeta->vgId;
 
   streamMetaWLock(pMeta);
   if (pStartInfo->taskStarting == 1) {
     tqDebug("vgId:%d already in start tasks procedure in other thread, restartCounter:%d, do nothing", vgId,
             pMeta->startInfo.restartCount);
   } else {  // not in starting procedure
-    if (pStartInfo->restartCount > 0) {
+    bool allReady = streamMetaAllTasksReady(pMeta);
+
+    if ((pStartInfo->restartCount > 0) && (!allReady)) {
+      // if all tasks are ready now, do NOT restart again, and reset the value of pStartInfo->restartCount
       pStartInfo->restartCount -= 1;
       tqDebug("vgId:%d role:%d need to restart all tasks again, restartCounter:%d", vgId, pMeta->role,
               pStartInfo->restartCount);
-
       streamMetaWUnLock(pMeta);
+
       restartStreamTasks(pMeta, (pMeta->role == NODE_ROLE_LEADER));
       return TSDB_CODE_SUCCESS;
     } else {
-      tqDebug("vgId:%d start all tasks completed in callbackFn", pMeta->vgId);
+      if (pStartInfo->restartCount == 0) {
+        tqDebug("vgId:%d start all tasks completed in callbackFn, restartCount is 0", pMeta->vgId);
+      } else if (allReady) {
+        pStartInfo->restartCount = 0;
+        tqDebug("vgId:%d all tasks are ready, reset restartCounter 0, not restart tasks", vgId);
+      }
     }
   }
 
diff --git a/source/libs/stream/src/streamMeta.c b/source/libs/stream/src/streamMeta.c
index 20e7be0509..bb5cb6e832 100644
--- a/source/libs/stream/src/streamMeta.c
+++ b/source/libs/stream/src/streamMeta.c
@@ -1518,6 +1518,23 @@ int32_t streamMetaStopAllTasks(SStreamMeta* pMeta) {
   return 0;
 }
 
+bool streamMetaAllTasksReady(const SStreamMeta* pMeta) {
+  int32_t num = taosArrayGetSize(pMeta->pTaskList);
+  for(int32_t i = 0; i < num; ++i) {
+    STaskId* pTaskId = taosArrayGet(pMeta->pTaskList, i);
+    SStreamTask** ppTask = taosHashGet(pMeta->pTasksMap, pTaskId, sizeof(*pTaskId));
+    if (ppTask == NULL) {
+      continue;
+    }
+
+    if ((*ppTask)->status.downstreamReady == 0) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
 int32_t streamMetaStartOneTask(SStreamMeta* pMeta, int64_t streamId, int32_t taskId) {
   int32_t vgId = pMeta->vgId;
   stInfo("vgId:%d start to task:0x%x by checking downstream status", vgId, taskId);

From f55c93b9693c485963cb039cd879d1ecc5f13399 Mon Sep 17 00:00:00 2001
From: Yihao Deng <luomoxyz@126.com>
Date: Mon, 15 Jan 2024 08:27:35 +0000
Subject: [PATCH 37/47] add hard link

---
 source/libs/stream/src/streamBackendRocksdb.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/source/libs/stream/src/streamBackendRocksdb.c b/source/libs/stream/src/streamBackendRocksdb.c
index 6b1bd759da..9c51d57f92 100644
--- a/source/libs/stream/src/streamBackendRocksdb.c
+++ b/source/libs/stream/src/streamBackendRocksdb.c
@@ -419,6 +419,7 @@ int32_t backendFileCopyFilesImpl(char* src, char* dst) {
       code = copyFiles_hardlink(srcName, dstName, 0);
     }
     if (code != 0) {
+      stError("failed to copy file, reason: %s", tstrerror(TAOS_SYSTEM_ERROR(code)));
       goto _ERROR;
     }
     memset(srcName, 0, sLen + 64);

From 8a2e431094cbe4648887756a32f00a36f2bd65ff Mon Sep 17 00:00:00 2001
From: Yihao Deng <luomoxyz@126.com>
Date: Mon, 15 Jan 2024 09:03:56 +0000
Subject: [PATCH 38/47] add hard link

---
 source/libs/stream/src/streamBackendRocksdb.c | 39 ++++++++++++++-----
 1 file changed, 30 insertions(+), 9 deletions(-)

diff --git a/source/libs/stream/src/streamBackendRocksdb.c b/source/libs/stream/src/streamBackendRocksdb.c
index 9c51d57f92..8175b946cc 100644
--- a/source/libs/stream/src/streamBackendRocksdb.c
+++ b/source/libs/stream/src/streamBackendRocksdb.c
@@ -41,6 +41,8 @@ void            destroyRocksdbCfInst(RocksdbCfInst* inst);
 int32_t         getCfIdx(const char* cfName);
 STaskDbWrapper* taskDbOpenImpl(char* key, char* statePath, char* dbPath);
 
+int32_t backendCopyFiles(char* src, char* dst);
+
 void        destroyCompactFilteFactory(void* arg);
 void        destroyCompactFilte(void* arg);
 const char* compactFilteFactoryName(void* arg);
@@ -218,7 +220,7 @@ int32_t rebuildDirFromCheckpoint(const char* path, int64_t chkpId, char** dst) {
         taosRemoveDir(state);
       }
       taosMkDir(state);
-      code = copyFiles(chkp, state);
+      code = backendCopyFiles(chkp, state);
       stInfo("copy snap file from %s to %s", chkp, state);
       if (code != 0) {
         stError("failed to restart stream backend from %s, reason: %s", chkp, tstrerror(TAOS_SYSTEM_ERROR(errno)));
@@ -334,7 +336,7 @@ int32_t rebuildFromRemoteChkp_rsync(char* key, char* chkpPath, int64_t chkpId, c
   if (code != 0) {
     return code;
   }
-  code = copyFiles(chkpPath, defaultPath);
+  code = backendCopyFiles(chkpPath, defaultPath);
 
   return code;
 }
@@ -359,7 +361,7 @@ int32_t rebuildFromRemoteChkp_s3(char* key, char* chkpPath, int64_t chkpId, char
 
   if (code == 0) {
     taosMkDir(defaultPath);
-    code = copyFiles(chkpPath, defaultPath);
+    code = backendCopyFiles(chkpPath, defaultPath);
   }
 
   if (code != 0) {
@@ -384,7 +386,13 @@ int32_t rebuildFromRemoteChkp(char* key, char* chkpPath, int64_t chkpId, char* d
 
 int32_t copyFiles_create(char* src, char* dst, int8_t type) {
   // create and copy file
-  return taosCopyFile(src, dst);
+  int32_t err = taosCopyFile(src, dst);
+
+  if (errno == EXDEV || errno == ENOTSUP) {
+    errno = 0;
+    return 0;
+  }
+  return 0;
 }
 int32_t copyFiles_hardlink(char* src, char* dst, int8_t type) {
   // same fs and hard link
@@ -392,6 +400,9 @@ int32_t copyFiles_hardlink(char* src, char* dst, int8_t type) {
 }
 
 int32_t backendFileCopyFilesImpl(char* src, char* dst) {
+  const char* current = "CURRENT";
+  size_t      currLen = strlen(current);
+
   int32_t code = 0;
   int32_t sLen = strlen(src);
   int32_t dLen = strlen(dst);
@@ -403,8 +414,10 @@ int32_t backendFileCopyFilesImpl(char* src, char* dst) {
   if (pDir == NULL) {
     taosMemoryFree(srcName);
     taosMemoryFree(dstName);
+    errno = 0;
     return -1;
   }
+
   TdDirEntryPtr de = NULL;
   while ((de = taosReadDir(pDir)) != NULL) {
     char* name = taosGetDirEntryName(de);
@@ -413,25 +426,33 @@ int32_t backendFileCopyFilesImpl(char* src, char* dst) {
     sprintf(srcName, "%s%s%s", src, TD_DIRSEP, name);
     sprintf(dstName, "%s%s%s", dst, TD_DIRSEP, name);
 
-    if (strcmp(name, "CURRENT") == 0) {
+    if (strncmp(name, current, strlen(name) <= currLen ? strlen(name) : currLen) == 0) {
       code = copyFiles_create(srcName, dstName, 0);
+      if (code != 0) {
+        stError("failed to copy file, detail: %s to %s reason: %s", srcName, dstName,
+                tstrerror(TAOS_SYSTEM_ERROR(code)));
+        goto _ERROR;
+      }
     } else {
       code = copyFiles_hardlink(srcName, dstName, 0);
-    }
-    if (code != 0) {
-      stError("failed to copy file, reason: %s", tstrerror(TAOS_SYSTEM_ERROR(code)));
-      goto _ERROR;
+      if (code != 0) {
+        stError("failed to hard line file, detail: %s to %s, reason: %s", srcName, dstName,
+                tstrerror(TAOS_SYSTEM_ERROR(code)));
+        goto _ERROR;
+      }
     }
     memset(srcName, 0, sLen + 64);
     memset(dstName, 0, dLen + 64);
   }
 
   taosCloseDir(&pDir);
+  errno = 0;
   return 0;
 _ERROR:
   taosMemoryFreeClear(srcName);
   taosMemoryFreeClear(dstName);
   taosCloseDir(&pDir);
+  errno = 0;
   return -1;
 }
 int32_t backendCopyFiles(char* src, char* dst) {

From 2e543d950ab62caca9827ab7c8cf33cc551e914e Mon Sep 17 00:00:00 2001
From: 54liuyao <54liuyao>
Date: Mon, 15 Jan 2024 17:36:23 +0800
Subject: [PATCH 39/47] set delete for session op

---
 .../libs/executor/src/streamtimewindowoperator.c | 16 +++++++++-------
 source/libs/stream/src/tstreamFileState.c        |  3 +--
 2 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/source/libs/executor/src/streamtimewindowoperator.c b/source/libs/executor/src/streamtimewindowoperator.c
index 22339aa384..02f8b90864 100644
--- a/source/libs/executor/src/streamtimewindowoperator.c
+++ b/source/libs/executor/src/streamtimewindowoperator.c
@@ -2893,6 +2893,14 @@ SOperatorInfo* createStreamSessionAggOperatorInfo(SOperatorInfo* downstream, SPh
     goto _error;
   }
 
+  pInfo->twAggSup = (STimeWindowAggSupp){
+      .waterMark = pSessionNode->window.watermark,
+      .calTrigger = pSessionNode->window.triggerType,
+      .maxTs = INT64_MIN,
+      .minTs = INT64_MAX,
+      .deleteMark = getDeleteMark(&pSessionNode->window, 0),
+  };
+
   code = initStreamAggSupporter(&pInfo->streamAggSup, pExpSup, numOfCols, pSessionNode->gap,
                                 pTaskInfo->streamInfo.pState, 0, 0, &pTaskInfo->storageAPI.stateStore, pHandle,
                                 &pInfo->twAggSup, GET_TASKID(pTaskInfo), &pTaskInfo->storageAPI);
@@ -2900,13 +2908,6 @@ SOperatorInfo* createStreamSessionAggOperatorInfo(SOperatorInfo* downstream, SPh
     goto _error;
   }
 
-  pInfo->twAggSup = (STimeWindowAggSupp){
-      .waterMark = pSessionNode->window.watermark,
-      .calTrigger = pSessionNode->window.triggerType,
-      .maxTs = INT64_MIN,
-      .minTs = INT64_MAX,
-  };
-
   initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window);
 
   pInfo->primaryTsIndex = ((SColumnNode*)pSessionNode->window.pTspk)->slotId;
@@ -3775,6 +3776,7 @@ SOperatorInfo* createStreamStateAggOperatorInfo(SOperatorInfo* downstream, SPhys
       .calTrigger = pStateNode->window.triggerType,
       .maxTs = INT64_MIN,
       .minTs = INT64_MAX,
+      .deleteMark = getDeleteMark(&pStateNode->window, 0),
   };
 
   initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window);
diff --git a/source/libs/stream/src/tstreamFileState.c b/source/libs/stream/src/tstreamFileState.c
index aac78cf03b..fb5e02c827 100644
--- a/source/libs/stream/src/tstreamFileState.c
+++ b/source/libs/stream/src/tstreamFileState.c
@@ -527,8 +527,7 @@ bool hasRowBuff(SStreamFileState* pFileState, void* pKey, int32_t keyLen) {
 }
 
 SStreamSnapshot* getSnapshot(SStreamFileState* pFileState) {
-  int64_t mark = (INT64_MIN + pFileState->deleteMark >= pFileState->maxTs) ? INT64_MIN
-                                                                           : pFileState->maxTs - pFileState->deleteMark;
+  int64_t mark = (pFileState->deleteMark == INT64_MAX) ? INT64_MIN : pFileState->maxTs - pFileState->deleteMark;
   clearExpiredRowBuff(pFileState, mark, false);
   return pFileState->usedBuffs;
 }

From cacbb4e3692dae65fa880eddd015f385aa4d9aab Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Mon, 15 Jan 2024 17:40:35 +0800
Subject: [PATCH 40/47] fix(stream): save the checkpoint info for sink tasks.

---
 source/libs/stream/src/streamCheckpoint.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/libs/stream/src/streamCheckpoint.c b/source/libs/stream/src/streamCheckpoint.c
index cb3f7a3504..60e4d74b43 100644
--- a/source/libs/stream/src/streamCheckpoint.c
+++ b/source/libs/stream/src/streamCheckpoint.c
@@ -330,7 +330,7 @@ int32_t streamSaveTaskCheckpointInfo(SStreamTask* p, int64_t checkpointId) {
           vgId, id, p->info.taskLevel, checkpointId, pCKInfo->checkpointVer, pCKInfo->nextProcessVer, pStatus->name);
 
   // save the task if not sink task
-  if (p->info.taskLevel < TASK_LEVEL__SINK) {
+  if (p->info.taskLevel <= TASK_LEVEL__SINK) {
     streamMetaWLock(pMeta);
 
     code = streamMetaSaveTask(pMeta, p);
@@ -455,7 +455,7 @@ int32_t streamTaskBuildCheckpoint(SStreamTask* pTask) {
 
   // sink task do not need to save the status, and generated the checkpoint
   if (pTask->info.taskLevel != TASK_LEVEL__SINK) {
-    stDebug("s-task:%s level:%d start gen checkpoint", id, pTask->info.taskLevel);
+    stDebug("s-task:%s level:%d start gen checkpoint, checkpointId:%" PRId64, id, pTask->info.taskLevel, ckId);
     code = streamBackendDoCheckpoint(pTask->pBackend, ckId);
     if (code != TSDB_CODE_SUCCESS) {
       stError("s-task:%s gen checkpoint:%" PRId64 " failed, code:%s", id, ckId, tstrerror(terrno));

From fafb5b1f03d9cfba9be163579a15b8900978820e Mon Sep 17 00:00:00 2001
From: fullhonest <fullhon@sohu.com>
Date: Mon, 15 Jan 2024 18:29:41 +0800
Subject: [PATCH 41/47] Fix TD-28018: last row num error where partition by
 null column

---
 source/dnode/vnode/src/tsdb/tsdbCacheRead.c  | 5 ++++-
 tests/system-test/2-query/last_cache_scan.py | 2 +-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/source/dnode/vnode/src/tsdb/tsdbCacheRead.c b/source/dnode/vnode/src/tsdb/tsdbCacheRead.c
index f668ea5f72..7c4df77a17 100644
--- a/source/dnode/vnode/src/tsdb/tsdbCacheRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbCacheRead.c
@@ -391,7 +391,10 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
               if (!COL_VAL_IS_VALUE(&p->colVal)) {
                 hasNotNullRow = false;
               }
-              continue;
+              // For all of cols is null, the last null col of last table will be save 
+              if (i != pr->numOfTables - 1 || k != pr->numOfCols - 1 || hasRes) {
+                continue;
+              }
             }
 
             hasRes = true;
diff --git a/tests/system-test/2-query/last_cache_scan.py b/tests/system-test/2-query/last_cache_scan.py
index 3881607437..3ee0dc2d2a 100644
--- a/tests/system-test/2-query/last_cache_scan.py
+++ b/tests/system-test/2-query/last_cache_scan.py
@@ -387,7 +387,7 @@ class TDTestCase:
         tdSql.query('select last(c1) from meters partition by t1')
         print(str(tdSql.queryResult))
         tdSql.checkCols(1)
-        tdSql.checkRows(2)
+        tdSql.checkRows(5)
         p = subprocess.run(["taos", '-s', "alter table test.meters drop column c1; alter table test.meters add column c2 int"])
         p.check_returncode()
         tdSql.query_success_failed('select last(c1) from meters partition by t1',  queryTimes=10, expectErrInfo="Invalid column name: c1")

From 3a1d8f2e8f664ed9f4e9f4c061993559d9d51aa4 Mon Sep 17 00:00:00 2001
From: chenhaoran <haoran920c@163.com>
Date: Mon, 15 Jan 2024 19:14:24 +0800
Subject: [PATCH 42/47] test: replace timestamp now with var ts

---
 tests/parallel_test/cases.task                |  2 +-
 tests/script/sh/checkAsan.sh                  | 55 +++++++-------
 .../2-query/nestedQueryInterval.py            | 72 +++++++++----------
 3 files changed, 63 insertions(+), 66 deletions(-)

diff --git a/tests/parallel_test/cases.task b/tests/parallel_test/cases.task
index 63745f75ab..7a34e6f8e5 100644
--- a/tests/parallel_test/cases.task
+++ b/tests/parallel_test/cases.task
@@ -34,7 +34,7 @@
 ,,y,system-test,./pytest.sh python3 ./test.py -f 8-stream/pause_resume_test.py
 #,,n,system-test,python3 ./test.py -f 8-stream/vnode_restart.py -N 4
 #,,n,system-test,python3 ./test.py -f 8-stream/snode_restart.py -N 4
-#,,n,system-test,python3 ./test.py -f 8-stream/snode_restart_with_checkpoint.py -N 4
+,,n,system-test,python3 ./test.py -f 8-stream/snode_restart_with_checkpoint.py -N 4
 
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/tbname_vgroup.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/count_interval.py
diff --git a/tests/script/sh/checkAsan.sh b/tests/script/sh/checkAsan.sh
index 19057d8834..9f67d437e2 100755
--- a/tests/script/sh/checkAsan.sh
+++ b/tests/script/sh/checkAsan.sh
@@ -3,22 +3,22 @@
 set +e
 #set -x
 if [[ "$OSTYPE" == "darwin"* ]]; then
-    TD_OS="Darwin"
+  TD_OS="Darwin"
 else
-    OS=$(cat /etc/*-release | grep "^NAME=" | cut -d= -f2)
-    len=$(echo ${#OS})
-    len=$((len-2))
-    TD_OS=$(echo -ne ${OS:1:${len}} | cut -d" " -f1)
+  OS=$(cat /etc/*-release | grep "^NAME=" | cut -d= -f2)
+  len=$(echo ${#OS})
+  len=$((len - 2))
+  TD_OS=$(echo -ne ${OS:1:${len}} | cut -d" " -f1)
 fi
 
 if [[ "$TD_OS" == "Alpine" ]]; then
-    echo -e "os is Alpine,skip check Asan"
-    exit 0
+  echo -e "os is Alpine,skip check Asan"
+  exit 0
 fi
 unset LD_PRELOAD
-SCRIPT_DIR=`dirname $0`
+SCRIPT_DIR=$(dirname $0)
 cd $SCRIPT_DIR/../
-SCRIPT_DIR=`pwd`
+SCRIPT_DIR=$(pwd)
 
 IN_TDINTERNAL="community"
 if [[ "$SCRIPT_DIR" == *"$IN_TDINTERNAL"* ]]; then
@@ -27,31 +27,28 @@ else
   cd ../../
 fi
 
-TAOS_DIR=`pwd`
+TAOS_DIR=$(pwd)
 LOG_DIR=$TAOS_DIR/sim/asan
 
+error_num=$(cat ${LOG_DIR}/*.asan | grep "ERROR" | wc -l)
 
-
-error_num=`cat ${LOG_DIR}/*.asan | grep "ERROR" | wc -l`
-
-archOs=`arch`  
-if [[ $archOs =~ "aarch64" ]]; then  
-  echo "arm64 check mem leak" 
-  memory_leak=`cat ${LOG_DIR}/*.asan | grep "Direct leak" | grep -v "Direct leak of 32 byte"| wc -l`
-  memory_count=`cat ${LOG_DIR}/*.asan | grep "Direct leak of 32 byte"| wc -l`
+archOs=$(arch)
+if [[ $archOs =~ "aarch64" ]]; then
+  echo "arm64 check mem leak"
+  memory_leak=$(cat ${LOG_DIR}/*.asan | grep "Direct leak" | grep -v "Direct leak of 32 byte" | wc -l)
+  memory_count=$(cat ${LOG_DIR}/*.asan | grep "Direct leak of 32 byte" | wc -l)
 
   if [ $memory_count -eq $error_num ] && [ $memory_leak -eq 0 ]; then
     echo "reset error_num to 0, ignore: __cxa_thread_atexit_impl leak"
     error_num=0
-  fi 
+  fi
 else
   echo "os check mem leak"
-  memory_leak=`cat ${LOG_DIR}/*.asan | grep "Direct leak" | wc -l`
+  memory_leak=$(cat ${LOG_DIR}/*.asan | grep "Direct leak" | wc -l)
 fi
 
-
-indirect_leak=`cat ${LOG_DIR}/*.asan | grep "Indirect leak" | wc -l`
-python_error=`cat ${LOG_DIR}/*.info | grep -w "stack" | wc -l`
+indirect_leak=$(cat ${LOG_DIR}/*.asan | grep "Indirect leak" | wc -l)
+python_error=$(cat ${LOG_DIR}/*.info | grep -w "stack" | wc -l)
 
 # ignore
 
@@ -64,18 +61,18 @@ python_error=`cat ${LOG_DIR}/*.info | grep -w "stack" | wc -l`
 # /root/TDengine/source/libs/scalar/src/sclfunc.c:772:11: runtime error: 3.52344e+09 is outside the range of representable values of type 'int'
 # /root/TDengine/source/libs/scalar/src/sclfunc.c:753:11: runtime error: 4.75783e+11 is outside the range of representable values of type 'short int'
 
-# TD-20569  
+# TD-20569
 # /root/TDengine/source/libs/function/src/builtinsimpl.c:856:29: runtime error: signed integer overflow: 9223372036854775806 + 9223372036854775805 cannot be represented in type 'long int'
 # /root/TDengine/source/libs/scalar/src/sclvector.c:1075:66: runtime error: signed integer overflow: 9223372034707292160 + 1668838476672 cannot be represented in type 'long int'
 # /root/TDengine/source/common/src/tdataformat.c:1876:7: runtime error: signed integer overflow: 8252423483843671206 + 2406154664059062870 cannot be represented in type 'long int'
 # /home/chr/TDengine/source/libs/scalar/src/filter.c:3149:14: runtime error: applying non-zero offset 18446744073709551615 to null pointer
 
-# /home/chr/TDengine/source/libs/scalar/src/filter.c:3149:14: runtime error: applying non-zero offset 18446744073709551615 to null pointer 
+# /home/chr/TDengine/source/libs/scalar/src/filter.c:3149:14: runtime error: applying non-zero offset 18446744073709551615 to null pointer
 # /home/TDinternal/community/source/libs/scalar/src/sclvector.c:1109:66: runtime error: signed integer overflow: 9223372034707292160 + 1676867897049 cannot be represented in type 'long int'
- 
+
 #0 0x7f2d64f5a808 in __interceptor_malloc ../../../../src/libsanitizer/asan/asan_malloc_linux.cc:144
 #1 0x7f2d63fcf459 in strerror /build/glibc-SzIz7B/glibc-2.31/string/strerror.c:38
-runtime_error=`cat ${LOG_DIR}/*.asan | grep "runtime error" | grep -v "trees.c:873" | grep -v "sclfunc.c.*outside the range of representable values of type"| grep -v "signed integer overflow" |grep -v "strerror.c"| grep -v "asan_malloc_linux.cc" |grep -v "strerror.c"|wc -l`
+runtime_error=$(cat ${LOG_DIR}/*.asan | grep "runtime error" | grep -v "trees.c:873" | grep -v "sclfunc.c.*outside the range of representable values of type" | grep -v "signed integer overflow" | grep -v "strerror.c" | grep -v "asan_malloc_linux.cc" | grep -v "strerror.c" | wc -l)
 
 echo -e "\033[44;32;1m"asan error_num: $error_num"\033[0m"
 echo -e "\033[44;32;1m"asan memory_leak: $memory_leak"\033[0m"
@@ -86,10 +83,10 @@ echo -e "\033[44;32;1m"asan python error: $python_error"\033[0m"
 let "errors=$error_num+$memory_leak+$indirect_leak+$runtime_error+$python_error"
 
 if [ $errors -eq 0 ]; then
-  echo  -e "\033[44;32;1m"no asan errors"\033[0m"
+  echo -e "\033[44;32;1m"no asan errors"\033[0m"
   exit 0
 else
-  echo  -e "\033[44;31;1m"asan total errors: $errors"\033[0m"
+  echo -e "\033[44;31;1m"asan total errors: $errors"\033[0m"
   if [ $python_error -ne 0 ]; then
     cat ${LOG_DIR}/*.info
   fi
diff --git a/tests/system-test/2-query/nestedQueryInterval.py b/tests/system-test/2-query/nestedQueryInterval.py
index 07b5519432..f0cd561363 100644
--- a/tests/system-test/2-query/nestedQueryInterval.py
+++ b/tests/system-test/2-query/nestedQueryInterval.py
@@ -1314,36 +1314,36 @@ class TDTestCase:
         
         
         #stables
-        tdSql.query(f"insert into nested.stable_1 (ts,tbname,q_int) values(now,'stable_1_1',1) \
-                      nested.stable_1 (ts,tbname,q_bigint) values(now+1a,'stable_1_1',1)\
-                      nested.stable_1 (ts,tbname,q_smallint) values(now+2a,'stable_1_1',1)\
-                      nested.stable_1 (ts,tbname,q_tinyint) values(now+3a,'stable_1_1',1)\
-                      nested.stable_1 (ts,tbname,q_float) values(now+4a,'stable_1_1',1)\
-                      nested.stable_1 (ts,tbname,q_double) values(now+5a,'stable_1_1',1)\
-                      nested.stable_1 (ts,tbname,q_bool) values(now+6a,'stable_1_1',1)\
-                      nested.stable_1 (ts,tbname,q_binary) values(now+7a,'stable_1_1',1)\
-                      nested.stable_1 (ts,tbname,q_nchar) values(now+8a,'stable_1_1',1)\
-                      nested.stable_1 (ts,tbname,q_ts) values(now+9a,'stable_1_1',1)\
-                      nested.stable_null_data (ts,tbname,q_int) values(now,'stable_null_data_1',1) \
-                      nested.stable_null_data (ts,tbname,q_bigint) values(now+1a,'stable_null_data_1',1)\
-                      nested.stable_null_data (ts,tbname,q_smallint) values(now+2a,'stable_null_data_1',1)\
-                      nested.stable_null_data (ts,tbname,q_tinyint) values(now+3a,'stable_null_data_1',1)\
-                      nested.stable_null_data (ts,tbname,q_float) values(now+4a,'stable_null_data_1',1)\
-                      nested.stable_null_data (ts,tbname,q_double) values(now+5a,'stable_null_data_1',1)\
-                      nested.stable_null_data (ts,tbname,q_bool) values(now+6a,'stable_null_data_1',1)\
-                      nested.stable_null_data (ts,tbname,q_binary) values(now+7a,'stable_null_data_1',1)\
-                      nested.stable_null_data (ts,tbname,q_nchar) values(now+8a,'stable_null_data_1',1)\
-                      nested.stable_null_data (ts,tbname,q_ts) values(now+9a,'stable_null_data_1',1)\
-                      nested.stable_null_childtable (ts,tbname,q_int) values(now,'stable_null_childtable_1',1) \
-                      nested.stable_null_childtable (ts,tbname,q_bigint) values(now+1a,'stable_null_childtable_1',1)\
-                      nested.stable_null_childtable (ts,tbname,q_smallint) values(now+2a,'stable_null_childtable_1',1)\
-                      nested.stable_null_childtable (ts,tbname,q_tinyint) values(now+3a,'stable_null_childtable_1',1)\
-                      nested.stable_null_childtable (ts,tbname,q_float) values(now+4a,'stable_null_childtable_1',1)\
-                      nested.stable_null_childtable (ts,tbname,q_double) values(now+5a,'stable_null_childtable_1',1)\
-                      nested.stable_null_childtable (ts,tbname,q_bool) values(now+6a,'stable_null_childtable_1',1)\
-                      nested.stable_null_childtable (ts,tbname,q_binary) values(now+7a,'stable_null_childtable_1',1)\
-                      nested.stable_null_childtable (ts,tbname,q_nchar) values(now+8a,'stable_null_childtable_1',1)\
-                      nested.stable_null_childtable (ts,tbname,q_ts) values(now+9a,'stable_null_childtable_1',1);")
+        tdSql.query(f"insert into nested.stable_1 (ts,tbname,q_int) values({ts},'stable_1_1',1) \
+                      nested.stable_1 (ts,tbname,q_bigint) values({ts}+1a,'stable_1_1',1)\
+                      nested.stable_1 (ts,tbname,q_smallint) values({ts}+2a,'stable_1_1',1)\
+                      nested.stable_1 (ts,tbname,q_tinyint) values({ts}+3a,'stable_1_1',1)\
+                      nested.stable_1 (ts,tbname,q_float) values({ts}+4a,'stable_1_1',1)\
+                      nested.stable_1 (ts,tbname,q_double) values({ts}+5a,'stable_1_1',1)\
+                      nested.stable_1 (ts,tbname,q_bool) values({ts}+6a,'stable_1_1',1)\
+                      nested.stable_1 (ts,tbname,q_binary) values({ts}+7a,'stable_1_1',1)\
+                      nested.stable_1 (ts,tbname,q_nchar) values({ts}+8a,'stable_1_1',1)\
+                      nested.stable_1 (ts,tbname,q_ts) values({ts}+9a,'stable_1_1',1)\
+                      nested.stable_null_data (ts,tbname,q_int) values({ts},'stable_null_data_1',1) \
+                      nested.stable_null_data (ts,tbname,q_bigint) values({ts}+1a,'stable_null_data_1',1)\
+                      nested.stable_null_data (ts,tbname,q_smallint) values({ts}+2a,'stable_null_data_1',1)\
+                      nested.stable_null_data (ts,tbname,q_tinyint) values({ts}+3a,'stable_null_data_1',1)\
+                      nested.stable_null_data (ts,tbname,q_float) values({ts}+4a,'stable_null_data_1',1)\
+                      nested.stable_null_data (ts,tbname,q_double) values({ts}+5a,'stable_null_data_1',1)\
+                      nested.stable_null_data (ts,tbname,q_bool) values({ts}+6a,'stable_null_data_1',1)\
+                      nested.stable_null_data (ts,tbname,q_binary) values({ts}+7a,'stable_null_data_1',1)\
+                      nested.stable_null_data (ts,tbname,q_nchar) values({ts}+8a,'stable_null_data_1',1)\
+                      nested.stable_null_data (ts,tbname,q_ts) values({ts}+9a,'stable_null_data_1',1)\
+                      nested.stable_null_childtable (ts,tbname,q_int) values({ts},'stable_null_childtable_1',1) \
+                      nested.stable_null_childtable (ts,tbname,q_bigint) values({ts}+1a,'stable_null_childtable_1',1)\
+                      nested.stable_null_childtable (ts,tbname,q_smallint) values({ts}+2a,'stable_null_childtable_1',1)\
+                      nested.stable_null_childtable (ts,tbname,q_tinyint) values({ts}+3a,'stable_null_childtable_1',1)\
+                      nested.stable_null_childtable (ts,tbname,q_float) values({ts}+4a,'stable_null_childtable_1',1)\
+                      nested.stable_null_childtable (ts,tbname,q_double) values({ts}+5a,'stable_null_childtable_1',1)\
+                      nested.stable_null_childtable (ts,tbname,q_bool) values({ts}+6a,'stable_null_childtable_1',1)\
+                      nested.stable_null_childtable (ts,tbname,q_binary) values({ts}+7a,'stable_null_childtable_1',1)\
+                      nested.stable_null_childtable (ts,tbname,q_nchar) values({ts}+8a,'stable_null_childtable_1',1)\
+                      nested.stable_null_childtable (ts,tbname,q_ts) values({ts}+9a,'stable_null_childtable_1',1);")
         
         tdSql.query(f"select tbname,count(*) from nested.stable_1 group by tbname order by tbname;")
         tdSql.checkRows(6)
@@ -1360,9 +1360,9 @@ class TDTestCase:
         
         #test special character
 
-        tdSql.query(f"insert into nested.stable_1 (ts,tbname,q_int) values(now+10a,'!@!@$$^$',1) \
-                      nested.stable_null_data (ts,tbname,q_int) values(now+10a,'%^$^&^&',1) \
-                      nested.stable_null_childtable (ts,tbname,q_int) values(now+10a,'$^%$%^&',1);")
+        tdSql.query(f"insert into nested.stable_1 (ts,tbname,q_int) values({ts}+10a,'!@!@$$^$',1) \
+                      nested.stable_null_data (ts,tbname,q_int) values({ts}+10a,'%^$^&^&',1) \
+                      nested.stable_null_childtable (ts,tbname,q_int) values({ts}+10a,'$^%$%^&',1);")
         
         tdSql.query(f"select tbname,count(*) from nested.stable_1 group by tbname order by tbname;")
         tdSql.checkRows(7)
@@ -1468,9 +1468,9 @@ class TDTestCase:
         
         #test stable 
 
-        tdSql.error(f"insert into nested.stable_1 (ts,tbname,q_int) values(now,'stable_1',1) \
-                      nested.stable_null_data (ts,tbname,q_int) values(now,'stable_null_data',1) \
-                      nested.stable_null_childtable (ts,tbname,q_int) values(now,'stable_null_childtable',1);")
+        tdSql.error(f"insert into nested.stable_1 (ts,tbname,q_int) values({ts},'stable_1',1) \
+                      nested.stable_null_data (ts,tbname,q_int) values({ts},'stable_null_data',1) \
+                      nested.stable_null_childtable (ts,tbname,q_int) values({ts},'stable_null_childtable',1);")
         
     
     def stop(self):

From 52b9c09d6ce1106184b3fcdf6652fe98eb7b6395 Mon Sep 17 00:00:00 2001
From: Yihao Deng <luomoxyz@126.com>
Date: Mon, 15 Jan 2024 11:33:03 +0000
Subject: [PATCH 43/47] fix mem leak

---
 source/libs/stream/src/streamBackendRocksdb.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/source/libs/stream/src/streamBackendRocksdb.c b/source/libs/stream/src/streamBackendRocksdb.c
index 8175b946cc..c8f944071f 100644
--- a/source/libs/stream/src/streamBackendRocksdb.c
+++ b/source/libs/stream/src/streamBackendRocksdb.c
@@ -445,6 +445,8 @@ int32_t backendFileCopyFilesImpl(char* src, char* dst) {
     memset(dstName, 0, dLen + 64);
   }
 
+  taosMemoryFreeClear(srcName);
+  taosMemoryFreeClear(dstName);
   taosCloseDir(&pDir);
   errno = 0;
   return 0;

From 7a09ba2630f3a5cd051272aff21c50bdbf025306 Mon Sep 17 00:00:00 2001
From: Yihao Deng <luomoxyz@126.com>
Date: Mon, 15 Jan 2024 11:56:38 +0000
Subject: [PATCH 44/47] fix pause/resume error

---
 source/dnode/mnode/impl/src/mndStream.c | 189 ++++++++++++------------
 1 file changed, 95 insertions(+), 94 deletions(-)

diff --git a/source/dnode/mnode/impl/src/mndStream.c b/source/dnode/mnode/impl/src/mndStream.c
index 1c255cb7df..a9e2277264 100644
--- a/source/dnode/mnode/impl/src/mndStream.c
+++ b/source/dnode/mnode/impl/src/mndStream.c
@@ -40,7 +40,7 @@ typedef struct SNodeEntry {
 
 typedef struct SVgroupChangeInfo {
   SHashObj *pDBMap;
-  SArray *  pUpdateNodeList;  // SArray<SNodeUpdateInfo>
+  SArray   *pUpdateNodeList;  // SArray<SNodeUpdateInfo>
 } SVgroupChangeInfo;
 
 static int32_t  mndNodeCheckSentinel = 0;
@@ -89,8 +89,8 @@ static void    freeCheckpointCandEntry(void *);
 static SSdbRaw *mndStreamActionEncode(SStreamObj *pStream);
 static SSdbRow *mndStreamActionDecode(SSdbRaw *pRaw);
 
-SSdbRaw *      mndStreamSeqActionEncode(SStreamObj *pStream);
-SSdbRow *      mndStreamSeqActionDecode(SSdbRaw *pRaw);
+SSdbRaw       *mndStreamSeqActionEncode(SStreamObj *pStream);
+SSdbRow       *mndStreamSeqActionDecode(SSdbRaw *pRaw);
 static int32_t mndStreamSeqActionInsert(SSdb *pSdb, SStreamSeq *pStream);
 static int32_t mndStreamSeqActionDelete(SSdb *pSdb, SStreamSeq *pStream);
 static int32_t mndStreamSeqActionUpdate(SSdb *pSdb, SStreamSeq *pOldStream, SStreamSeq *pNewStream);
@@ -219,9 +219,9 @@ STREAM_ENCODE_OVER:
 
 SSdbRow *mndStreamActionDecode(SSdbRaw *pRaw) {
   terrno = TSDB_CODE_OUT_OF_MEMORY;
-  SSdbRow *   pRow = NULL;
+  SSdbRow    *pRow = NULL;
   SStreamObj *pStream = NULL;
-  void *      buf = NULL;
+  void       *buf = NULL;
 
   int8_t sver = 0;
   if (sdbGetRawSoftVer(pRaw, &sver) != 0) {
@@ -301,7 +301,7 @@ static int32_t mndStreamActionUpdate(SSdb *pSdb, SStreamObj *pOldStream, SStream
 }
 
 SStreamObj *mndAcquireStream(SMnode *pMnode, char *streamName) {
-  SSdb *      pSdb = pMnode->pSdb;
+  SSdb       *pSdb = pMnode->pSdb;
   SStreamObj *pStream = sdbAcquire(pSdb, SDB_STREAM, streamName);
   if (pStream == NULL && terrno == TSDB_CODE_SDB_OBJ_NOT_THERE) {
     terrno = TSDB_CODE_MND_STREAM_NOT_EXIST;
@@ -356,7 +356,7 @@ static int32_t mndCheckCreateStreamReq(SCMCreateStreamReq *pCreate) {
 }
 
 static int32_t mndBuildStreamObjFromCreateReq(SMnode *pMnode, SStreamObj *pObj, SCMCreateStreamReq *pCreate) {
-  SNode *     pAst = NULL;
+  SNode      *pAst = NULL;
   SQueryPlan *pPlan = NULL;
 
   mInfo("stream:%s to create", pCreate->name);
@@ -595,7 +595,7 @@ int32_t mndPersistDropStreamLog(SMnode *pMnode, STrans *pTrans, SStreamObj *pStr
 
 static int32_t mndCreateStbForStream(SMnode *pMnode, STrans *pTrans, const SStreamObj *pStream, const char *user) {
   SStbObj *pStb = NULL;
-  SDbObj * pDb = NULL;
+  SDbObj  *pDb = NULL;
 
   SMCreateStbReq createReq = {0};
   tstrncpy(createReq.name, pStream->targetSTbName, TSDB_TABLE_FNAME_LEN);
@@ -684,7 +684,7 @@ _OVER:
   return -1;
 }
 
-static int32_t extractNodeEpset(SMnode *pMnode, SEpSet *pEpSet, bool* hasEpset, int32_t taskId, int32_t nodeId) {
+static int32_t extractNodeEpset(SMnode *pMnode, SEpSet *pEpSet, bool *hasEpset, int32_t taskId, int32_t nodeId) {
   *hasEpset = false;
 
   pEpSet->numOfEps = 0;
@@ -773,7 +773,7 @@ int32_t mndDropStreamTasks(SMnode *pMnode, STrans *pTrans, SStreamObj *pStream)
 static int32_t checkForNumOfStreams(SMnode *pMnode, SStreamObj *pStreamObj) {  // check for number of existed tasks
   int32_t     numOfStream = 0;
   SStreamObj *pStream = NULL;
-  void *      pIter = NULL;
+  void       *pIter = NULL;
 
   while ((pIter = sdbFetch(pMnode->pSdb, SDB_STREAM, pIter, (void **)&pStream)) != NULL) {
     if (pStream->sourceDbUid == pStreamObj->sourceDbUid) {
@@ -804,7 +804,7 @@ static int32_t mndProcessCreateStreamReq(SRpcMsg *pReq) {
   SMnode     *pMnode = pReq->info.node;
   SStreamObj *pStream = NULL;
   SStreamObj  streamObj = {0};
-  char *      sql = NULL;
+  char       *sql = NULL;
   int32_t     sqlLen = 0;
   terrno = TSDB_CODE_SUCCESS;
 
@@ -931,7 +931,7 @@ static int32_t mndProcessCreateStreamReq(SRpcMsg *pReq) {
   }
 
 _OVER:
-   if (terrno != TSDB_CODE_SUCCESS && terrno != TSDB_CODE_ACTION_IN_PROGRESS) {
+  if (terrno != TSDB_CODE_SUCCESS && terrno != TSDB_CODE_ACTION_IN_PROGRESS) {
     mError("stream:%s, failed to create since %s", createStreamReq.name, terrstr());
   }
 
@@ -947,8 +947,8 @@ _OVER:
 
 int64_t mndStreamGenChkpId(SMnode *pMnode) {
   SStreamObj *pStream = NULL;
-  void *      pIter = NULL;
-  SSdb *      pSdb = pMnode->pSdb;
+  void       *pIter = NULL;
+  SSdb       *pSdb = pMnode->pSdb;
   int64_t     maxChkpId = 0;
   while (1) {
     pIter = sdbFetch(pSdb, SDB_STREAM, pIter, (void **)&pStream);
@@ -966,7 +966,7 @@ int64_t mndStreamGenChkpId(SMnode *pMnode) {
 
 static int32_t mndProcessStreamCheckpointTmr(SRpcMsg *pReq) {
   SMnode *pMnode = pReq->info.node;
-  SSdb *  pSdb = pMnode->pSdb;
+  SSdb   *pSdb = pMnode->pSdb;
   if (sdbGetSize(pSdb, SDB_STREAM) <= 0) {
     return 0;
   }
@@ -982,7 +982,7 @@ static int32_t mndProcessStreamCheckpointTmr(SRpcMsg *pReq) {
 
 static int32_t mndProcessStreamRemainChkptTmr(SRpcMsg *pReq) {
   SMnode *pMnode = pReq->info.node;
-  SSdb *  pSdb = pMnode->pSdb;
+  SSdb   *pSdb = pMnode->pSdb;
   if (sdbGetSize(pSdb, SDB_STREAM) <= 0) {
     return 0;
   }
@@ -1023,7 +1023,7 @@ static int32_t mndBuildStreamCheckpointSourceReq2(void **pBuf, int32_t *pLen, in
     return -1;
   }
 
-  void *   abuf = POINTER_SHIFT(buf, sizeof(SMsgHead));
+  void    *abuf = POINTER_SHIFT(buf, sizeof(SMsgHead));
   SEncoder encoder;
   tEncoderInit(&encoder, abuf, tlen);
   tEncodeStreamCheckpointSourceReq(&encoder, &req);
@@ -1077,7 +1077,7 @@ static int32_t mndProcessStreamCheckpointTrans(SMnode *pMnode, SStreamObj *pStre
   // 1. redo action: broadcast checkpoint source msg for all source vg
   int32_t totLevel = taosArrayGetSize(pStream->tasks);
   for (int32_t i = 0; i < totLevel; i++) {
-    SArray *     pLevel = taosArrayGetP(pStream->tasks, i);
+    SArray      *pLevel = taosArrayGetP(pStream->tasks, i);
     SStreamTask *p = taosArrayGetP(pLevel, 0);
 
     if (p->info.taskLevel == TASK_LEVEL__SOURCE) {
@@ -1091,7 +1091,7 @@ static int32_t mndProcessStreamCheckpointTrans(SMnode *pMnode, SStreamObj *pStre
           goto _ERR;
         }
 
-        void *  buf;
+        void   *buf;
         int32_t tlen;
         if (mndBuildStreamCheckpointSourceReq2(&buf, &tlen, pTask->info.nodeId, checkpointId, pTask->id.streamId,
                                                pTask->id.taskId, pTrans->id) < 0) {
@@ -1143,7 +1143,7 @@ static int32_t mndAddStreamCheckpointToTrans(STrans *pTrans, SStreamObj *pStream
 
   int32_t totLevel = taosArrayGetSize(pStream->tasks);
   for (int32_t i = 0; i < totLevel; i++) {
-    SArray *     pLevel = taosArrayGetP(pStream->tasks, i);
+    SArray      *pLevel = taosArrayGetP(pStream->tasks, i);
     SStreamTask *pTask = taosArrayGetP(pLevel, 0);
 
     if (pTask->info.taskLevel == TASK_LEVEL__SOURCE) {
@@ -1160,7 +1160,7 @@ static int32_t mndAddStreamCheckpointToTrans(STrans *pTrans, SStreamObj *pStream
           return -1;
         }
 
-        void *  buf;
+        void   *buf;
         int32_t tlen;
         if (mndBuildStreamCheckpointSourceReq2(&buf, &tlen, pTask->info.nodeId, chkptId, pTask->id.streamId,
                                                pTask->id.taskId, pTrans->id) < 0) {
@@ -1279,7 +1279,7 @@ static int32_t mndCheckNodeStatus(SMnode *pMnode) {
   }
 
   for (int32_t i = 0; i < taosArrayGetSize(execInfo.pTaskList); ++i) {
-    STaskId *         p = taosArrayGet(execInfo.pTaskList, i);
+    STaskId          *p = taosArrayGet(execInfo.pTaskList, i);
     STaskStatusEntry *pEntry = taosHashGet(execInfo.pTaskMap, p, sizeof(*p));
     if (pEntry == NULL) {
       continue;
@@ -1298,9 +1298,9 @@ static int32_t mndCheckNodeStatus(SMnode *pMnode) {
 }
 
 static int32_t mndProcessStreamDoCheckpoint(SRpcMsg *pReq) {
-  SMnode *    pMnode = pReq->info.node;
-  SSdb *      pSdb = pMnode->pSdb;
-  void *      pIter = NULL;
+  SMnode     *pMnode = pReq->info.node;
+  SSdb       *pSdb = pMnode->pSdb;
+  void       *pIter = NULL;
   SStreamObj *pStream = NULL;
   int32_t     code = 0;
 
@@ -1322,7 +1322,7 @@ static int32_t mndProcessStreamDoCheckpoint(SRpcMsg *pReq) {
 
 static int32_t mndProcessStreamCheckpointInCandid(SRpcMsg *pReq) {
   SMnode *pMnode = pReq->info.node;
-  void *  pIter = NULL;
+  void   *pIter = NULL;
   int32_t code = 0;
 
   taosThreadMutexLock(&execInfo.lock);
@@ -1368,7 +1368,7 @@ static int32_t mndProcessStreamCheckpointInCandid(SRpcMsg *pReq) {
 }
 
 static int32_t mndProcessDropStreamReq(SRpcMsg *pReq) {
-  SMnode *    pMnode = pReq->info.node;
+  SMnode     *pMnode = pReq->info.node;
   SStreamObj *pStream = NULL;
 
   SMDropStreamReq dropReq = {0};
@@ -1525,7 +1525,7 @@ int32_t mndDropStreamByDb(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {
 }
 
 int32_t mndGetNumOfStreams(SMnode *pMnode, char *dbName, int32_t *pNumOfStreams) {
-  SSdb *  pSdb = pMnode->pSdb;
+  SSdb   *pSdb = pMnode->pSdb;
   SDbObj *pDb = mndAcquireDb(pMnode, dbName);
   if (pDb == NULL) {
     terrno = TSDB_CODE_MND_DB_NOT_SELECTED;
@@ -1533,7 +1533,7 @@ int32_t mndGetNumOfStreams(SMnode *pMnode, char *dbName, int32_t *pNumOfStreams)
   }
 
   int32_t numOfStreams = 0;
-  void *  pIter = NULL;
+  void   *pIter = NULL;
   while (1) {
     SStreamObj *pStream = NULL;
     pIter = sdbFetch(pSdb, SDB_STREAM, pIter, (void **)&pStream);
@@ -1552,8 +1552,8 @@ int32_t mndGetNumOfStreams(SMnode *pMnode, char *dbName, int32_t *pNumOfStreams)
 }
 
 static int32_t mndRetrieveStream(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
-  SMnode *    pMnode = pReq->info.node;
-  SSdb *      pSdb = pMnode->pSdb;
+  SMnode     *pMnode = pReq->info.node;
+  SSdb       *pSdb = pMnode->pSdb;
   int32_t     numOfRows = 0;
   SStreamObj *pStream = NULL;
 
@@ -1728,7 +1728,7 @@ static int32_t setTaskAttrInResBlock(SStreamObj *pStream, SStreamTask *pTask, SS
   colDataSetVal(pColInfo, numOfRows, (const char *)vbuf, false);
 
   // output queue
-//          sprintf(buf, queueInfoStr, pe->outputQUsed, pe->outputRate);
+  //          sprintf(buf, queueInfoStr, pe->outputQUsed, pe->outputRate);
   //        STR_TO_VARSTR(vbuf, buf);
 
   //        pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
@@ -1764,8 +1764,8 @@ static int32_t getNumOfTasks(SArray *pTaskList) {
 }
 
 static int32_t mndRetrieveStreamTask(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity) {
-  SMnode *    pMnode = pReq->info.node;
-  SSdb *      pSdb = pMnode->pSdb;
+  SMnode     *pMnode = pReq->info.node;
+  SSdb       *pSdb = pMnode->pSdb;
   int32_t     numOfRows = 0;
   SStreamObj *pStream = NULL;
 
@@ -1790,7 +1790,7 @@ static int32_t mndRetrieveStreamTask(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock
       int32_t numOfLevels = taosArrayGetSize(pLevel);
       for (int32_t j = 0; j < numOfLevels; j++) {
         SStreamTask *pTask = taosArrayGetP(pLevel, j);
-        int32_t code = setTaskAttrInResBlock(pStream, pTask, pBlock, numOfRows);
+        int32_t      code = setTaskAttrInResBlock(pStream, pTask, pBlock, numOfRows);
         if (code == TSDB_CODE_SUCCESS) {
           numOfRows++;
         }
@@ -1824,7 +1824,7 @@ static int32_t mndPauseStreamTask(SMnode *pMnode, STrans *pTrans, SStreamTask *p
   pReq->taskId = pTask->id.taskId;
   pReq->streamId = pTask->id.streamId;
 
-  SEpSet  epset = {0};
+  SEpSet epset = {0};
   mDebug("pause node:%d, epset:%d", pTask->info.nodeId, epset.numOfEps);
   bool    hasEpset = false;
   int32_t code = extractNodeEpset(pMnode, &epset, &hasEpset, pTask->id.taskId, pTask->info.nodeId);
@@ -1871,12 +1871,14 @@ int32_t mndPauseAllStreamTasks(SMnode *pMnode, STrans *pTrans, SStreamObj *pStre
   return 0;
 }
 
-static int32_t mndPersistStreamLog(STrans *pTrans, const SStreamObj *pStream, int8_t status) {
-  SStreamObj streamObj = {0};
-  memcpy(streamObj.name, pStream->name, TSDB_STREAM_FNAME_LEN);
-  streamObj.status = status;
+static int32_t mndPersistStreamLog(STrans *pTrans, SStreamObj *pStream, int8_t status) {
+  // SStreamObj streamObj = {0};
+  // memcpy(streamObj.name, pStream->name, TSDB_STREAM_FNAME_LEN);
+  taosWLockLatch(&pStream->lock);
+  pStream->status = status;
+  SSdbRaw *pCommitRaw = mndStreamActionEncode(pStream);
 
-  SSdbRaw *pCommitRaw = mndStreamActionEncode(&streamObj);
+  taosWUnLockLatch(&pStream->lock);
   if (pCommitRaw == NULL) return -1;
   if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
     mError("stream trans:%d, failed to append commit log since %s", pTrans->id, terrstr());
@@ -1887,7 +1889,7 @@ static int32_t mndPersistStreamLog(STrans *pTrans, const SStreamObj *pStream, in
 }
 
 static int32_t mndProcessPauseStreamReq(SRpcMsg *pReq) {
-  SMnode *    pMnode = pReq->info.node;
+  SMnode     *pMnode = pReq->info.node;
   SStreamObj *pStream = NULL;
 
   SMPauseStreamReq pauseReq = {0};
@@ -2029,7 +2031,7 @@ int32_t mndResumeAllStreamTasks(STrans *pTrans, SMnode *pMnode, SStreamObj *pStr
 }
 
 static int32_t mndProcessResumeStreamReq(SRpcMsg *pReq) {
-  SMnode *    pMnode = pReq->info.node;
+  SMnode     *pMnode = pReq->info.node;
   SStreamObj *pStream = NULL;
 
   SMResumeStreamReq pauseReq = {0};
@@ -2147,7 +2149,7 @@ static int32_t doBuildStreamTaskUpdateMsg(void **pBuf, int32_t *pLen, SVgroupCha
     return -1;
   }
 
-  void *   abuf = POINTER_SHIFT(buf, sizeof(SMsgHead));
+  void    *abuf = POINTER_SHIFT(buf, sizeof(SMsgHead));
   SEncoder encoder;
   tEncoderInit(&encoder, abuf, tlen);
   tEncodeStreamTaskUpdateMsg(&encoder, &req);
@@ -2214,7 +2216,7 @@ static int32_t createStreamUpdateTrans(SStreamObj *pStream, SVgroupChangeInfo *p
     for (int32_t k = 0; k < numOfTasks; ++k) {
       SStreamTask *pTask = taosArrayGetP(pLevel, k);
 
-      void *  pBuf = NULL;
+      void   *pBuf = NULL;
       int32_t len = 0;
       streamTaskUpdateEpsetInfo(pTask, pInfo->pUpdateNodeList);
       doBuildStreamTaskUpdateMsg(&pBuf, &len, pInfo, pTask->info.nodeId, &pTask->id, pTrans->id);
@@ -2293,8 +2295,8 @@ static SVgroupChangeInfo mndFindChangedNodeInfo(SMnode *pMnode, const SArray *pP
 }
 
 static SArray *mndTakeVgroupSnapshot(SMnode *pMnode, bool *allReady) {
-  SSdb *  pSdb = pMnode->pSdb;
-  void *  pIter = NULL;
+  SSdb   *pSdb = pMnode->pSdb;
+  void   *pIter = NULL;
   SVgObj *pVgroup = NULL;
 
   *allReady = true;
@@ -2362,7 +2364,7 @@ static int32_t mndProcessVgroupChange(SMnode *pMnode, SVgroupChangeInfo *pChange
   STrans     *pTrans = NULL;
 
   // conflict check for nodeUpdate trans, here we randomly chose one stream to add into the trans pool
-  while(1) {
+  while (1) {
     pIter = sdbFetch(pSdb, SDB_STREAM, pIter, (void **)&pStream);
     if (pIter == NULL) {
       break;
@@ -2378,7 +2380,6 @@ static int32_t mndProcessVgroupChange(SMnode *pMnode, SVgroupChangeInfo *pChange
     }
   }
 
-
   while (1) {
     pIter = sdbFetch(pSdb, SDB_STREAM, pIter, (void **)&pStream);
     if (pIter == NULL) {
@@ -2440,9 +2441,9 @@ static int32_t mndProcessVgroupChange(SMnode *pMnode, SVgroupChangeInfo *pChange
 }
 
 static SArray *extractNodeListFromStream(SMnode *pMnode) {
-  SSdb *      pSdb = pMnode->pSdb;
+  SSdb       *pSdb = pMnode->pSdb;
   SStreamObj *pStream = NULL;
-  void *      pIter = NULL;
+  void       *pIter = NULL;
 
   SHashObj *pHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_NO_LOCK);
   while (1) {
@@ -2489,9 +2490,9 @@ static SArray *extractNodeListFromStream(SMnode *pMnode) {
 }
 
 static void doExtractTasksFromStream(SMnode *pMnode) {
-  SSdb *      pSdb = pMnode->pSdb;
+  SSdb       *pSdb = pMnode->pSdb;
   SStreamObj *pStream = NULL;
-  void *      pIter = NULL;
+  void       *pIter = NULL;
 
   while (1) {
     pIter = sdbFetch(pSdb, SDB_STREAM, pIter, (void **)&pStream);
@@ -2543,7 +2544,7 @@ int32_t removeExpirednodeEntryAndTask(SArray *pNodeSnapshot) {
 
   int32_t numOfTask = taosArrayGetSize(execInfo.pTaskList);
   for (int32_t i = 0; i < numOfTask; ++i) {
-    STaskId *         pId = taosArrayGet(execInfo.pTaskList, i);
+    STaskId          *pId = taosArrayGet(execInfo.pTaskList, i);
     STaskStatusEntry *pEntry = taosHashGet(execInfo.pTaskMap, pId, sizeof(*pId));
 
     if (pEntry->nodeId == SNODE_HANDLE) continue;
@@ -2591,7 +2592,7 @@ static void killAllCheckpointTrans(SMnode *pMnode, SVgroupChangeInfo *pChangeInf
     char *pDb = (char *)pIter;
 
     size_t len = 0;
-    void * pKey = taosHashGetKey(pDb, &len);
+    void  *pKey = taosHashGetKey(pDb, &len);
     doKillCheckpointTrans(pMnode, pKey, len);
   }
 }
@@ -2671,7 +2672,7 @@ typedef struct SMStreamNodeCheckMsg {
 
 static int32_t mndProcessNodeCheck(SRpcMsg *pReq) {
   SMnode *pMnode = pReq->info.node;
-  SSdb *  pSdb = pMnode->pSdb;
+  SSdb   *pSdb = pMnode->pSdb;
   if (sdbGetSize(pSdb, SDB_STREAM) <= 0) {
     return 0;
   }
@@ -2695,7 +2696,7 @@ void saveStreamTasksInfo(SStreamObj *pStream, SStreamExecInfo *pExecNode) {
       SStreamTask *pTask = taosArrayGetP(pLevel, j);
 
       STaskId id = {.streamId = pTask->id.streamId, .taskId = pTask->id.taskId};
-      void *  p = taosHashGet(pExecNode->pTaskMap, &id, sizeof(id));
+      void   *p = taosHashGet(pExecNode->pTaskMap, &id, sizeof(id));
       if (p == NULL) {
         STaskStatusEntry entry = {0};
         streamTaskStatusInit(&entry, pTask);
@@ -2719,7 +2720,7 @@ void removeStreamTasksInBuf(SStreamObj *pStream, SStreamExecInfo *pExecNode) {
       SStreamTask *pTask = taosArrayGetP(pLevel, j);
 
       STaskId id = {.streamId = pTask->id.streamId, .taskId = pTask->id.taskId};
-      void *  p = taosHashGet(pExecNode->pTaskMap, &id, sizeof(id));
+      void   *p = taosHashGet(pExecNode->pTaskMap, &id, sizeof(id));
       if (p != NULL) {
         taosHashRemove(pExecNode->pTaskMap, &id, sizeof(id));
 
@@ -2792,8 +2793,8 @@ int32_t createStreamResetStatusTrans(SMnode *pMnode, SStreamObj *pStream) {
       pReq->taskId = pTask->id.taskId;
       pReq->streamId = pTask->id.streamId;
 
-      SEpSet epset = {0};
-      bool hasEpset = false;
+      SEpSet  epset = {0};
+      bool    hasEpset = false;
       int32_t code = extractNodeEpset(pMnode, &epset, &hasEpset, pTask->id.taskId, pTask->info.nodeId);
       if (code != TSDB_CODE_SUCCESS) {
         taosMemoryFree(pReq);
@@ -2837,7 +2838,7 @@ int32_t createStreamResetStatusTrans(SMnode *pMnode, SStreamObj *pStream) {
   return TSDB_CODE_ACTION_IN_PROGRESS;
 }
 
-void killTransImpl(SMnode* pMnode, int32_t transId, const char* pDbName) {
+void killTransImpl(SMnode *pMnode, int32_t transId, const char *pDbName) {
   STrans *pTrans = mndAcquireTrans(pMnode, transId);
   if (pTrans != NULL) {
     mInfo("kill active transId:%d in Db:%s", transId, pDbName);
@@ -2859,7 +2860,7 @@ int32_t doKillCheckpointTrans(SMnode *pMnode, const char *pDBName, size_t len) {
     return TSDB_CODE_SUCCESS;
   }
 
-  char* pDupDBName = strndup(pDBName, len);
+  char *pDupDBName = strndup(pDBName, len);
   killTransImpl(pMnode, pTransInfo->transId, pDupDBName);
   taosMemoryFree(pDupDBName);
 
@@ -2914,38 +2915,38 @@ static SStreamTask *mndGetStreamTask(STaskId *pId, SStreamObj *pStream) {
   return NULL;
 }
 
-//static bool needDropRelatedFillhistoryTask(STaskStatusEntry *pTaskEntry, SStreamExecInfo *pExecNode) {
-//  if (pTaskEntry->status == TASK_STATUS__STREAM_SCAN_HISTORY && pTaskEntry->statusLastDuration >= 10) {
-//    if (!pTaskEntry->inputQChanging && pTaskEntry->inputQUnchangeCounter > 10) {
-//      int32_t numOfReady = 0;
-//      int32_t numOfTotal = 0;
-//      for (int32_t k = 0; k < taosArrayGetSize(pExecNode->pTaskList); ++k) {
-//        STaskId *pId = taosArrayGet(pExecNode->pTaskList, k);
-//        if (pTaskEntry->id.streamId == pId->streamId) {
-//          numOfTotal++;
+// static bool needDropRelatedFillhistoryTask(STaskStatusEntry *pTaskEntry, SStreamExecInfo *pExecNode) {
+//   if (pTaskEntry->status == TASK_STATUS__STREAM_SCAN_HISTORY && pTaskEntry->statusLastDuration >= 10) {
+//     if (!pTaskEntry->inputQChanging && pTaskEntry->inputQUnchangeCounter > 10) {
+//       int32_t numOfReady = 0;
+//       int32_t numOfTotal = 0;
+//       for (int32_t k = 0; k < taosArrayGetSize(pExecNode->pTaskList); ++k) {
+//         STaskId *pId = taosArrayGet(pExecNode->pTaskList, k);
+//         if (pTaskEntry->id.streamId == pId->streamId) {
+//           numOfTotal++;
 //
-//          if (pTaskEntry->id.taskId != pId->taskId) {
-//            STaskStatusEntry *pEntry = taosHashGet(execInfo.pTaskMap, pId, sizeof(*pId));
-//            if (pEntry->status == TASK_STATUS__READY) {
-//              numOfReady++;
-//            }
-//          }
-//        }
-//      }
+//           if (pTaskEntry->id.taskId != pId->taskId) {
+//             STaskStatusEntry *pEntry = taosHashGet(execInfo.pTaskMap, pId, sizeof(*pId));
+//             if (pEntry->status == TASK_STATUS__READY) {
+//               numOfReady++;
+//             }
+//           }
+//         }
+//       }
 //
-//      if (numOfReady > 0) {
-//        mDebug("stream:0x%" PRIx64
-//               " %d tasks are ready, %d tasks in stream-scan-history for more than 50s, drop related fill-history task",
-//               pTaskEntry->id.streamId, numOfReady, numOfTotal - numOfReady);
-//        return true;
-//      } else {
-//        return false;
-//      }
-//    }
-//  }
+//       if (numOfReady > 0) {
+//         mDebug("stream:0x%" PRIx64
+//                " %d tasks are ready, %d tasks in stream-scan-history for more than 50s, drop related fill-history
+//                task", pTaskEntry->id.streamId, numOfReady, numOfTotal - numOfReady);
+//         return true;
+//       } else {
+//         return false;
+//       }
+//     }
+//   }
 //
-//  return false;
-//}
+//   return false;
+// }
 
 // currently only handle the sink task
 // 1. sink task, drop related fill-history task msg is missing
@@ -3028,7 +3029,7 @@ static void updateStageInfo(STaskStatusEntry *pTaskEntry, int64_t stage) {
 }
 
 int32_t mndProcessStreamHb(SRpcMsg *pReq) {
-  SMnode *     pMnode = pReq->info.node;
+  SMnode      *pMnode = pReq->info.node;
   SStreamHbMsg req = {0};
 
   bool    checkpointFailed = false;
@@ -3148,8 +3149,8 @@ void freeCheckpointCandEntry(void *param) {
   taosMemoryFreeClear(pEntry->pName);
 }
 SStreamObj *mndGetStreamObj(SMnode *pMnode, int64_t streamId) {
-  void *      pIter = NULL;
-  SSdb *      pSdb = pMnode->pSdb;
+  void       *pIter = NULL;
+  SSdb       *pSdb = pMnode->pSdb;
   SStreamObj *pStream = NULL;
 
   while ((pIter = sdbFetch(pSdb, SDB_STREAM, pIter, (void **)&pStream)) != NULL) {

From 79671d3e688ae7a5c32d303dd438b7018b81ec3c Mon Sep 17 00:00:00 2001
From: facetosea <25808407@qq.com>
Date: Tue, 16 Jan 2024 10:07:46 +0800
Subject: [PATCH 45/47] fix: internal error code

---
 source/libs/executor/src/aggregateoperator.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/libs/executor/src/aggregateoperator.c b/source/libs/executor/src/aggregateoperator.c
index a3adb02ab9..715c354873 100644
--- a/source/libs/executor/src/aggregateoperator.c
+++ b/source/libs/executor/src/aggregateoperator.c
@@ -282,7 +282,7 @@ int32_t doAggregateImpl(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx) {
       }
 
       if ((&pCtx[k])->input.pData[0] == NULL) {
-        code = TSDB_CODE_PAR_INTERNAL_ERROR;
+        code = TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;
         qError("%s aggregate function error happens, input data is NULL.", GET_TASKID(pOperator->pTaskInfo));
       } else {
         code = pCtx[k].fpSet.process(&pCtx[k]);
@@ -570,7 +570,7 @@ void applyAggFunctionOnPartialTuples(SExecTaskInfo* taskInfo, SqlFunctionCtx* pC
       int32_t code = TSDB_CODE_SUCCESS;
       if (functionNeedToExecute(&pCtx[k]) && pCtx[k].fpSet.process != NULL) {
         if ((&pCtx[k])->input.pData[0] == NULL) {
-          code = TSDB_CODE_PAR_INTERNAL_ERROR;
+          code = TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;
           qError("%s apply functions error, input data is NULL.", GET_TASKID(taskInfo));
         } else {
           code = pCtx[k].fpSet.process(&pCtx[k]);

From 63494de7f92fbf55dfa5d7f7f952f776242872b2 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 16 Jan 2024 10:28:07 +0800
Subject: [PATCH 46/47] refactor: do some internal refactor.

---
 include/libs/stream/tstream.h             |  2 +-
 source/dnode/vnode/src/tq/tq.c            | 26 +++++++++++------------
 source/libs/stream/src/stream.c           |  6 +++---
 source/libs/stream/src/streamCheckpoint.c |  5 +++++
 source/libs/stream/src/streamMeta.c       | 12 +++++------
 source/libs/stream/src/streamState.c      |  1 -
 source/libs/stream/src/streamTask.c       |  2 +-
 7 files changed, 29 insertions(+), 25 deletions(-)

diff --git a/include/libs/stream/tstream.h b/include/libs/stream/tstream.h
index 5bdf3ab75f..a0cff35623 100644
--- a/include/libs/stream/tstream.h
+++ b/include/libs/stream/tstream.h
@@ -834,7 +834,7 @@ void    streamTaskUpdateDownstreamInfo(SStreamTask* pTask, int32_t nodeId, const
 void    streamTaskSetFixedDownstreamInfo(SStreamTask* pTask, const SStreamTask* pDownstreamTask);
 int32_t streamTaskReleaseState(SStreamTask* pTask);
 int32_t streamTaskReloadState(SStreamTask* pTask);
-void    streamTaskCloseAllUpstreamInput(SStreamTask* pTask, int32_t taskId);
+void    streamTaskCloseUpstreamInput(SStreamTask* pTask, int32_t taskId);
 void    streamTaskOpenAllUpstreamInput(SStreamTask* pTask);
 int32_t streamTaskSetDb(SStreamMeta* pMeta, void* pTask, char* key);
 bool    streamTaskIsSinkTask(const SStreamTask* pTask);
diff --git a/source/dnode/vnode/src/tq/tq.c b/source/dnode/vnode/src/tq/tq.c
index 016e3e199e..1fc7402363 100644
--- a/source/dnode/vnode/src/tq/tq.c
+++ b/source/dnode/vnode/src/tq/tq.c
@@ -1124,6 +1124,19 @@ int32_t tqProcessTaskCheckPointSourceReq(STQ* pTq, SRpcMsg* pMsg, SRpcMsg* pRsp)
   pRsp->info.handle = NULL;
 
   SStreamCheckpointSourceReq req = {0};
+  SDecoder decoder;
+  tDecoderInit(&decoder, (uint8_t*)msg, len);
+  if (tDecodeStreamCheckpointSourceReq(&decoder, &req) < 0) {
+    code = TSDB_CODE_MSG_DECODE_ERROR;
+    tDecoderClear(&decoder);
+    tqError("vgId:%d failed to decode checkpoint-source msg, code:%s", vgId, tstrerror(code));
+    SRpcMsg rsp = {0};
+    buildCheckpointSourceRsp(&req, &pMsg->info, &rsp, 0);
+    tmsgSendRsp(&rsp);  // error occurs
+    return code;
+  }
+  tDecoderClear(&decoder);
+
   if (!vnodeIsRoleLeader(pTq->pVnode)) {
     tqDebug("vgId:%d not leader, ignore checkpoint-source msg, s-task:0x%x", vgId, req.taskId);
     SRpcMsg rsp = {0};
@@ -1140,19 +1153,6 @@ int32_t tqProcessTaskCheckPointSourceReq(STQ* pTq, SRpcMsg* pMsg, SRpcMsg* pRsp)
     return TSDB_CODE_SUCCESS;
   }
 
-  SDecoder decoder;
-  tDecoderInit(&decoder, (uint8_t*)msg, len);
-  if (tDecodeStreamCheckpointSourceReq(&decoder, &req) < 0) {
-    code = TSDB_CODE_MSG_DECODE_ERROR;
-    tDecoderClear(&decoder);
-    tqError("vgId:%d failed to decode checkpoint-source msg, code:%s", vgId, tstrerror(code));
-    SRpcMsg rsp = {0};
-    buildCheckpointSourceRsp(&req, &pMsg->info, &rsp, 0);
-    tmsgSendRsp(&rsp);  // error occurs
-    return code;
-  }
-  tDecoderClear(&decoder);
-
   SStreamTask* pTask = streamMetaAcquireTask(pMeta, req.streamId, req.taskId);
   if (pTask == NULL) {
     tqError("vgId:%d failed to find s-task:0x%x, ignore checkpoint msg. it may have been destroyed already", vgId,
diff --git a/source/libs/stream/src/stream.c b/source/libs/stream/src/stream.c
index 32e724c156..75af5a9fc5 100644
--- a/source/libs/stream/src/stream.c
+++ b/source/libs/stream/src/stream.c
@@ -243,18 +243,18 @@ int32_t streamProcessDispatchMsg(SStreamTask* pTask, SStreamDispatchReq* pReq, S
         // blocked. Note that there is no race condition here.
         if (pReq->type == STREAM_INPUT__CHECKPOINT_TRIGGER) {
           atomic_add_fetch_32(&pTask->upstreamInfo.numOfClosed, 1);
-          streamTaskCloseAllUpstreamInput(pTask, pReq->upstreamTaskId);
+          streamTaskCloseUpstreamInput(pTask, pReq->upstreamTaskId);
           stDebug("s-task:%s close inputQ for upstream:0x%x, msgId:%d", id, pReq->upstreamTaskId, pReq->msgId);
         } else if (pReq->type == STREAM_INPUT__TRANS_STATE) {
           atomic_add_fetch_32(&pTask->upstreamInfo.numOfClosed, 1);
-          streamTaskCloseAllUpstreamInput(pTask, pReq->upstreamTaskId);
+          streamTaskCloseUpstreamInput(pTask, pReq->upstreamTaskId);
 
           // disable the related stream task here to avoid it to receive the newly arrived data after the transfer-state
           STaskId* pRelTaskId = &pTask->streamTaskId;
           SStreamTask* pStreamTask = streamMetaAcquireTask(pMeta, pRelTaskId->streamId, pRelTaskId->taskId);
           if (pStreamTask != NULL) {
             atomic_add_fetch_32(&pStreamTask->upstreamInfo.numOfClosed, 1);
-            streamTaskCloseAllUpstreamInput(pStreamTask, pReq->upstreamRelTaskId);
+            streamTaskCloseUpstreamInput(pStreamTask, pReq->upstreamRelTaskId);
             streamMetaReleaseTask(pMeta, pStreamTask);
           }
 
diff --git a/source/libs/stream/src/streamCheckpoint.c b/source/libs/stream/src/streamCheckpoint.c
index 60e4d74b43..006202fdd1 100644
--- a/source/libs/stream/src/streamCheckpoint.c
+++ b/source/libs/stream/src/streamCheckpoint.c
@@ -185,6 +185,11 @@ int32_t streamProcessCheckpointBlock(SStreamTask* pTask, SStreamDataBlock* pBloc
   int64_t      checkpointId = pDataBlock->info.version;
   const char*  id = pTask->id.idStr;
   int32_t      code = TSDB_CODE_SUCCESS;
+  int32_t      vgId = pTask->pMeta->vgId;
+
+  stDebug("s-task:%s vgId:%d start to handle the checkpoint block, checkpointId:%" PRId64 " ver:%" PRId64
+          ", current checkpointingId:%" PRId64,
+          id, vgId, pTask->chkInfo.checkpointId, pTask->chkInfo.checkpointVer, checkpointId);
 
   // set task status
   if (streamTaskGetStatus(pTask)->state != TASK_STATUS__CK) {
diff --git a/source/libs/stream/src/streamMeta.c b/source/libs/stream/src/streamMeta.c
index bb5cb6e832..1f45e9b94c 100644
--- a/source/libs/stream/src/streamMeta.c
+++ b/source/libs/stream/src/streamMeta.c
@@ -1308,28 +1308,28 @@ void streamMetaResetStartInfo(STaskStartInfo* pStartInfo) {
 }
 
 void streamMetaRLock(SStreamMeta* pMeta) {
-  stTrace("vgId:%d meta-rlock", pMeta->vgId);
+//  stTrace("vgId:%d meta-rlock", pMeta->vgId);
   taosThreadRwlockRdlock(&pMeta->lock);
 }
 
 void streamMetaRUnLock(SStreamMeta* pMeta) {
-  stTrace("vgId:%d meta-runlock", pMeta->vgId);
+//  stTrace("vgId:%d meta-runlock", pMeta->vgId);
   int32_t code = taosThreadRwlockUnlock(&pMeta->lock);
   if (code != TSDB_CODE_SUCCESS) {
     stError("vgId:%d meta-runlock failed, code:%d", pMeta->vgId, code);
   } else {
-    stDebug("vgId:%d meta-runlock completed", pMeta->vgId);
+//    stDebug("vgId:%d meta-runlock completed", pMeta->vgId);
   }
 }
 
 void streamMetaWLock(SStreamMeta* pMeta) {
-  stTrace("vgId:%d meta-wlock", pMeta->vgId);
+//  stTrace("vgId:%d meta-wlock", pMeta->vgId);
   taosThreadRwlockWrlock(&pMeta->lock);
-  stTrace("vgId:%d meta-wlock completed", pMeta->vgId);
+//  stTrace("vgId:%d meta-wlock completed", pMeta->vgId);
 }
 
 void streamMetaWUnLock(SStreamMeta* pMeta) {
-  stTrace("vgId:%d meta-wunlock", pMeta->vgId);
+//  stTrace("vgId:%d meta-wunlock", pMeta->vgId);
   taosThreadRwlockUnlock(&pMeta->lock);
 }
 
diff --git a/source/libs/stream/src/streamState.c b/source/libs/stream/src/streamState.c
index 776a9db522..19b7359981 100644
--- a/source/libs/stream/src/streamState.c
+++ b/source/libs/stream/src/streamState.c
@@ -435,7 +435,6 @@ int32_t streamStateAddIfNotExist(SStreamState* pState, const SWinKey* key, void*
 
 int32_t streamStateReleaseBuf(SStreamState* pState, void* pVal, bool used) {
   // todo refactor
-  stDebug("streamStateReleaseBuf");
   if (!pVal) {
     return 0;
   }
diff --git a/source/libs/stream/src/streamTask.c b/source/libs/stream/src/streamTask.c
index 9e981a79c7..2497e8dd8e 100644
--- a/source/libs/stream/src/streamTask.c
+++ b/source/libs/stream/src/streamTask.c
@@ -684,7 +684,7 @@ void streamTaskOpenAllUpstreamInput(SStreamTask* pTask) {
   stDebug("s-task:%s opening up inputQ for %d upstream tasks", pTask->id.idStr, num);
 }
 
-void streamTaskCloseAllUpstreamInput(SStreamTask* pTask, int32_t taskId) {
+void streamTaskCloseUpstreamInput(SStreamTask* pTask, int32_t taskId) {
   SStreamChildEpInfo* pInfo = streamTaskGetUpstreamTaskEpInfo(pTask, taskId);
   if (pInfo != NULL) {
     pInfo->dataAllowed = false;

From 4c119c76269bd4b42dfcfb6677a41d49f5f4cecc Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 16 Jan 2024 10:44:59 +0800
Subject: [PATCH 47/47] fix(os): fix error on windows.

---
 source/os/src/osFile.c | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/source/os/src/osFile.c b/source/os/src/osFile.c
index 74ce5e5aa6..f4e35c5b7f 100644
--- a/source/os/src/osFile.c
+++ b/source/os/src/osFile.c
@@ -1388,15 +1388,13 @@ int32_t taosSetFileHandlesLimit() {
 }
 
 int32_t taosLinkFile(char *src, char *dst) {
-#ifdef WINDOWS
-  // don nothing
-  return 0;
-#endif
+#ifndef WINDOWS
   if (link(src, dst) != 0) {
     if (errno == EXDEV || errno == ENOTSUP) {
       return -1;
     }
     return errno;
   }
+#endif
   return 0;
 }