diff --git a/source/libs/scalar/src/sclfunc.c b/source/libs/scalar/src/sclfunc.c
index 7b18f566d1..c54c6c121f 100644
--- a/source/libs/scalar/src/sclfunc.c
+++ b/source/libs/scalar/src/sclfunc.c
@@ -21,85 +21,80 @@ int32_t absFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutpu
 
   switch (type) {
     case TSDB_DATA_TYPE_FLOAT: {
+      float *in  = (float *)pInputData->pData;
+      float *out = (float *)pOutputData->pData;
       for (int32_t i = 0; i < pOutput->numOfRows; ++i) {
         if (colDataIsNull_f(pInputData->nullbitmap, i)) {
           colDataAppendNULL(pOutputData, i);
           continue;
         }
-
-        float *in = (float *)pInputData->pData;
-        float *out = (float *)pOutputData;
-        in[i] = (out[i] > 0)? out[i] : -out[i];
+        out[i] = (in[i] > 0)? in[i] : -in[i];
       }
       break;
     }
 
     case TSDB_DATA_TYPE_DOUBLE: {
+      double *in  = (double *)pInputData->pData;
+      double *out = (double *)pOutputData->pData;
       for (int32_t i = 0; i < pOutput->numOfRows; ++i) {
         if (colDataIsNull_f(pInputData->nullbitmap, i)) {
           colDataAppendNULL(pOutputData, i);
           continue;
         }
-
-        double *in = (double *)pInputData->pData;
-        double *out = (double *)pOutputData;
-        in[i] = (out[i] > 0)? out[i] : -out[i];
+        out[i] = (in[i] > 0)? in[i] : -in[i];
       }
       break;
     }
 
     case TSDB_DATA_TYPE_TINYINT: {
+      int8_t *in  = (int8_t *)pInputData->pData;
+      int8_t *out = (int8_t *)pOutputData->pData;
       for (int32_t i = 0; i < pOutput->numOfRows; ++i) {
         if (colDataIsNull_f(pInputData->nullbitmap, i)) {
           colDataAppendNULL(pOutputData, i);
           continue;
         }
-
-        int8_t *in = (int8_t *)pInputData->pData;
-        int8_t *out = (int8_t *)pOutputData;
-        in[i] = (out[i] > 0)? out[i] : -out[i];
+        out[i] = (in[i] > 0)? in[i] : -in[i];
       }
       break;
     }
 
     case TSDB_DATA_TYPE_SMALLINT: {
+      int16_t *in  = (int16_t *)pInputData->pData;
+      int16_t *out = (int16_t *)pOutputData->pData;
       for (int32_t i = 0; i < pOutput->numOfRows; ++i) {
         if (colDataIsNull_f(pInputData->nullbitmap, i)) {
           colDataAppendNULL(pOutputData, i);
           continue;
         }
-
-        int16_t *in = (int16_t *)pInputData->pData;
-        int16_t *out = (int16_t *)pOutputData;
-        in[i] = (out[i] > 0)? out[i] : -out[i];
+        out[i] = (in[i] > 0)? in[i] : -in[i];
       }
       break;
     }
 
     case TSDB_DATA_TYPE_INT: {
+      int32_t *in  = (int32_t *)pInputData->pData;
+      int32_t *out = (int32_t *)pOutputData->pData;
+
       for (int32_t i = 0; i < pOutput->numOfRows; ++i) {
         if (colDataIsNull_f(pInputData->nullbitmap, i)) {
           colDataAppendNULL(pOutputData, i);
           continue;
         }
-
-        int32_t *in = (int32_t *)pInputData->pData;
-        int32_t *out = (int32_t *)pOutputData;
-        in[i] = (out[i] > 0) ? out[i] : -out[i];
+        out[i] = (in[i] > 0)? in[i] : -in[i];
       }
       break;
     }
 
     case TSDB_DATA_TYPE_BIGINT: {
+      int64_t *in  = (int64_t *)pInputData->pData;
+      int64_t *out = (int64_t *)pOutputData->pData;
       for (int32_t i = 0; i < pOutput->numOfRows; ++i) {
         if (colDataIsNull_f(pInputData->nullbitmap, i)) {
           colDataAppendNULL(pOutputData, i);
           continue;
         }
-
-        int64_t *in = (int64_t *)pInputData->pData;
-        int64_t *out = (int64_t *)pOutputData;
-        in[i] = (out[i] > 0) ? out[i] : -out[i];
+        out[i] = (in[i] > 0)? in[i] : -in[i];
       }
       break;
     }
@@ -114,6 +109,7 @@ int32_t absFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutpu
 }
 
 int32_t logFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
+#if 0
   if (inputNum != 2 || !IS_NUMERIC_TYPE(pInput[0].type) || !IS_NUMERIC_TYPE(pInput[1].type)) {
     return TSDB_CODE_FAILED;
   }
@@ -149,11 +145,13 @@ int32_t logFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutpu
   }
 
   taosMemoryFree(input);
+#endif
 
   return TSDB_CODE_SUCCESS;
 }
 
 int32_t powFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
+#if 0
   if (inputNum != 2 || !IS_NUMERIC_TYPE(pInput[0].type) || !IS_NUMERIC_TYPE(pInput[1].type)) {
     return TSDB_CODE_FAILED;
   }
@@ -192,11 +190,12 @@ int32_t powFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutpu
   }
 
   taosMemoryFree(input);
-
+#endif
   return TSDB_CODE_SUCCESS;
 }
 
 int32_t sqrtFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
+#if 0
   if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) {
     return TSDB_CODE_FAILED;
   }
@@ -223,11 +222,12 @@ int32_t sqrtFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
     double result = sqrt(v);
     SET_TYPED_DATA(output, pOutput->type, result);
   }
-
+#endif
   return TSDB_CODE_SUCCESS;
 }
 
 int32_t sinFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
+#if 0
   if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) {
     return TSDB_CODE_FAILED;
   }
@@ -254,11 +254,13 @@ int32_t sinFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutpu
     double result = sin(v);
     SET_TYPED_DATA(output, pOutput->type, result);
   }
+#endif
 
   return TSDB_CODE_SUCCESS;
 }
 
 int32_t cosFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
+#if 0
   if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) {
     return TSDB_CODE_FAILED;
   }
@@ -285,11 +287,12 @@ int32_t cosFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutpu
     double result = cos(v);
     SET_TYPED_DATA(output, pOutput->type, result);
   }
-
+#endif
   return TSDB_CODE_SUCCESS;
 }
 
 int32_t tanFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
+#if 0
   if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) {
     return TSDB_CODE_FAILED;
   }
@@ -316,11 +319,12 @@ int32_t tanFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutpu
     double result = tan(v);
     SET_TYPED_DATA(output, pOutput->type, result);
   }
-
+#endif
   return TSDB_CODE_SUCCESS;
 }
 
 int32_t asinFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
+#if 0
   if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) {
     return TSDB_CODE_FAILED;
   }
@@ -347,11 +351,12 @@ int32_t asinFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
     double result = asin(v);
     SET_TYPED_DATA(output, pOutput->type, result);
   }
-
+#endif
   return TSDB_CODE_SUCCESS;
 }
 
 int32_t acosFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
+#if 0
   if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) {
     return TSDB_CODE_FAILED;
   }
@@ -378,11 +383,12 @@ int32_t acosFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
     double result = acos(v);
     SET_TYPED_DATA(output, pOutput->type, result);
   }
-
+#endif
   return TSDB_CODE_SUCCESS;
 }
 
 int32_t atanFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
+#if 0
   if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) {
     return TSDB_CODE_FAILED;
   }
@@ -409,147 +415,149 @@ int32_t atanFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
     double result = atan(v);
     SET_TYPED_DATA(output, pOutput->type, result);
   }
-
+#endif
   return TSDB_CODE_SUCCESS;
 }
 
+//TODO use callback function [ceilf, ceil]
 int32_t ceilFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
-  if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) {
+  int32_t type = GET_PARAM_TYPE(pInput);
+  if (inputNum != 1 || !IS_NUMERIC_TYPE(type)) {
     return TSDB_CODE_FAILED;
   }
 
-  char *input = NULL, *output = NULL;
-  for (int32_t i = 0; i < pOutput->num; ++i) {
-    if (pInput->num == 1) {
-      input = pInput->data;
-    } else {
-      input = pInput->data + i * pInput->bytes;
-    }
-    output = pOutput->data + i * pOutput->bytes;
+  SColumnInfoData *pInputData  = pInput->columnData;
+  SColumnInfoData *pOutputData = pOutput->columnData;
 
-    if (isNull(input, pInput->type)) {
-      setNull(output, pOutput->type, pOutput->bytes);
-      continue;
+  switch (type) {
+    case TSDB_DATA_TYPE_FLOAT: {
+      float *in  = (float *)pInputData->pData;
+      float *out = (float *)pOutputData->pData;
+
+      for (int32_t i = 0; i < pOutput->numOfRows; ++i) {
+        if (colDataIsNull_f(pInputData->nullbitmap, i)) {
+          colDataAppendNULL(pOutputData, i);
+          continue;
+        }
+        out[i] = ceilf(in[i]);
+      }
+      break;
     }
 
-    switch (pInput->type) {
-      case TSDB_DATA_TYPE_FLOAT: {
-        float v;
-        GET_TYPED_DATA(v, float, pInput->type, input);
-        float result = ceilf(v);
-        SET_TYPED_DATA(output, pOutput->type, result);
-        break;
-      }
+    case TSDB_DATA_TYPE_DOUBLE: {
+      double *in  = (double *)pInputData->pData;
+      double *out = (double *)pOutputData->pData;
 
-      case TSDB_DATA_TYPE_DOUBLE: {
-        double v;
-        GET_TYPED_DATA(v, double, pInput->type, input);
-        double result = ceil(v);
-        SET_TYPED_DATA(output, pOutput->type, result);
-        break;
+      for (int32_t i = 0; i < pOutput->numOfRows; ++i) {
+        if (colDataIsNull_f(pInputData->nullbitmap, i)) {
+          colDataAppendNULL(pOutputData, i);
+          continue;
+        }
+        out[i] = ceil(in[i]);
       }
+      break;
+    }
 
-      default: {
-        memcpy(output, input, pInput->bytes);
-        break;
-      }
+    default: {
+      colDataAssign(pOutputData, pInputData, pInput->numOfRows);
     }
   }
 
+  pOutput->numOfRows = pInput->numOfRows;
   return TSDB_CODE_SUCCESS;
 }
 
 int32_t floorFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
-  assignBasicParaInfo(pOutput, pInput);
-  if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) {
+  int32_t type = GET_PARAM_TYPE(pInput);
+  if (inputNum != 1 || !IS_NUMERIC_TYPE(type)) {
     return TSDB_CODE_FAILED;
   }
 
-  char *input = NULL, *output = NULL;
-  for (int32_t i = 0; i < pOutput->num; ++i) {
-    if (pInput->num == 1) {
-      input = pInput->data;
-    } else {
-      input = pInput->data + i * pInput->bytes;
-    }
-    output = pOutput->data + i * pOutput->bytes;
+  SColumnInfoData *pInputData  = pInput->columnData;
+  SColumnInfoData *pOutputData = pOutput->columnData;
 
-    if (isNull(input, pInput->type)) {
-      setNull(output, pOutput->type, pOutput->bytes);
-      continue;
+  switch (type) {
+    case TSDB_DATA_TYPE_FLOAT: {
+      float *in  = (float *)pInputData->pData;
+      float *out = (float *)pOutputData->pData;
+
+      for (int32_t i = 0; i < pOutput->numOfRows; ++i) {
+        if (colDataIsNull_f(pInputData->nullbitmap, i)) {
+          colDataAppendNULL(pOutputData, i);
+          continue;
+        }
+        out[i] = floorf(in[i]);
+      }
+      break;
     }
 
-    switch (pInput->type) {
-      case TSDB_DATA_TYPE_FLOAT: {
-        float v;
-        GET_TYPED_DATA(v, float, pInput->type, input);
-        float result = floorf(v);
-        SET_TYPED_DATA(output, pOutput->type, result);
-        break;
-      }
+    case TSDB_DATA_TYPE_DOUBLE: {
+      double *in  = (double *)pInputData->pData;
+      double *out = (double *)pOutputData->pData;
 
-      case TSDB_DATA_TYPE_DOUBLE: {
-        double v;
-        GET_TYPED_DATA(v, double, pInput->type, input);
-        double result = floor(v);
-        SET_TYPED_DATA(output, pOutput->type, result);
-        break;
+      for (int32_t i = 0; i < pOutput->numOfRows; ++i) {
+        if (colDataIsNull_f(pInputData->nullbitmap, i)) {
+          colDataAppendNULL(pOutputData, i);
+          continue;
+        }
+        out[i] = floor(in[i]);
       }
+      break;
+    }
 
-      default: {
-        memcpy(output, input, pInput->bytes);
-        break;
-      }
+    default: {
+      colDataAssign(pOutputData, pInputData, pInput->numOfRows);
     }
   }
 
+  pOutput->numOfRows = pInput->numOfRows;
   return TSDB_CODE_SUCCESS;
 }
 
 int32_t roundFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
-  assignBasicParaInfo(pOutput, pInput);
-  if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) {
+  int32_t type = GET_PARAM_TYPE(pInput);
+  if (inputNum != 1 || !IS_NUMERIC_TYPE(type)) {
     return TSDB_CODE_FAILED;
   }
 
-  char *input = NULL, *output = NULL;
-  for (int32_t i = 0; i < pOutput->num; ++i) {
-    if (pInput->num == 1) {
-      input = pInput->data;
-    } else {
-      input = pInput->data + i * pInput->bytes;
-    }
-    output = pOutput->data + i * pOutput->bytes;
+  SColumnInfoData *pInputData  = pInput->columnData;
+  SColumnInfoData *pOutputData = pOutput->columnData;
 
-    if (isNull(input, pInput->type)) {
-      setNull(output, pOutput->type, pOutput->bytes);
-      continue;
+  switch (type) {
+    case TSDB_DATA_TYPE_FLOAT: {
+      float *in  = (float *)pInputData->pData;
+      float *out = (float *)pOutputData->pData;
+
+      for (int32_t i = 0; i < pOutput->numOfRows; ++i) {
+        if (colDataIsNull_f(pInputData->nullbitmap, i)) {
+          colDataAppendNULL(pOutputData, i);
+          continue;
+        }
+        out[i] = roundf(in[i]);
+      }
+      break;
     }
 
-    switch (pInput->type) {
-      case TSDB_DATA_TYPE_FLOAT: {
-        float v;
-        GET_TYPED_DATA(v, float, pInput->type, input);
-        float result = roundf(v);
-        SET_TYPED_DATA(output, pOutput->type, result);
-        break;
-      }
+    case TSDB_DATA_TYPE_DOUBLE: {
+      double *in  = (double *)pInputData->pData;
+      double *out = (double *)pOutputData->pData;
 
-      case TSDB_DATA_TYPE_DOUBLE: {
-        double v;
-        GET_TYPED_DATA(v, double, pInput->type, input);
-        double result = round(v);
-        SET_TYPED_DATA(output, pOutput->type, result);
-        break;
+      for (int32_t i = 0; i < pOutput->numOfRows; ++i) {
+        if (colDataIsNull_f(pInputData->nullbitmap, i)) {
+          colDataAppendNULL(pOutputData, i);
+          continue;
+        }
+        out[i] = round(in[i]);
       }
+      break;
+    }
 
-      default: {
-        memcpy(output, input, pInput->bytes);
-        break;
-      }
+    default: {
+      colDataAssign(pOutputData, pInputData, pInput->numOfRows);
     }
   }
 
+  pOutput->numOfRows = pInput->numOfRows;
   return TSDB_CODE_SUCCESS;
 }
 
@@ -671,153 +679,3 @@ static void reverseCopy(char* dest, const char* src, int16_t type, int32_t numOf
   }
 }
 
-static void setScalarFuncParam(SScalarParam* param, int32_t type, int32_t bytes, void* pInput, int32_t numOfRows) {
-//  param->bytes = bytes;
-//  param->type = type;
-//  param->num  = numOfRows;
-//  param->data = pInput;
-}
-
-#if 0
-int32_t evaluateExprNodeTree(tExprNode* pExprs, int32_t numOfRows, SScalarFuncParam* pOutput, void* param,
-                          char* (*getSourceDataBlock)(void*, const char*, int32_t)) {
-  if (pExprs == NULL) {
-    return 0;
-  }
-
-  tExprNode* pLeft = pExprs->_node.pLeft;
-  tExprNode* pRight = pExprs->_node.pRight;
-
-  /* the left output has result from the left child syntax tree */
-  SScalarFuncParam leftOutput = {0};
-  SScalarFuncParam rightOutput = {0};
-
-  if (pLeft->nodeType == TEXPR_BINARYEXPR_NODE || pLeft->nodeType == TEXPR_UNARYEXPR_NODE) {
-    leftOutput.data = taosMemoryMalloc(sizeof(int64_t) * numOfRows);
-    evaluateExprNodeTree(pLeft, numOfRows, &leftOutput, param, getSourceDataBlock);
-  }
-
-  // the right output has result from the right child syntax tree
-  if (pRight->nodeType == TEXPR_BINARYEXPR_NODE || pRight->nodeType == TEXPR_UNARYEXPR_NODE) {
-    rightOutput.data = taosMemoryMalloc(sizeof(int64_t) * numOfRows);
-    evaluateExprNodeTree(pRight, numOfRows, &rightOutput, param, getSourceDataBlock);
-  }
-
-  if (pExprs->nodeType == TEXPR_BINARYEXPR_NODE) {
-    _bin_scalar_fn_t OperatorFn = getBinScalarOperatorFn(pExprs->_node.optr);
-
-    SScalarFuncParam left = {0}, right = {0};
-    if (pLeft->nodeType == TEXPR_BINARYEXPR_NODE || pLeft->nodeType == TEXPR_UNARYEXPR_NODE) {
-      setScalarFuncParam(&left, leftOutput.type, leftOutput.bytes, leftOutput.data, leftOutput.num);
-    } else if (pLeft->nodeType == TEXPR_COL_NODE) {
-      SSchema* pschema = pLeft->pSchema;
-      char*    pLeftInputData = getSourceDataBlock(param, pschema->name, pschema->colId);
-      setScalarFuncParam(&right, pschema->type, pschema->bytes, pLeftInputData, numOfRows);
-    } else if (pLeft->nodeType == TEXPR_VALUE_NODE) {
-      SVariant* pVar = pRight->pVal;
-      setScalarFuncParam(&left, pVar->nType, pVar->nLen, &pVar->i, 1);
-    }
-
-    if (pRight->nodeType == TEXPR_BINARYEXPR_NODE || pRight->nodeType == TEXPR_UNARYEXPR_NODE) {
-      setScalarFuncParam(&right, rightOutput.type, rightOutput.bytes, rightOutput.data, rightOutput.num);
-    } else if (pRight->nodeType == TEXPR_COL_NODE) {  // exprLeft + columnRight
-      SSchema* pschema = pRight->pSchema;
-      char*    pInputData = getSourceDataBlock(param, pschema->name, pschema->colId);
-      setScalarFuncParam(&right, pschema->type, pschema->bytes, pInputData, numOfRows);
-    } else if (pRight->nodeType == TEXPR_VALUE_NODE) {  // exprLeft + 12
-      SVariant* pVar = pRight->pVal;
-      setScalarFuncParam(&right, pVar->nType, pVar->nLen, &pVar->i, 1);
-    }
-
-    void* outputBuf = pOutput->data;
-    if (isStringOp(pExprs->_node.optr)) {
-      outputBuf = taosMemoryRealloc(pOutput->data, (left.bytes + right.bytes) * left.num);
-    }
-
-    OperatorFn(&left, &right, outputBuf, TSDB_ORDER_ASC);
-    // Set the result info
-    setScalarFuncParam(pOutput, TSDB_DATA_TYPE_DOUBLE, sizeof(double), outputBuf, numOfRows);
-  } else if (pExprs->nodeType == TEXPR_UNARYEXPR_NODE) {
-    _unary_scalar_fn_t OperatorFn = getUnaryScalarOperatorFn(pExprs->_node.optr);
-    SScalarFuncParam   left = {0};
-
-    if (pLeft->nodeType == TEXPR_BINARYEXPR_NODE || pLeft->nodeType == TEXPR_UNARYEXPR_NODE) {
-      setScalarFuncParam(&left, leftOutput.type, leftOutput.bytes, leftOutput.data, leftOutput.num);
-    } else if (pLeft->nodeType == TEXPR_COL_NODE) {
-      SSchema* pschema = pLeft->pSchema;
-      char*    pLeftInputData = getSourceDataBlock(param, pschema->name, pschema->colId);
-      setScalarFuncParam(&left, pschema->type, pschema->bytes, pLeftInputData, numOfRows);
-    } else if (pLeft->nodeType == TEXPR_VALUE_NODE) {
-      SVariant* pVar = pLeft->pVal;
-      setScalarFuncParam(&left, pVar->nType, pVar->nLen, &pVar->i, 1);
-    }
-
-    // reserve enough memory buffer
-    if (isBinaryStringOp(pExprs->_node.optr)) {
-      void* outputBuf = taosMemoryRealloc(pOutput->data, left.bytes * left.num);
-      assert(outputBuf != NULL);
-      pOutput->data = outputBuf;
-    }
-
-    OperatorFn(&left, pOutput);
-  }
-
-  taosMemoryFreeClear(leftOutput.data);
-  taosMemoryFreeClear(rightOutput.data);
-
-  return 0;
-}
-#endif
-
-
-//SScalarFunctionInfo scalarFunc[8] = {
-//    {"ceil",   FUNCTION_TYPE_SCALAR, FUNCTION_CEIL,   tceil},
-//    {"floor",  FUNCTION_TYPE_SCALAR, FUNCTION_FLOOR,  tfloor},
-//    {"abs",    FUNCTION_TYPE_SCALAR, FUNCTION_ABS,    _tabs},
-//    {"round",  FUNCTION_TYPE_SCALAR, FUNCTION_ROUND,  tround},
-//    {"length", FUNCTION_TYPE_SCALAR, FUNCTION_LENGTH, tlength},
-//    {"concat", FUNCTION_TYPE_SCALAR, FUNCTION_CONCAT, tconcat},
-//    {"ltrim",  FUNCTION_TYPE_SCALAR, FUNCTION_LTRIM, tltrim},
-//    {"rtrim",  FUNCTION_TYPE_SCALAR, FUNCTION_RTRIM, trtrim},
-//};
-
-void setScalarFunctionSupp(struct SScalarFunctionSupport* sas, SExprInfo *pExprInfo, SSDataBlock* pSDataBlock) {
-  sas->numOfCols = (int32_t) pSDataBlock->info.numOfCols;
-  sas->pExprInfo = pExprInfo;
-  if (sas->colList != NULL) {
-    return;
-  }
-
-  sas->colList = taosMemoryCalloc(1, pSDataBlock->info.numOfCols*sizeof(SColumnInfo));
-  for(int32_t i = 0; i < sas->numOfCols; ++i) {
-    SColumnInfoData* pColData = taosArrayGet(pSDataBlock->pDataBlock, i);
-    sas->colList[i] = pColData->info;
-  }
-
-  sas->data = taosMemoryCalloc(sas->numOfCols, POINTER_BYTES);
-
-  // set the input column data
-  for (int32_t f = 0; f < pSDataBlock->info.numOfCols; ++f) {
-    SColumnInfoData *pColumnInfoData = taosArrayGet(pSDataBlock->pDataBlock, f);
-    sas->data[f] = pColumnInfoData->pData;
-  }
-}
-
-SScalarFunctionSupport* createScalarFuncSupport(int32_t num) {
-  SScalarFunctionSupport* pSupp = taosMemoryCalloc(num, sizeof(SScalarFunctionSupport));
-  return pSupp;
-}
-
-void destroyScalarFuncSupport(struct SScalarFunctionSupport* pSupport, int32_t num) {
-  if (pSupport == NULL) {
-    return;
-  }
-
-  for(int32_t i = 0; i < num; ++i) {
-    SScalarFunctionSupport* pSupp = &pSupport[i];
-    taosMemoryFreeClear(pSupp->data);
-    taosMemoryFreeClear(pSupp->colList);
-  }
-
-  taosMemoryFreeClear(pSupport);
-}
diff --git a/source/libs/scalar/src/sclvector.c b/source/libs/scalar/src/sclvector.c
index 5b5bb62992..dcd4e57ff3 100644
--- a/source/libs/scalar/src/sclvector.c
+++ b/source/libs/scalar/src/sclvector.c
@@ -279,7 +279,7 @@ static FORCE_INLINE void varToBool(char *buf, SScalarParam* pOut, int32_t rowInd
 
 int32_t vectorConvertFromVarData(SScalarParam* pIn, SScalarParam* pOut, int32_t inType, int32_t outType) {
   int32_t bufSize = pIn->columnData->info.bytes;
-  char *tmp = malloc(bufSize);
+  char *tmp = taosMemoryMalloc(bufSize);
 
   _bufConverteFunc func = NULL;
   if (TSDB_DATA_TYPE_BOOL == outType) {