Merge pull request #12274 from taosdata/feature/3.0_liaohj

enh(query):support selectivity function and normal column data query.

source/libs/executor/src/executorimpl.c

@@ -13,6 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <libs/function/function.h>
 #include "filter.h"
 #include "function.h"
 #include "functionMgt.h"
@@ -803,6 +804,7 @@ static void doAggregateImpl(SOperatorInfo* pOperator, TSKEY startTs, SqlFunction
   for (int32_t k = 0; k < pOperator->numOfExprs; ++k) {
     if (functionNeedToExecute(&pCtx[k])) {
       pCtx[k].startTs = startTs;  // this can be set during create the struct
+      if (pCtx[k].fpSet.process != NULL)
         pCtx[k].fpSet.process(&pCtx[k]);
     }
   }
@@ -1074,35 +1076,36 @@ void setBlockStatisInfo(SqlFunctionCtx* pCtx, SExprInfo* pExprInfo, SSDataBlock*
 // set the output buffer for the selectivity + tag query
 static int32_t setCtxTagColumnInfo(SqlFunctionCtx* pCtx, int32_t numOfOutput) {
   int32_t num = 0;
-  int16_t tagLen = 0;
 
   SqlFunctionCtx*  p = NULL;
-  SqlFunctionCtx** pTagCtx = taosMemoryCalloc(numOfOutput, POINTER_BYTES);
-  if (pTagCtx == NULL) {
+  SqlFunctionCtx** pValCtx = taosMemoryCalloc(numOfOutput, POINTER_BYTES);
+  if (pValCtx == NULL) {
     return TSDB_CODE_QRY_OUT_OF_MEMORY;
   }
 
   for (int32_t i = 0; i < numOfOutput; ++i) {
-    int32_t functionId = pCtx[i].functionId;
-
-    if (functionId == FUNCTION_TAG_DUMMY || functionId == FUNCTION_TS_DUMMY) {
-      tagLen += pCtx[i].resDataInfo.bytes;
-      pTagCtx[num++] = &pCtx[i];
-    } else if (1 /*(aAggs[functionId].status & FUNCSTATE_SELECTIVITY) != 0*/) {
-      p = &pCtx[i];
-    } else if (functionId == FUNCTION_TS || functionId == FUNCTION_TAG) {
-      // tag function may be the group by tag column
-      // ts may be the required primary timestamp column
-      continue;
+    if (strcmp(pCtx[i].pExpr->pExpr->_function.functionName, "_select_value") == 0) {
+      pValCtx[num++] = &pCtx[i];
     } else {
-      // the column may be the normal column, group by normal_column, the functionId is FUNCTION_PRJ
+      p = &pCtx[i];
     }
+//    if (functionId == FUNCTION_TAG_DUMMY || functionId == FUNCTION_TS_DUMMY) {
+//      tagLen += pCtx[i].resDataInfo.bytes;
+//      pTagCtx[num++] = &pCtx[i];
+//    } else if (functionId == FUNCTION_TS || functionId == FUNCTION_TAG) {
+//      // tag function may be the group by tag column
+//      // ts may be the required primary timestamp column
+//      continue;
+//    } else {
+//      // the column may be the normal column, group by normal_column, the functionId is FUNCTION_PRJ
+//    }
   }
+
   if (p != NULL) {
-    p->subsidiaries.pCtx = pTagCtx;
+    p->subsidiaries.pCtx = pValCtx;
     p->subsidiaries.num = num;
   } else {
-    taosMemoryFreeClear(pTagCtx);
+    taosMemoryFreeClear(pValCtx);
   }
 
   return TSDB_CODE_SUCCESS;
@@ -2219,6 +2222,8 @@ int32_t doCopyToSDataBlock(SSDataBlock* pBlock, SExprInfo* pExprInfo, SDiskbased
       pCtx[j].resultInfo = getResultCell(pRow, j, rowCellOffset);
       if (pCtx[j].fpSet.process) {
         pCtx[j].fpSet.finalize(&pCtx[j], pBlock);
+      } else if (strcmp(pCtx[j].pExpr->pExpr->_function.functionName, "_select_value") == 0) {
+        // do nothing, todo refactor
       } else {
         SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, slotId);
 
@@ -3974,6 +3979,7 @@ static SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) {
   SSDataBlock* pRes = pInfo->pRes;
   blockDataCleanup(pRes);
 
+  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
   if (pOperator->status == OP_EXEC_DONE) {
     return NULL;
   }
@@ -4037,9 +4043,13 @@ static SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) {
     setInputDataBlock(pOperator, pInfo->pCtx, pBlock, order, false);
     blockDataEnsureCapacity(pInfo->pRes, pInfo->pRes->info.rows + pBlock->info.rows);
 
-    projectApplyFunctions(pOperator->pExpr, pInfo->pRes, pBlock, pInfo->pCtx, pOperator->numOfExprs,
+    pTaskInfo->code = projectApplyFunctions(pOperator->pExpr, pInfo->pRes, pBlock, pInfo->pCtx, pOperator->numOfExprs,
                           pProjectInfo->pPseudoColInfo);
 
+    if (pTaskInfo->code != TSDB_CODE_SUCCESS) {
+      longjmp(pTaskInfo->env, pTaskInfo->code);
+    }
+
     int32_t status = handleLimitOffset(pOperator, pBlock);
     if (status == PROJECT_RETRIEVE_CONTINUE) {
       continue;

source/libs/executor/src/groupoperator.c

@@ -262,6 +262,8 @@ static SSDataBlock* hashGroupbyAggregate(SOperatorInfo* pOperator) {
     return NULL;
   }
 
+  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
+
   SGroupbyOperatorInfo* pInfo = pOperator->info;
   SSDataBlock* pRes = pInfo->binfo.pRes;
 
@@ -289,7 +291,10 @@ static SSDataBlock* hashGroupbyAggregate(SOperatorInfo* pOperator) {
 
     // there is an scalar expression that needs to be calculated right before apply the group aggregation.
     if (pInfo->pScalarExprInfo != NULL) {
-      projectApplyFunctions(pInfo->pScalarExprInfo, pBlock, pBlock, pInfo->pScalarFuncCtx, pInfo->numOfScalarExpr, NULL);
+      pTaskInfo->code = projectApplyFunctions(pInfo->pScalarExprInfo, pBlock, pBlock, pInfo->pScalarFuncCtx, pInfo->numOfScalarExpr, NULL);
+      if (pTaskInfo->code != TSDB_CODE_SUCCESS) {
+        longjmp(pTaskInfo->env, pTaskInfo->code);
+      }
     }
 
     //    setTagValue(pOperator, pRuntimeEnv->current->pTable, pInfo->binfo.pCtx, pOperator->numOfExprs);

source/libs/executor/src/sortoperator.c

@@ -114,7 +114,10 @@ void applyScalarFunction(SSDataBlock* pBlock, void* param) {
   SOperatorInfo* pOperator = param;
   SSortOperatorInfo* pSort = pOperator->info;
   if (pOperator->pExpr != NULL) {
-    projectApplyFunctions(pOperator->pExpr, pBlock, pBlock, pSort->binfo.pCtx, pOperator->numOfExprs, NULL);
+    int32_t code = projectApplyFunctions(pOperator->pExpr, pBlock, pBlock, pSort->binfo.pCtx, pOperator->numOfExprs, NULL);
+    if (code != TSDB_CODE_SUCCESS) {
+      longjmp(pOperator->pTaskInfo->env, code);
+    }
   }
 }
 

source/libs/function/inc/builtinsimpl.h

@@ -37,11 +37,11 @@ bool getSumFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
 int32_t sumFunction(SqlFunctionCtx *pCtx);
 int32_t sumInvertFunction(SqlFunctionCtx *pCtx);
 
-bool minFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
-bool maxFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
+bool minmaxFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
 bool getMinmaxFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
 int32_t minFunction(SqlFunctionCtx* pCtx);
 int32_t maxFunction(SqlFunctionCtx *pCtx);
+int32_t minmaxFunctionFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
 
 bool getAvgFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
 bool avgFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultInfo);
@@ -70,6 +70,7 @@ int32_t lastFunction(SqlFunctionCtx *pCtx);
 
 bool getTopBotFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv);
 int32_t topFunction(SqlFunctionCtx *pCtx);
+int32_t bottomFunction(SqlFunctionCtx *pCtx);
 int32_t topBotFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
 
 bool getSpreadFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
@@ -82,6 +83,8 @@ bool histogramFunctionSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResultIn
 int32_t histogramFunction(SqlFunctionCtx* pCtx);
 int32_t histogramFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
 
+bool getSelectivityFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv);
+
 #ifdef __cplusplus
 }
 #endif

source/libs/function/src/builtins.c

@@ -207,7 +207,8 @@ static int32_t translateTop(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
 }
 
 static int32_t translateBottom(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
-  // todo
+  SDataType* pType = &((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType;
+  pFunc->node.resType = (SDataType){.bytes = pType->bytes, .type = pType->type};
   return TSDB_CODE_SUCCESS;
 }
 
@@ -509,9 +510,9 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .translateFunc = translateInOutNum,
     .dataRequiredFunc = statisDataRequired,
     .getEnvFunc   = getMinmaxFuncEnv,
-    .initFunc     = minFunctionSetup,
+    .initFunc     = minmaxFunctionSetup,
     .processFunc  = minFunction,
-    .finalizeFunc = functionFinalize
+    .finalizeFunc = minmaxFunctionFinalize
   },
   {
     .name = "max",
@@ -520,9 +521,9 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .translateFunc = translateInOutNum,
     .dataRequiredFunc = statisDataRequired,
     .getEnvFunc   = getMinmaxFuncEnv,
-    .initFunc     = maxFunctionSetup,
+    .initFunc     = minmaxFunctionSetup,
     .processFunc  = maxFunction,
-    .finalizeFunc = functionFinalize
+    .finalizeFunc = minmaxFunctionFinalize
   },
   {
     .name = "stddev",
@@ -562,14 +563,14 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .classification = FUNC_MGT_AGG_FUNC,
     .translateFunc = translateApercentile,
     .getEnvFunc   = getMinmaxFuncEnv,
-    .initFunc     = maxFunctionSetup,
+    .initFunc     = minmaxFunctionSetup,
     .processFunc  = maxFunction,
     .finalizeFunc = functionFinalize
   },
   {
     .name = "top",
     .type = FUNCTION_TYPE_TOP,
-    .classification = FUNC_MGT_AGG_FUNC,
+    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC,
     .translateFunc = translateTop,
     .getEnvFunc   = getTopBotFuncEnv,
     .initFunc     = functionSetup,
@@ -579,12 +580,12 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
   {
     .name = "bottom",
     .type = FUNCTION_TYPE_BOTTOM,
-    .classification = FUNC_MGT_AGG_FUNC,
+    .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC,
     .translateFunc = translateBottom,
-    .getEnvFunc   = getMinmaxFuncEnv,
-    .initFunc     = maxFunctionSetup,
-    .processFunc  = maxFunction,
-    .finalizeFunc = functionFinalize
+    .getEnvFunc   = getTopBotFuncEnv,
+    .initFunc     = functionSetup,
+    .processFunc  = bottomFunction,
+    .finalizeFunc = topBotFinalize
   },
   {
     .name = "spread",
@@ -603,7 +604,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_MULTI_RES_FUNC,
     .translateFunc = translateLastRow,
     .getEnvFunc   = getMinmaxFuncEnv,
-    .initFunc     = maxFunctionSetup,
+    .initFunc     = minmaxFunctionSetup,
     .processFunc  = maxFunction,
     .finalizeFunc = functionFinalize
   },
@@ -1032,8 +1033,8 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .type = FUNCTION_TYPE_SELECT_VALUE,
     .classification = FUNC_MGT_AGG_FUNC | FUNC_MGT_SELECT_FUNC,
     .translateFunc = translateSelectValue,
-    .getEnvFunc   = NULL,
-    .initFunc     = NULL,
+    .getEnvFunc   = getSelectivityFuncEnv,  // todo remove this function later.
+    .initFunc     = functionSetup,
     .sprocessFunc = NULL,
     .finalizeFunc = NULL
   }

source/libs/function/src/builtinsimpl.c

@@ -37,13 +37,15 @@ typedef struct SAvgRes {
   int64_t count;
 } SAvgRes;
 
+typedef struct STuplePos {
+ int32_t pageId;
+ int32_t offset;
+} STuplePos;
+
 typedef struct STopBotResItem {
   SVariant  v;
   uint64_t  uid;  // it is a table uid, used to extract tag data during building of the final result for the tag data
-  struct {
-    int32_t pageId;
-    int32_t offset;
-  } tuplePos;  // tuple data of this chosen row
+  STuplePos tuplePos;  // tuple data of this chosen row
 } STopBotResItem;
 
 typedef struct STopBotRes {
@@ -616,101 +618,25 @@ EFuncDataRequired statisDataRequired(SFunctionNode* pFunc, STimeWindow* pTimeWin
   return FUNC_DATA_REQUIRED_STATIS_LOAD;
 }
 
-bool maxFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
-  if (!functionSetup(pCtx, pResultInfo)) {
-    return false;
-  }
+typedef struct SMinmaxResInfo {
+  bool      assign;   // assign the first value or not
+  int64_t   v;
+  STuplePos tuplePos;
+} SMinmaxResInfo;
 
-  char* buf = GET_ROWCELL_INTERBUF(pResultInfo);
-  switch (pCtx->resDataInfo.type) {
-    case TSDB_DATA_TYPE_INT:
-      *((int32_t*)buf) = INT32_MIN;
-      break;
-    case TSDB_DATA_TYPE_UINT:
-      *((uint32_t*)buf) = 0;
-      break;
-    case TSDB_DATA_TYPE_FLOAT:
-      *((float*)buf) = -FLT_MAX;
-      break;
-    case TSDB_DATA_TYPE_DOUBLE:
-      SET_DOUBLE_VAL(((double*)buf), -DBL_MAX);
-      break;
-    case TSDB_DATA_TYPE_BIGINT:
-      *((int64_t*)buf) = INT64_MIN;
-      break;
-    case TSDB_DATA_TYPE_UBIGINT:
-      *((uint64_t*)buf) = 0;
-      break;
-    case TSDB_DATA_TYPE_SMALLINT:
-      *((int16_t*)buf) = INT16_MIN;
-      break;
-    case TSDB_DATA_TYPE_USMALLINT:
-      *((uint16_t*)buf) = 0;
-      break;
-    case TSDB_DATA_TYPE_TINYINT:
-      *((int8_t*)buf) = INT8_MIN;
-      break;
-    case TSDB_DATA_TYPE_UTINYINT:
-      *((uint8_t*)buf) = 0;
-      break;
-    case TSDB_DATA_TYPE_BOOL:
-      *((int8_t*)buf) = 0;
-      break;
-    default:
-      assert(0);
-  }
-  return true;
-}
-
-bool minFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
+bool minmaxFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
   if (!functionSetup(pCtx, pResultInfo)) {
     return false;  // not initialized since it has been initialized
   }
 
-  char* buf = GET_ROWCELL_INTERBUF(pResultInfo);
-  switch (pCtx->resDataInfo.type) {
-    case TSDB_DATA_TYPE_TINYINT:
-      *((int8_t*)buf) = INT8_MAX;
-      break;
-    case TSDB_DATA_TYPE_UTINYINT:
-      *(uint8_t*)buf = UINT8_MAX;
-      break;
-    case TSDB_DATA_TYPE_SMALLINT:
-      *((int16_t*)buf) = INT16_MAX;
-      break;
-    case TSDB_DATA_TYPE_USMALLINT:
-      *((uint16_t*)buf) = UINT16_MAX;
-      break;
-    case TSDB_DATA_TYPE_INT:
-      *((int32_t*)buf) = INT32_MAX;
-      break;
-    case TSDB_DATA_TYPE_UINT:
-      *((uint32_t*)buf) = UINT32_MAX;
-      break;
-    case TSDB_DATA_TYPE_BIGINT:
-      *((int64_t*)buf) = INT64_MAX;
-      break;
-    case TSDB_DATA_TYPE_UBIGINT:
-      *((uint64_t*)buf) = UINT64_MAX;
-      break;
-    case TSDB_DATA_TYPE_FLOAT:
-      *((float*)buf) = FLT_MAX;
-      break;
-    case TSDB_DATA_TYPE_DOUBLE:
-      SET_DOUBLE_VAL(((double*)buf), DBL_MAX);
-      break;
-    case TSDB_DATA_TYPE_BOOL:
-      *((int8_t*)buf) = 1;
-      break;
-    default:
-      assert(0);
-  }
-
+  SMinmaxResInfo* buf = GET_ROWCELL_INTERBUF(pResultInfo);
+  buf->assign = false;
+  buf->tuplePos.pageId = -1;
   return true;
 }
 
 bool getMinmaxFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
-  pEnv->calcMemSize = sizeof(int64_t);
+  pEnv->calcMemSize = sizeof(SMinmaxResInfo);
   return true;
 }
 
@@ -758,6 +684,9 @@ bool getMinmaxFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
     }                                                                    \
   } while (0)
 
+static void saveTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, STuplePos* pPos);
+static void copyTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, STuplePos* pPos);
+
 int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) {
   int32_t numOfElems = 0;
 
@@ -768,13 +697,12 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) {
   int32_t          type = pCol->info.type;
 
   SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
-  char*                buf = GET_ROWCELL_INTERBUF(pResInfo);
+  SMinmaxResInfo *pBuf = GET_ROWCELL_INTERBUF(pResInfo);
 
   // data in current data block are qualified to the query
   if (pInput->colDataAggIsSet) {
     numOfElems = pInput->numOfRows - pAgg->numOfNull;
     ASSERT(pInput->numOfRows == pInput->totalRows && numOfElems >= 0);
-
     if (numOfElems == 0) {
       return numOfElems;
     }
@@ -793,48 +721,82 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) {
     // the index is the original position, not the relative position
     TSKEY key = (pCtx->ptsList != NULL) ? pCtx->ptsList[index] : TSKEY_INITIAL_VAL;
 
+    if (!pBuf->assign) {
+      pBuf->v = *(int64_t*)tval;
+      if (pCtx->subsidiaries.num > 0) {
+        saveTupleData(pCtx, index, pCtx->pSrcBlock, &pBuf->tuplePos);
+      }
+    } else {
       if (IS_SIGNED_NUMERIC_TYPE(type)) {
         int64_t prev = 0;
-      GET_TYPED_DATA(prev, int64_t, type, buf);
+        GET_TYPED_DATA(prev, int64_t, type, &pBuf->v);
 
         int64_t val = GET_INT64_VAL(tval);
         if ((prev < val) ^ isMinFunc) {
-        *(int64_t*)buf = val;
-        for (int32_t i = 0; i < (pCtx)->subsidiaries.num; ++i) {
-          SqlFunctionCtx* __ctx = pCtx->subsidiaries.pCtx[i];
-          if (__ctx->functionId == FUNCTION_TS_DUMMY) {  // TODO refactor
-            __ctx->tag.i = key;
-            __ctx->tag.nType = TSDB_DATA_TYPE_BIGINT;
-          }
+          pBuf->v = val;
+          //        for (int32_t i = 0; i < (pCtx)->subsidiaries.num; ++i) {
+          //          SqlFunctionCtx* __ctx = pCtx->subsidiaries.pCtx[i];
+          //          if (__ctx->functionId == FUNCTION_TS_DUMMY) {  // TODO refactor
+          //            __ctx->tag.i = key;
+          //            __ctx->tag.nType = TSDB_DATA_TYPE_BIGINT;
+          //          }
+          //
+          //          __ctx->fpSet.process(__ctx);
+          //        }
 
-          __ctx->fpSet.process(__ctx);
+          if (pCtx->subsidiaries.num > 0) {
+            saveTupleData(pCtx, index, pCtx->pSrcBlock, &pBuf->tuplePos);
           }
         }
+
       } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
         uint64_t prev = 0;
-      GET_TYPED_DATA(prev, uint64_t, type, buf);
+        GET_TYPED_DATA(prev, uint64_t, type, &pBuf->v);
 
         uint64_t val = GET_UINT64_VAL(tval);
         if ((prev < val) ^ isMinFunc) {
-        *(uint64_t*)buf = val;
-        for (int32_t i = 0; i < (pCtx)->subsidiaries.num; ++i) {
-          SqlFunctionCtx* __ctx = pCtx->subsidiaries.pCtx[i];
-          if (__ctx->functionId == FUNCTION_TS_DUMMY) {  // TODO refactor
-            __ctx->tag.i = key;
-            __ctx->tag.nType = TSDB_DATA_TYPE_BIGINT;
-          }
-
-          __ctx->fpSet.process(__ctx);
+          pBuf->v = val;
+          //          for (int32_t i = 0; i < (pCtx)->subsidiaries.num; ++i) {
+          //            SqlFunctionCtx* __ctx = pCtx->subsidiaries.pCtx[i];
+          //            if (__ctx->functionId == FUNCTION_TS_DUMMY) {  // TODO refactor
+          //              __ctx->tag.i = key;
+          //              __ctx->tag.nType = TSDB_DATA_TYPE_BIGINT;
+          //            }
+          //
+          //            __ctx->fpSet.process(__ctx);
+          //          }
+          if (pCtx->subsidiaries.num > 0) {
+            saveTupleData(pCtx, index, pCtx->pSrcBlock, &pBuf->tuplePos);
           }
         }
       } else if (type == TSDB_DATA_TYPE_DOUBLE) {
+        double prev = 0;
+        GET_TYPED_DATA(prev, int64_t, type, &pBuf->v);
+
         double val = GET_DOUBLE_VAL(tval);
-      UPDATE_DATA(pCtx, *(double*)buf, val, numOfElems, isMinFunc, key);
+        if ((prev < val) ^ isMinFunc) {
+          pBuf->v = val;
+
+          if (pCtx->subsidiaries.num > 0) {
+            saveTupleData(pCtx, index, pCtx->pSrcBlock, &pBuf->tuplePos);
+          }
+        }
       } else if (type == TSDB_DATA_TYPE_FLOAT) {
+        double prev = 0;
+        GET_TYPED_DATA(prev, int64_t, type, &pBuf->v);
+
         double val = GET_DOUBLE_VAL(tval);
-      UPDATE_DATA(pCtx, *(float*)buf, val, numOfElems, isMinFunc, key);
+        if ((prev < val) ^ isMinFunc) {
+          pBuf->v = val;
+        }
+
+        if (pCtx->subsidiaries.num > 0) {
+          saveTupleData(pCtx, index, pCtx->pSrcBlock, &pBuf->tuplePos);
+        }
+      }
     }
 
+    pBuf->assign = true;
     return numOfElems;
   }
 
@@ -843,47 +805,318 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc) {
 
   if (IS_SIGNED_NUMERIC_TYPE(type) || type == TSDB_DATA_TYPE_BOOL) {
     if (type == TSDB_DATA_TYPE_TINYINT || type == TSDB_DATA_TYPE_BOOL) {
-      LOOPCHECK_N(*(int8_t*)buf, pCol, pCtx, int8_t, numOfRows, start, isMinFunc, numOfElems);
+      int8_t* pData = (int8_t*)pCol->pData;
+      int8_t* val = (int8_t*)&pBuf->v;
+
+      for (int32_t i = start; i < start + numOfRows; ++i) {
+        if ((pCol->hasNull) && colDataIsNull_f(pCol->nullbitmap, i)) {
+          continue;
+        }
+
+        if (!pBuf->assign) {
+          *val = pData[i];
+          if (pCtx->subsidiaries.num > 0) {
+            saveTupleData(pCtx, i, pCtx->pSrcBlock, &pBuf->tuplePos);
+          }
+          pBuf->assign = true;
+        } else {
+          // ignore the equivalent data value
+          if ((*val) == pData[i]) {
+            continue;
+          }
+
+          if ((*val < pData[i]) ^ isMinFunc) {
+            *val = pData[i];
+            if (pCtx->subsidiaries.num > 0) {
+              copyTupleData(pCtx, i, pCtx->pSrcBlock, &pBuf->tuplePos);
+            }
+          }
+        }
+
+        numOfElems += 1;
+      }
     } else if (type == TSDB_DATA_TYPE_SMALLINT) {
-      LOOPCHECK_N(*(int16_t*)buf, pCol, pCtx, int16_t, numOfRows, start, isMinFunc, numOfElems);
+      int16_t* pData = (int16_t*)pCol->pData;
+      int16_t* val = (int16_t*)&pBuf->v;
+
+      for (int32_t i = start; i < start + numOfRows; ++i) {
+        if ((pCol->hasNull) && colDataIsNull_f(pCol->nullbitmap, i)) {
+          continue;
+        }
+
+        if (!pBuf->assign) {
+          *val = pData[i];
+          if (pCtx->subsidiaries.num > 0) {
+            saveTupleData(pCtx, i, pCtx->pSrcBlock, &pBuf->tuplePos);
+          }
+          pBuf->assign = true;
+        } else {
+          // ignore the equivalent data value
+          if ((*val) == pData[i]) {
+            continue;
+          }
+
+          if ((*val < pData[i]) ^ isMinFunc) {
+            *val = pData[i];
+            if (pCtx->subsidiaries.num > 0) {
+              copyTupleData(pCtx, i, pCtx->pSrcBlock, &pBuf->tuplePos);
+            }
+          }
+        }
+
+        numOfElems += 1;
+      }
     } else if (type == TSDB_DATA_TYPE_INT) {
       int32_t* pData = (int32_t*)pCol->pData;
-      int32_t* val = (int32_t*)buf;
+      int32_t* val = (int32_t*)&pBuf->v;
 
       for (int32_t i = start; i < start + numOfRows; ++i) {
         if ((pCol->hasNull) && colDataIsNull_f(pCol->nullbitmap, i)) {
           continue;
         }
 
+        if (!pBuf->assign) {
+          *val = pData[i];
+          if (pCtx->subsidiaries.num > 0) {
+            saveTupleData(pCtx, i, pCtx->pSrcBlock, &pBuf->tuplePos);
+          }
+          pBuf->assign = true;
+        } else {
+          // ignore the equivalent data value
+          if ((*val) == pData[i]) {
+            continue;
+          }
+
           if ((*val < pData[i]) ^ isMinFunc) {
             *val = pData[i];
-          TSKEY ts = (pCtx->ptsList != NULL) ? GET_TS_DATA(pCtx, i) : 0;
-          DO_UPDATE_SUBSID_RES(pCtx, ts);
+            if (pCtx->subsidiaries.num > 0) {
+              copyTupleData(pCtx, i, pCtx->pSrcBlock, &pBuf->tuplePos);
+            }
+          }
         }
 
         numOfElems += 1;
       }
-
-#if defined(_DEBUG_VIEW)
-      qDebug("max value updated:%d", *retVal);
-#endif
     } else if (type == TSDB_DATA_TYPE_BIGINT) {
-      LOOPCHECK_N(*(int64_t*)buf, pCol, pCtx, int64_t, numOfRows, start, isMinFunc, numOfElems);
+      int64_t* pData = (int64_t*)pCol->pData;
+      int64_t* val = (int64_t*)&pBuf->v;
+
+      for (int32_t i = start; i < start + numOfRows; ++i) {
+        if ((pCol->hasNull) && colDataIsNull_f(pCol->nullbitmap, i)) {
+          continue;
+        }
+
+        if (!pBuf->assign) {
+          *val = pData[i];
+          if (pCtx->subsidiaries.num > 0) {
+            saveTupleData(pCtx, i, pCtx->pSrcBlock, &pBuf->tuplePos);
+          }
+          pBuf->assign = true;
+        } else {
+          // ignore the equivalent data value
+          if ((*val) == pData[i]) {
+            continue;
+          }
+
+          if ((*val < pData[i]) ^ isMinFunc) {
+            *val = pData[i];
+            if (pCtx->subsidiaries.num > 0) {
+              copyTupleData(pCtx, i, pCtx->pSrcBlock, &pBuf->tuplePos);
+            }
+          }
+        }
+
+        numOfElems += 1;
+      }
     }
   } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
     if (type == TSDB_DATA_TYPE_UTINYINT) {
-      LOOPCHECK_N(*(uint8_t*)buf, pCol, pCtx, uint8_t, numOfRows, start, isMinFunc, numOfElems);
+      uint8_t* pData = (uint8_t*)pCol->pData;
+      uint8_t* val = (uint8_t*)&pBuf->v;
+
+      for (int32_t i = start; i < start + numOfRows; ++i) {
+        if ((pCol->hasNull) && colDataIsNull_f(pCol->nullbitmap, i)) {
+          continue;
+        }
+
+        if (!pBuf->assign) {
+          *val = pData[i];
+          if (pCtx->subsidiaries.num > 0) {
+            saveTupleData(pCtx, i, pCtx->pSrcBlock, &pBuf->tuplePos);
+          }
+          pBuf->assign = true;
+        } else {
+          // ignore the equivalent data value
+          if ((*val) == pData[i]) {
+            continue;
+          }
+
+          if ((*val < pData[i]) ^ isMinFunc) {
+            *val = pData[i];
+            if (pCtx->subsidiaries.num > 0) {
+              copyTupleData(pCtx, i, pCtx->pSrcBlock, &pBuf->tuplePos);
+            }
+          }
+        }
+
+        numOfElems += 1;
+      }
     } else if (type == TSDB_DATA_TYPE_USMALLINT) {
-      LOOPCHECK_N(*(uint16_t*)buf, pCol, pCtx, uint16_t, numOfRows, start, isMinFunc, numOfElems);
+      uint16_t* pData = (uint16_t*)pCol->pData;
+      uint16_t* val = (uint16_t*)&pBuf->v;
+
+      for (int32_t i = start; i < start + numOfRows; ++i) {
+        if ((pCol->hasNull) && colDataIsNull_f(pCol->nullbitmap, i)) {
+          continue;
+        }
+
+        if (!pBuf->assign) {
+          *val = pData[i];
+          if (pCtx->subsidiaries.num > 0) {
+            saveTupleData(pCtx, i, pCtx->pSrcBlock, &pBuf->tuplePos);
+          }
+          pBuf->assign = true;
+        } else {
+          // ignore the equivalent data value
+          if ((*val) == pData[i]) {
+            continue;
+          }
+
+          if ((*val < pData[i]) ^ isMinFunc) {
+            *val = pData[i];
+            if (pCtx->subsidiaries.num > 0) {
+              copyTupleData(pCtx, i, pCtx->pSrcBlock, &pBuf->tuplePos);
+            }
+          }
+        }
+
+        numOfElems += 1;
+      }
     } else if (type == TSDB_DATA_TYPE_UINT) {
-      LOOPCHECK_N(*(uint32_t*)buf, pCol, pCtx, uint32_t, numOfRows, start, isMinFunc, numOfElems);
+      uint32_t* pData = (uint32_t*)pCol->pData;
+      uint32_t* val = (uint32_t*)&pBuf->v;
+
+      for (int32_t i = start; i < start + numOfRows; ++i) {
+        if ((pCol->hasNull) && colDataIsNull_f(pCol->nullbitmap, i)) {
+          continue;
+        }
+
+        if (!pBuf->assign) {
+          *val = pData[i];
+          if (pCtx->subsidiaries.num > 0) {
+            saveTupleData(pCtx, i, pCtx->pSrcBlock, &pBuf->tuplePos);
+          }
+          pBuf->assign = true;
+        } else {
+          // ignore the equivalent data value
+          if ((*val) == pData[i]) {
+            continue;
+          }
+
+          if ((*val < pData[i]) ^ isMinFunc) {
+            *val = pData[i];
+            if (pCtx->subsidiaries.num > 0) {
+              copyTupleData(pCtx, i, pCtx->pSrcBlock, &pBuf->tuplePos);
+            }
+          }
+        }
+
+        numOfElems += 1;
+      }
     } else if (type == TSDB_DATA_TYPE_UBIGINT) {
-      LOOPCHECK_N(*(uint64_t*)buf, pCol, pCtx, uint64_t, numOfRows, start, isMinFunc, numOfElems);
+      uint64_t* pData = (uint64_t*)pCol->pData;
+      uint64_t* val = (uint64_t*)&pBuf->v;
+
+      for (int32_t i = start; i < start + numOfRows; ++i) {
+        if ((pCol->hasNull) && colDataIsNull_f(pCol->nullbitmap, i)) {
+          continue;
+        }
+
+        if (!pBuf->assign) {
+          *val = pData[i];
+          if (pCtx->subsidiaries.num > 0) {
+            saveTupleData(pCtx, i, pCtx->pSrcBlock, &pBuf->tuplePos);
+          }
+          pBuf->assign = true;
+        } else {
+          // ignore the equivalent data value
+          if ((*val) == pData[i]) {
+            continue;
+          }
+
+          if ((*val < pData[i]) ^ isMinFunc) {
+            *val = pData[i];
+            if (pCtx->subsidiaries.num > 0) {
+              copyTupleData(pCtx, i, pCtx->pSrcBlock, &pBuf->tuplePos);
+            }
+          }
+        }
+
+        numOfElems += 1;
+      }
     }
   } else if (type == TSDB_DATA_TYPE_DOUBLE) {
-    LOOPCHECK_N(*(double*)buf, pCol, pCtx, double, numOfRows, start, isMinFunc, numOfElems);
+    double* pData = (double*)pCol->pData;
+    double* val = (double*)&pBuf->v;
+
+    for (int32_t i = start; i < start + numOfRows; ++i) {
+      if ((pCol->hasNull) && colDataIsNull_f(pCol->nullbitmap, i)) {
+        continue;
+      }
+
+      if (!pBuf->assign) {
+        *val = pData[i];
+        if (pCtx->subsidiaries.num > 0) {
+          saveTupleData(pCtx, i, pCtx->pSrcBlock, &pBuf->tuplePos);
+        }
+        pBuf->assign = true;
+      } else {
+        // ignore the equivalent data value
+        if ((*val) == pData[i]) {
+          continue;
+        }
+
+        if ((*val < pData[i]) ^ isMinFunc) {
+          *val = pData[i];
+          if (pCtx->subsidiaries.num > 0) {
+            copyTupleData(pCtx, i, pCtx->pSrcBlock, &pBuf->tuplePos);
+          }
+        }
+      }
+
+      numOfElems += 1;
+    }
   } else if (type == TSDB_DATA_TYPE_FLOAT) {
-    LOOPCHECK_N(*(float*)buf, pCol, pCtx, float, numOfRows, start, isMinFunc, numOfElems);
+    float* pData = (float*)pCol->pData;
+    double* val = (double*)&pBuf->v;
+
+    for (int32_t i = start; i < start + numOfRows; ++i) {
+      if ((pCol->hasNull) && colDataIsNull_f(pCol->nullbitmap, i)) {
+        continue;
+      }
+
+      if (!pBuf->assign) {
+        *val = pData[i];
+        if (pCtx->subsidiaries.num > 0) {
+          saveTupleData(pCtx, i, pCtx->pSrcBlock, &pBuf->tuplePos);
+        }
+        pBuf->assign = true;
+      } else {
+        // ignore the equivalent data value
+        if ((*val) == pData[i]) {
+          continue;
+        }
+
+        if ((*val < pData[i]) ^ isMinFunc) {
+          *val = pData[i];
+          if (pCtx->subsidiaries.num > 0) {
+            copyTupleData(pCtx, i, pCtx->pSrcBlock, &pBuf->tuplePos);
+          }
+        }
+      }
+
+      numOfElems += 1;
+    }
   }
 
   return numOfElems;
@@ -901,6 +1134,65 @@ int32_t maxFunction(SqlFunctionCtx* pCtx) {
   return TSDB_CODE_SUCCESS;
 }
 
+static void setSelectivityValue(SqlFunctionCtx* pCtx, SSDataBlock* pBlock, const STuplePos *pTuplePos, int32_t rowIndex);
+
+int32_t minmaxFunctionFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
+  SResultRowEntryInfo* pEntryInfo = GET_RES_INFO(pCtx);
+
+  SMinmaxResInfo* pRes = GET_ROWCELL_INTERBUF(pEntryInfo);
+
+  int32_t type = pCtx->input.pData[0]->info.type;
+  int32_t slotId = pCtx->pExpr->base.resSchema.slotId;
+
+  SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
+
+  // todo assign the tag value
+  int32_t currentRow = pBlock->info.rows;
+
+  if (pCol->info.type == TSDB_DATA_TYPE_FLOAT) {
+    float v = *(double*) &pRes->v;
+    colDataAppend(pCol, currentRow, (const char*)&v, false);
+  } else {
+    colDataAppend(pCol, currentRow, (const char*)&pRes->v, false);
+  }
+
+  setSelectivityValue(pCtx, pBlock, &pRes->tuplePos, currentRow);
+  return pEntryInfo->numOfRes;
+}
+
+void setSelectivityValue(SqlFunctionCtx* pCtx, SSDataBlock* pBlock, const STuplePos *pTuplePos, int32_t rowIndex) {
+  int32_t pageId = pTuplePos->pageId;
+  int32_t offset = pTuplePos->offset;
+  if (pTuplePos->pageId != -1) {
+    SFilePage* pPage = getBufPage(pCtx->pBuf, pageId);
+
+    bool* nullList = (bool*)((char*)pPage + offset);
+    char* pStart = (char*)(nullList + pCtx->pSrcBlock->info.numOfCols * sizeof(bool));
+
+    // todo set the offset value to optimize the performance.
+    for (int32_t j = 0; j < pCtx->subsidiaries.num; ++j) {
+      SqlFunctionCtx* pc = pCtx->subsidiaries.pCtx[j];
+
+      SFunctParam* pFuncParam = &pc->pExpr->base.pParam[0];
+      int32_t      srcSlotId = pFuncParam->pCol->slotId;
+      int32_t      dstSlotId = pc->pExpr->base.resSchema.slotId;
+
+      int32_t ps = 0;
+      for (int32_t k = 0; k < srcSlotId; ++k) {
+        SColumnInfoData* pSrcCol = taosArrayGet(pCtx->pSrcBlock->pDataBlock, k);
+        ps += pSrcCol->info.bytes;
+      }
+
+      SColumnInfoData* pDstCol = taosArrayGet(pBlock->pDataBlock, dstSlotId);
+      if (nullList[srcSlotId]) {
+        colDataAppendNULL(pDstCol, rowIndex);
+      } else {
+        colDataAppend(pDstCol, rowIndex, (pStart + ps), false);
+      }
+    }
+  }
+}
+
 bool getStddevFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
   pEnv->calcMemSize = sizeof(SStddevRes);
   return true;
@@ -1244,6 +1536,14 @@ bool getFirstLastFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
   return true;
 }
 
+bool getSelectivityFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
+  SColumnNode* pNode = nodesListGetNode(pFunc->pParameterList, 0);
+  pEnv->calcMemSize = pNode->node.resType.bytes;
+  return true;
+}
+
+
+
 static FORCE_INLINE TSKEY getRowPTs(SColumnInfoData* pTsColInfo, int32_t rowIndex) {
   if (pTsColInfo == NULL) {
     return 0;
@@ -1622,35 +1922,49 @@ static STopBotRes* getTopBotOutputInfo(SqlFunctionCtx* pCtx) {
 }
 
 static void doAddIntoResult(SqlFunctionCtx* pCtx, void* pData, int32_t rowIndex, SSDataBlock* pSrcBlock, uint16_t type,
-                            uint64_t uid, SResultRowEntryInfo* pEntryInfo);
-
-static void saveTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, STopBotResItem* pItem);
-static void copyTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, STopBotResItem* pItem);
+                            uint64_t uid, SResultRowEntryInfo* pEntryInfo, bool isTopQuery);
 
 int32_t topFunction(SqlFunctionCtx* pCtx) {
   int32_t              numOfElems = 0;
   SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
 
-  //  if ((void *)pRes->res[0] != (void *)((char *)pRes + sizeof(STopBotRes) + POINTER_BYTES * pCtx->param[0].i)) {
-  //    buildTopBotStruct(pRes, pCtx);
-  //  }
-
   SInputColumnInfoData* pInput = &pCtx->input;
   SColumnInfoData*      pCol = pInput->pData[0];
 
   int32_t type = pInput->pData[0]->info.type;
 
   int32_t start = pInput->startRowIndex;
-  int32_t numOfRows = pInput->numOfRows;
-
-  for (int32_t i = start; i < numOfRows + start; ++i) {
+  for (int32_t i = start; i < pInput->numOfRows + start; ++i) {
     if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) {
       continue;
     }
+
     numOfElems++;
+    char* data = colDataGetData(pCol, i);
+    doAddIntoResult(pCtx, data, i, pCtx->pSrcBlock, type, pInput->uid, pResInfo, true);
+  }
 
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t bottomFunction(SqlFunctionCtx* pCtx) {
+  int32_t              numOfElems = 0;
+  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
+
+  SInputColumnInfoData* pInput = &pCtx->input;
+  SColumnInfoData*      pCol = pInput->pData[0];
+
+  int32_t type = pInput->pData[0]->info.type;
+
+  int32_t start = pInput->startRowIndex;
+  for (int32_t i = start; i < pInput->numOfRows + start; ++i) {
+    if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) {
+      continue;
+    }
+
+    numOfElems++;
     char* data = colDataGetData(pCol, i);
-    doAddIntoResult(pCtx, data, i, pCtx->pSrcBlock, type, pInput->uid, pResInfo);
+    doAddIntoResult(pCtx, data, i, pCtx->pSrcBlock, type, pInput->uid, pResInfo, false);
   }
 
   return TSDB_CODE_SUCCESS;
@@ -1684,7 +1998,7 @@ static int32_t topBotResComparFn(const void* p1, const void* p2, const void* par
 }
 
 void doAddIntoResult(SqlFunctionCtx* pCtx, void* pData, int32_t rowIndex, SSDataBlock* pSrcBlock, uint16_t type,
-                     uint64_t uid, SResultRowEntryInfo* pEntryInfo) {
+                     uint64_t uid, SResultRowEntryInfo* pEntryInfo, bool isTopQuery) {
   STopBotRes* pRes = getTopBotOutputInfo(pCtx);
   int32_t     maxSize = pCtx->param[1].param.i;
 
@@ -1701,30 +2015,36 @@ void doAddIntoResult(SqlFunctionCtx* pCtx, void* pData, int32_t rowIndex, SSData
     pItem->uid = uid;
 
     // save the data of this tuple
-    saveTupleData(pCtx, rowIndex, pSrcBlock, pItem);
+    saveTupleData(pCtx, rowIndex, pSrcBlock, &pItem->tuplePos);
 
     // allocate the buffer and keep the data of this row into the new allocated buffer
     pEntryInfo->numOfRes++;
     taosheapsort((void*)pItems, sizeof(STopBotResItem), pEntryInfo->numOfRes, (const void*)&type, topBotResComparFn,
-                 false);
+                 !isTopQuery);
   } else {  // replace the minimum value in the result
-    if ((IS_SIGNED_NUMERIC_TYPE(type) && val.i > pItems[0].v.i) ||
-        (IS_UNSIGNED_NUMERIC_TYPE(type) && val.u > pItems[0].v.u) || (IS_FLOAT_TYPE(type) && val.d > pItems[0].v.d)) {
+    if ((isTopQuery && (
+        (IS_SIGNED_NUMERIC_TYPE(type) && val.i > pItems[0].v.i) ||
+        (IS_UNSIGNED_NUMERIC_TYPE(type) && val.u > pItems[0].v.u) ||
+        (IS_FLOAT_TYPE(type) && val.d > pItems[0].v.d)))
+        || (!isTopQuery && (
+        (IS_SIGNED_NUMERIC_TYPE(type) && val.i < pItems[0].v.i) ||
+        (IS_UNSIGNED_NUMERIC_TYPE(type) && val.u < pItems[0].v.u) ||
+        (IS_FLOAT_TYPE(type) && val.d < pItems[0].v.d))
+        )) {
       // replace the old data and the coresponding tuple data
       STopBotResItem* pItem = &pItems[0];
       pItem->v = val;
       pItem->uid = uid;
 
       // save the data of this tuple by over writing the old data
-      copyTupleData(pCtx, rowIndex, pSrcBlock, pItem);
-
+      copyTupleData(pCtx, rowIndex, pSrcBlock, &pItem->tuplePos);
       taosheapadjust((void*)pItems, sizeof(STopBotResItem), 0, pEntryInfo->numOfRes - 1, (const void*)&type,
-                     topBotResComparFn, NULL, false);
+                     topBotResComparFn, NULL, !isTopQuery);
     }
   }
 }
 
-void saveTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, STopBotResItem* pItem) {
+void saveTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, STuplePos* pPos) {
   SFilePage* pPage = NULL;
 
   int32_t completeRowSize = pSrcBlock->info.rowSize + pSrcBlock->info.numOfCols * sizeof(bool);
@@ -1740,7 +2060,7 @@ void saveTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pS
     }
   }
 
-  pItem->tuplePos.pageId = pCtx->curBufPage;
+  pPos->pageId = pCtx->curBufPage;
 
   // keep the current row data, extract method
   int32_t offset = 0;
@@ -1751,6 +2071,7 @@ void saveTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pS
     bool             isNull = colDataIsNull_s(pCol, rowIndex);
     if (isNull) {
       nullList[i] = true;
+      offset += pCol->info.bytes;
       continue;
     }
 
@@ -1764,17 +2085,17 @@ void saveTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pS
     offset += pCol->info.bytes;
   }
 
-  pItem->tuplePos.offset = pPage->num;
+  pPos->offset = pPage->num;
   pPage->num += completeRowSize;
 
   setBufPageDirty(pPage, true);
   releaseBufPage(pCtx->pBuf, pPage);
 }
 
-void copyTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, STopBotResItem* pItem) {
-  SFilePage* pPage = getBufPage(pCtx->pBuf, pItem->tuplePos.pageId);
+void copyTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, STuplePos* pPos) {
+  SFilePage* pPage = getBufPage(pCtx->pBuf, pPos->pageId);
 
-  bool* nullList = (bool*)((char*)pPage + pItem->tuplePos.offset);
+  bool* nullList = (bool*)((char*)pPage + pPos->offset);
   char* pStart = (char*)(nullList + pSrcBlock->info.numOfCols * sizeof(bool));
 
   int32_t offset = 0;
@@ -1805,54 +2126,24 @@ int32_t topBotFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
 
   int32_t type = pCtx->input.pData[0]->info.type;
   int32_t slotId = pCtx->pExpr->base.resSchema.slotId;
+
   SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
 
   // todo assign the tag value and the corresponding row data
   int32_t currentRow = pBlock->info.rows;
-  switch (type) {
-    case TSDB_DATA_TYPE_INT: {
   for (int32_t i = 0; i < pEntryInfo->numOfRes; ++i) {
     STopBotResItem* pItem = &pRes->pItems[i];
-        colDataAppendInt32(pCol, currentRow, (int32_t*)&pItem->v.i);
-
-        int32_t pageId = pItem->tuplePos.pageId;
-        int32_t offset = pItem->tuplePos.offset;
-        if (pItem->tuplePos.pageId != -1) {
-          SFilePage* pPage = getBufPage(pCtx->pBuf, pageId);
-
-          bool* nullList = (bool*)((char*)pPage + offset);
-          char* pStart = (char*)(nullList + pCtx->pSrcBlock->info.numOfCols * sizeof(bool));
-
-          // todo set the offset value to optimize the performance.
-          for (int32_t j = 0; j < pCtx->subsidiaries.num; ++j) {
-            SqlFunctionCtx* pc = pCtx->subsidiaries.pCtx[j];
-
-            SFunctParam* pFuncParam = &pc->pExpr->base.pParam[0];
-            int32_t      srcSlotId = pFuncParam->pCol->slotId;
-            int32_t      dstSlotId = pCtx->pExpr->base.resSchema.slotId;
-
-            int32_t ps = 0;
-            for (int32_t k = 0; k < srcSlotId; ++k) {
-              SColumnInfoData* pSrcCol = taosArrayGet(pCtx->pSrcBlock->pDataBlock, k);
-              ps += pSrcCol->info.bytes;
-            }
-
-            SColumnInfoData* pDstCol = taosArrayGet(pBlock->pDataBlock, dstSlotId);
-            if (nullList[srcSlotId]) {
-              colDataAppendNULL(pDstCol, currentRow);
+    if (type == TSDB_DATA_TYPE_FLOAT) {
+      float v = pItem->v.d;
+      colDataAppend(pCol, currentRow, (const char*)&v, false);
     } else {
-              colDataAppend(pDstCol, currentRow, (pStart + ps), false);
-            }
-          }
+      colDataAppend(pCol, currentRow, (const char*)&pItem->v.i, false);
     }
 
+    setSelectivityValue(pCtx, pBlock, &pRes->pItems[i].tuplePos, currentRow);
     currentRow += 1;
   }
 
-      break;
-    }
-  }
-
   return pEntryInfo->numOfRes;
 }
 

tests/script/tsim/insert/basic0.sim

@@ -141,6 +141,7 @@ if $data00 != -13 then
   return -1
 endi
 if $data01 != -2.30000 then
+  print expect -2.30000, actual: $data01
   return -1
 endi
 if $data02 != -3.300000000 then