Merge branch '3.0' into feature/tq

include/common/tcommon.h

@@ -197,6 +197,11 @@ typedef struct SGroupbyExpr {
   bool    groupbyTag;  // group by tag or column
 } SGroupbyExpr;
 
+enum {
+  FUNC_PARAM_TYPE_VALUE = 0,
+  FUNC_PARAM_TYPE_COLUMN,
+};
+
 typedef struct SFunctParam {
   int32_t  type;
   SColumn* pCol;

source/libs/executor/src/executorimpl.c

@@ -241,7 +241,6 @@ static void doSetOperatorCompleted(SOperatorInfo* pOperator) {
     setTaskStatus(pOperator->pTaskInfo, TASK_COMPLETED);
   }
 }
-
 #define OPTR_IS_OPENED(_optr)  (((_optr)->status & OP_OPENED) == OP_OPENED)
 #define OPTR_SET_OPENED(_optr) ((_optr)->status |= OP_OPENED)
 
@@ -1200,8 +1199,19 @@ static void doSetInputDataBlock(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx,
     pCtx[i].size = pBlock->info.rows;
     pCtx[i].currentStage = MAIN_SCAN;
 
+    SExprInfo expr = pOperator->pExpr[i];
+    for (int32_t j = 0; j < expr.base.numOfParams; ++j) {
+      SFunctParam *pFuncParam = &expr.base.pParam[j];
+      if (pFuncParam->type == FUNC_PARAM_TYPE_COLUMN) {
+        int32_t slotId = pFuncParam->pCol->slotId;
+        pCtx[i].input.pData[j]  = taosArrayGet(pBlock->pDataBlock, slotId);
+        pCtx[i].input.totalRows = pBlock->info.rows;
+        pCtx[i].input.numOfRows = pBlock->info.rows;
+        pCtx[i].input.startRowIndex = 0;
+        ASSERT(pCtx[i].input.pData[j] != NULL);
+      }
+    }
     //    setBlockStatisInfo(&pCtx[i], pBlock, pOperator->pExpr[i].base.pColumns);
-    int32_t slotId = pOperator->pExpr[i].base.pParam[0].pCol->slotId;
 
     //      uint32_t flag = pOperator->pExpr[i].base.pParam[0].pCol->flag;
     //      if (TSDB_COL_IS_NORMAL_COL(flag) /*|| (pCtx[i].functionId == FUNCTION_BLKINFO) ||
@@ -1219,12 +1229,11 @@ static void doSetInputDataBlock(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx,
     //        }
 
     // in case of the block distribution query, the inputBytes is not a constant value.
-    pCtx[i].input.pData[0] = taosArrayGet(pBlock->pDataBlock, slotId);
-    pCtx[i].input.totalRows = pBlock->info.rows;
-    pCtx[i].input.numOfRows = pBlock->info.rows;
-    pCtx[i].input.startRowIndex = 0;
+    //pCtx[i].input.pData[0]  = taosArrayGet(pBlock->pDataBlock, slotId);
+    //pCtx[i].input.totalRows = pBlock->info.rows;
+    //pCtx[i].input.numOfRows = pBlock->info.rows;
+    //pCtx[i].input.startRowIndex = 0;
 
-    ASSERT(pCtx[i].input.pData[0] != NULL);
 
     //        uint32_t status = aAggs[pCtx[i].functionId].status;
     //        if ((status & (FUNCSTATE_SELECTIVITY | FUNCSTATE_NEED_TS)) != 0) {
@@ -1282,15 +1291,17 @@ static void projectApplyFunctions(SExprInfo* pExpr, SSDataBlock* pResult, SSData
     } else if (pExpr[k].pExpr->nodeType == QUERY_NODE_FUNCTION) {
       ASSERT(!fmIsAggFunc(pCtx->functionId));
 
-      SScalarParam p = {.numOfRows = pSrcBlock->info.rows};
-      int32_t      slotId = pExpr[k].base.pParam[0].pCol->slotId;
-      p.columnData = taosArrayGet(pSrcBlock->pDataBlock, slotId);
+      SArray* pBlockList = taosArrayInit(4, POINTER_BYTES);
+      taosArrayPush(pBlockList, &pSrcBlock);
 
       SScalarParam dest = {0};
       dest.columnData = taosArrayGet(pResult->pDataBlock, k);
-      pCtx[k].sfp.process(&p, 1, &dest);
 
+      scalarCalculate((SNode *)pExpr[k].pExpr->_function.pFunctNode, pBlockList, &dest);
       pResult->info.rows = dest.numOfRows;
+
+      taosArrayDestroy(pBlockList);
+
     } else {
       ASSERT(0);
     }
@@ -8568,24 +8579,24 @@ SExprInfo* createExprInfo(SNodeList* pNodeList, SNodeList* pGroupKeys, int32_t*
     pExp->pExpr->_function.num = 1;
     pExp->pExpr->_function.functionId = -1;
 
-    pExp->base.pParam = taosMemoryCalloc(1, sizeof(SFunctParam));
-    pExp->base.numOfParams = 1;
-
-    pExp->base.pParam[0].pCol = taosMemoryCalloc(1, sizeof(SColumn));
-    SColumn* pCol = pExp->base.pParam[0].pCol;
-
     // it is a project query, or group by column
     if (nodeType(pTargetNode->pExpr) == QUERY_NODE_COLUMN) {
       pExp->pExpr->nodeType = QUERY_NODE_COLUMN;
       SColumnNode* pColNode = (SColumnNode*)pTargetNode->pExpr;
 
+      pExp->base.pParam = taosMemoryCalloc(1, sizeof(SFunctParam));
+      pExp->base.numOfParams = 1;
+      pExp->base.pParam[0].pCol = taosMemoryCalloc(1, sizeof(SColumn));
+      pExp->base.pParam[0].type = FUNC_PARAM_TYPE_COLUMN;
+
       SDataType* pType = &pColNode->node.resType;
-      pExp->base.resSchema = createResSchema(pType->type, pType->bytes, pTargetNode->slotId, pType->scale,
-                                             pType->precision, pColNode->colName);
-      pCol->slotId = pColNode->slotId;  // TODO refactor
-      pCol->bytes = pType->bytes;
-      pCol->type = pType->type;
-      pCol->scale = pType->scale;
+      pExp->base.resSchema = createResSchema(pType->type, pType->bytes, pTargetNode->slotId, pType->scale, pType->precision, pColNode->colName);
+
+      SColumn* pCol = pExp->base.pParam[0].pCol;
+      pCol->slotId    = pColNode->slotId;   // TODO refactor
+      pCol->bytes     = pType->bytes;
+      pCol->type      = pType->type;
+      pCol->scale     = pType->scale;
       pCol->precision = pType->precision;
     } else if (nodeType(pTargetNode->pExpr) == QUERY_NODE_FUNCTION) {
       pExp->pExpr->nodeType = QUERY_NODE_FUNCTION;
@@ -8602,31 +8613,51 @@ SExprInfo* createExprInfo(SNodeList* pNodeList, SNodeList* pGroupKeys, int32_t*
 
       // TODO: value parameter needs to be handled
       int32_t numOfParam = LIST_LENGTH(pFuncNode->pParameterList);
+
+      pExp->base.pParam = taosMemoryCalloc(numOfParam, sizeof(SFunctParam));
+      pExp->base.numOfParams = numOfParam;
+
       for (int32_t j = 0; j < numOfParam; ++j) {
         SNode*       p1 = nodesListGetNode(pFuncNode->pParameterList, j);
-        SColumnNode* pcn = (SColumnNode*)p1;  // TODO refactor
-
-        pCol->slotId = pcn->slotId;
-        pCol->bytes = pcn->node.resType.bytes;
-        pCol->type = pcn->node.resType.type;
-        pCol->scale = pcn->node.resType.scale;
-        pCol->precision = pcn->node.resType.precision;
-        pCol->dataBlockId = pcn->dataBlockId;
+        if (p1->type == QUERY_NODE_COLUMN) {
+          SColumnNode* pcn = (SColumnNode*)p1;  // TODO refactor
+
+          pExp->base.pParam[j].type = FUNC_PARAM_TYPE_COLUMN;
+          pExp->base.pParam[j].pCol = taosMemoryCalloc(1, sizeof(SColumn));
+          SColumn* pCol = pExp->base.pParam[j].pCol;
+
+          pCol->slotId      = pcn->slotId;
+          pCol->bytes       = pcn->node.resType.bytes;
+          pCol->type        = pcn->node.resType.type;
+          pCol->scale       = pcn->node.resType.scale;
+          pCol->precision   = pcn->node.resType.precision;
+          pCol->dataBlockId = pcn->dataBlockId;
+        } else if (p1->type == QUERY_NODE_VALUE) {
+          SValueNode* pvn = (SValueNode*)p1;
+
+          pExp->base.pParam[j].type = FUNC_PARAM_TYPE_VALUE;
+        }
       }
     } else if (nodeType(pTargetNode->pExpr) == QUERY_NODE_OPERATOR) {
       pExp->pExpr->nodeType = QUERY_NODE_OPERATOR;
       SOperatorNode* pNode = (SOperatorNode*)pTargetNode->pExpr;
 
+      pExp->base.pParam = taosMemoryCalloc(1, sizeof(SFunctParam));
+      pExp->base.numOfParams = 1;
+      pExp->base.pParam[0].pCol = taosMemoryCalloc(1, sizeof(SColumn));
+      pExp->base.pParam[0].type = FUNC_PARAM_TYPE_COLUMN;
+
       SDataType* pType = &pNode->node.resType;
       pExp->base.resSchema = createResSchema(pType->type, pType->bytes, pTargetNode->slotId, pType->scale,
                                              pType->precision, pNode->node.aliasName);
 
       pExp->pExpr->_optrRoot.pRootNode = pTargetNode->pExpr;
 
-      pCol->slotId = pTargetNode->slotId;  // TODO refactor
-      pCol->bytes = pType->bytes;
-      pCol->type = pType->type;
-      pCol->scale = pType->scale;
+      SColumn* pCol   = pExp->base.pParam[0].pCol;
+      pCol->slotId    = pTargetNode->slotId;   // TODO refactor
+      pCol->bytes     = pType->bytes;
+      pCol->type      = pType->type;
+      pCol->scale     = pType->scale;
       pCol->precision = pType->precision;
     } else {
       ASSERT(0);

source/libs/function/src/builtins.c

@@ -173,7 +173,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .finalizeFunc = NULL
   },
   {
-    .name = "power",
+    .name = "pow",
     .type = FUNCTION_TYPE_POW,
     .classification = FUNC_MGT_SCALAR_FUNC,
     .checkFunc    = stubCheckAndGetResultType,
@@ -409,13 +409,29 @@ int32_t stubCheckAndGetResultType(SFunctionNode* pFunc) {
       // todo
       break;
 
-    case FUNCTION_TYPE_ABS: {
+    case FUNCTION_TYPE_ABS:
+    case FUNCTION_TYPE_CEIL:
+    case FUNCTION_TYPE_FLOOR:
+    case FUNCTION_TYPE_ROUND: {
       SColumnNode* pParam = nodesListGetNode(pFunc->pParameterList, 0);
       int32_t paraType = pParam->node.resType.type;
       pFunc->node.resType = (SDataType) { .bytes = tDataTypes[paraType].bytes, .type = paraType };
       break;
     }
 
+    case FUNCTION_TYPE_SIN:
+    case FUNCTION_TYPE_COS:
+    case FUNCTION_TYPE_TAN:
+    case FUNCTION_TYPE_ASIN:
+    case FUNCTION_TYPE_ACOS:
+    case FUNCTION_TYPE_ATAN:
+    case FUNCTION_TYPE_SQRT:
+    case FUNCTION_TYPE_LOG:
+    case FUNCTION_TYPE_POW: {
+      pFunc->node.resType = (SDataType) { .bytes = tDataTypes[TSDB_DATA_TYPE_DOUBLE].bytes, .type = TSDB_DATA_TYPE_DOUBLE };
+      break;
+    }
+
     default:
       ASSERT(0); // to found the fault ASAP.
   }

source/libs/scalar/inc/sclfunc.h

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-#ifndef TDENGINE_TSCALARFUNCTION_H
-#define TDENGINE_TSCALARFUNCTION_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "function.h"
-#include "scalar.h"
-
-
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // TDENGINE_TSCALARFUNCTION_H

source/libs/scalar/src/sclfunc.c

-#include "sclfunc.h"
-#include <common/tdatablock.h>
+#include "function.h"
+#include "scalar.h"
+#include "tdatablock.h"
 #include "sclInt.h"
 #include "sclvector.h"
 
-static void assignBasicParaInfo(struct SScalarParam* dst, const struct SScalarParam* src) {
-//  dst->type = src->type;
-//  dst->bytes = src->bytes;
-//  dst->num = src->num;
-}
-
 /** Math functions **/
 int32_t absFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
   SColumnInfoData *pInputData  = pInput->columnData;
@@ -107,114 +102,62 @@ int32_t absFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutpu
   return TSDB_CODE_SUCCESS;
 }
 
-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;
-  }
-
-  char **input = NULL, *output = NULL;
-  bool hasNullInput = false;
-  input = taosMemoryCalloc(inputNum, sizeof(char *));
-  for (int32_t i = 0; i < pOutput->num; ++i) {
-    for (int32_t j = 0; j < inputNum; ++j) {
-      if (pInput[j].num == 1) {
-        input[j] = pInput[j].data;
-      } else {
-        input[j] = pInput[j].data + i * pInput[j].bytes;
-      }
-      if (isNull(input[j], pInput[j].type)) {
-        hasNullInput = true;
-        break;
-      }
-    }
-    output = pOutput->data + i * pOutput->bytes;
-
-    if (hasNullInput) {
-      setNull(output, pOutput->type, pOutput->bytes);
-      continue;
-    }
-
-    double base;
-    GET_TYPED_DATA(base, double, pInput[1].type, input[1]);
-    double v;
-    GET_TYPED_DATA(v, double, pInput[0].type, input[0]);
-    double result = log(v) / log(base);
-    SET_TYPED_DATA(output, pOutput->type, result);
-  }
-
-  taosMemoryFree(input);
-#endif
+typedef float (*_float_fn)(float);
+typedef double (*_double_fn)(double);
+typedef double (*_double_fn_2)(double, double);
 
-  return TSDB_CODE_SUCCESS;
+double tlog(double v, double base) {
+  return log(v) / log(base);
 }
 
-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)) {
+int32_t doScalarFunctionUnique(SScalarParam *pInput, int32_t inputNum, SScalarParam* pOutput, _double_fn valFn) {
+  int32_t type = GET_PARAM_TYPE(pInput);
+  if (inputNum != 1 || !IS_NUMERIC_TYPE(type)) {
     return TSDB_CODE_FAILED;
   }
 
-  pOutput->type = TSDB_DATA_TYPE_DOUBLE;
-  pOutput->bytes = tDataTypes[TSDB_DATA_TYPE_DOUBLE].bytes;
-
-  char **input = NULL, *output = NULL;
-  bool hasNullInput = false;
-  input = taosMemoryCalloc(inputNum, sizeof(char *));
-  for (int32_t i = 0; i < pOutput->num; ++i) {
-    for (int32_t j = 0; j < inputNum; ++j) {
-      if (pInput[j].num == 1) {
-        input[j] = pInput[j].data;
-      } else {
-        input[j] = pInput[j].data + i * pInput[j].bytes;
-      }
-      if (isNull(input[j], pInput[j].type)) {
-        hasNullInput = true;
-        break;
-      }
-    }
-    output = pOutput->data + i * pOutput->bytes;
+  SColumnInfoData *pInputData = pInput->columnData;
+  SColumnInfoData *pOutputData = pOutput->columnData;
+
+  _getDoubleValue_fn_t getValueFn = getVectorDoubleValueFn(type);
+
+  double *out = (double *)pOutputData->pData;
 
-    if (hasNullInput) {
-      setNull(output, pOutput->type, pOutput->bytes);
+  for (int32_t i = 0; i < pInput->numOfRows; ++i) {
+    if (colDataIsNull_f(pInputData->nullbitmap, i)) {
+      colDataSetNull_f(pOutputData->nullbitmap, i);
       continue;
     }
-
-    double base;
-    GET_TYPED_DATA(base, double, pInput[1].type, input[1]);
-    double v;
-    GET_TYPED_DATA(v, double, pInput[0].type, input[0]);
-    double result = pow(v, base);
-    SET_TYPED_DATA(output, pOutput->type, result);
+    out[i] = valFn(getValueFn(pInputData->pData, i));
   }
 
-  taosMemoryFree(input);
-#endif
+  pOutput->numOfRows = pInput->numOfRows;
   return TSDB_CODE_SUCCESS;
 }
 
-typedef float (*_float_fn)(float);
-typedef double (*_double_fn)(double);
-
-int32_t doScalarFunctionUnique(SScalarParam *pInput, int32_t inputNum, SScalarParam* pOutput, _double_fn valFn) {
-  int32_t type = GET_PARAM_TYPE(pInput);
-  if (inputNum != 1 || !IS_NUMERIC_TYPE(type)) {
+int32_t doScalarFunctionUnique2(SScalarParam *pInput, int32_t inputNum, SScalarParam* pOutput, _double_fn_2 valFn) {
+  if (inputNum != 2 || !IS_NUMERIC_TYPE(GET_PARAM_TYPE(&pInput[0])) || !IS_NUMERIC_TYPE(GET_PARAM_TYPE(&pInput[1]))) {
     return TSDB_CODE_FAILED;
   }
 
-  SColumnInfoData *pInputData = pInput->columnData;
+  SColumnInfoData *pInputData[2];
   SColumnInfoData *pOutputData = pOutput->columnData;
+  _getDoubleValue_fn_t getValueFn[2];
 
-  _getDoubleValue_fn_t getValueFn = getVectorDoubleValueFn(type);
+  for (int32_t i = 0; i < inputNum; ++i) {
+    pInputData[i] = pInput[i].columnData;
+    getValueFn[i]= getVectorDoubleValueFn(GET_PARAM_TYPE(&pInput[i]));
+  }
 
   double *out = (double *)pOutputData->pData;
 
   for (int32_t i = 0; i < pInput->numOfRows; ++i) {
-    if (colDataIsNull_f(pInputData->nullbitmap, i)) {
+    if (colDataIsNull_f(pInputData[0]->nullbitmap, i) ||
+        colDataIsNull_f(pInputData[1]->nullbitmap, 0)) {
       colDataSetNull_f(pOutputData->nullbitmap, i);
       continue;
     }
-    out[i] = valFn(getValueFn(pInputData->pData, i));
+    out[i] = valFn(getValueFn[0](pInputData[0]->pData, i), getValueFn[1](pInputData[1]->pData, 0));
   }
 
   pOutput->numOfRows = pInput->numOfRows;
@@ -292,6 +235,14 @@ int32_t acosFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
   return doScalarFunctionUnique(pInput, inputNum, pOutput, acos);
 }
 
+int32_t powFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
+  return doScalarFunctionUnique2(pInput, inputNum, pOutput, pow);
+}
+
+int32_t logFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
+  return doScalarFunctionUnique2(pInput, inputNum, pOutput, tlog);
+}
+
 int32_t sqrtFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
   return doScalarFunctionUnique(pInput, inputNum, pOutput, sqrt);
 }

source/libs/scalar/test/scalar/scalarTests.cpp

@@ -2833,11 +2833,11 @@ TEST(ScalarFunctionTest, logFunction_column) {
   int32_t rowNum = 3;
   int32_t type;
   int32_t otype = TSDB_DATA_TYPE_DOUBLE;
-  double  result[] = {2.0, 4.0, 3.0};
+  double  result[] = {2.0, 3.0, 4.0};
   pInput = (SScalarParam *)taosMemoryCalloc(2, sizeof(SScalarParam));
 
   //TINYINT
-  int8_t val_tinyint[2][3] = {{25, 81, 64}, {5, 3, 4}};
+  int8_t val_tinyint[2][3] = {{9, 27, 81}, {3, 3, 3}};
   type = TSDB_DATA_TYPE_TINYINT;
   for (int32_t i = 0; i < 2; ++i) {
     scltMakeDataBlock(&input[i], type, 0, rowNum, false);
@@ -2863,7 +2863,7 @@ TEST(ScalarFunctionTest, logFunction_column) {
   scltDestroyDataBlock(pOutput);
 
   //FLOAT
-  float val_float[2][3] = {{25.0, 81.0, 64.0}, {5.0, 3.0, 4.0}};
+  float val_float[2][3] = {{9.0, 27.0, 81.0}, {3.0, 3.0, 3.0}};
   type = TSDB_DATA_TYPE_FLOAT;
   for (int32_t i = 0; i < 2; ++i) {
     scltMakeDataBlock(&input[i], type, 0, rowNum, false);
@@ -2888,8 +2888,8 @@ TEST(ScalarFunctionTest, logFunction_column) {
   scltDestroyDataBlock(pOutput);
 
   //TINYINT AND FLOAT
-  int8_t param0[] = {25, 81, 64};
-  float  param1[] = {5.0, 3.0, 4.0};
+  int8_t param0[] = {9, 27, 81};
+  float  param1[] = {3.0, 3.0, 3.0};
   scltMakeDataBlock(&input[0], TSDB_DATA_TYPE_TINYINT, 0, rowNum, false);
   pInput[0] = *input[0];
   for (int32_t i = 0; i < rowNum; ++i) {
@@ -3003,17 +3003,17 @@ TEST(ScalarFunctionTest, powFunction_column) {
   int32_t rowNum = 3;
   int32_t type;
   int32_t otype = TSDB_DATA_TYPE_DOUBLE;
-  double  result[] = {32.0, 27.0, 16.0};
+  double  result[] = {8.0, 27.0, 64.0};
   pInput = (SScalarParam *)taosMemoryCalloc(2, sizeof(SScalarParam));
 
   //TINYINT
-  int8_t val_tinyint[2][3] = {{2, 3, 4}, {5, 3, 2}};
+  int8_t val_tinyint[2][3] = {{2, 3, 4}, {3, 3, 3}};
   type = TSDB_DATA_TYPE_TINYINT;
   for (int32_t i = 0; i < 2; ++i) {
     scltMakeDataBlock(&input[i], type, 0, rowNum, false);
     pInput[i] = *input[i];
     for (int32_t j = 0; j < rowNum; ++j) {
-      colDataAppend(pInput[i].columnData, i, (const char*) &val_tinyint[i][j], false);
+      colDataAppend(pInput[i].columnData, j, (const char*) &val_tinyint[i][j], false);
 
     }
     PRINTF("tiny_int before POW:%d,%d,%d\n", *((int8_t *)pInput[i].data + 0),
@@ -3034,7 +3034,7 @@ TEST(ScalarFunctionTest, powFunction_column) {
   scltDestroyDataBlock(pOutput);
 
   //FLOAT
-  float val_float[2][3] = {{2.0, 3.0, 4.0}, {5.0, 3.0, 2.0}};
+  float val_float[2][3] = {{2.0, 3.0, 4.0}, {3.0, 3.0, 3.0}};
   type = TSDB_DATA_TYPE_FLOAT;
   for (int32_t i = 0; i < 2; ++i) {
     scltMakeDataBlock(&input[i], type, 0, rowNum, false);
@@ -3060,7 +3060,7 @@ TEST(ScalarFunctionTest, powFunction_column) {
 
   //TINYINT AND FLOAT
   int8_t param0[] = {2, 3, 4};
-  float  param1[] = {5.0, 3.0, 2.0};
+  float  param1[] = {3.0, 3.0, 2.0};
   scltMakeDataBlock(&input[0], TSDB_DATA_TYPE_TINYINT, 0, rowNum, false);
   pInput[0] = *input[0];
   for (int32_t i = 0; i < rowNum; ++i) {