xxq250
/
homework-jianmu
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

[TD-14240]<feature>: add math functions

This commit is contained in:
Ganlin Zhao 2022-03-25 16:24:36 +08:00
parent eef9b77490
commit 303a853c0c
7 changed files with 270 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
include/libs/function/functionMgt.h
View File

@ -57,18 +57,19 @@ typedef enum EFunctionType {
// math function // math function
FUNCTION_TYPE_ABS = 1000, FUNCTION_TYPE_ABS = 1000,
FUNCTION_TYPE_ACOS,
FUNCTION_TYPE_ASION,
FUNCTION_TYPE_ATAN,
FUNCTION_TYPE_CEIL,
FUNCTION_TYPE_COS,
FUNCTION_TYPE_FLOOR,
FUNCTION_TYPE_LOG, FUNCTION_TYPE_LOG,
FUNCTION_TYPE_POW, FUNCTION_TYPE_POW,
FUNCTION_TYPE_ROUND,
FUNCTION_TYPE_SIN,
FUNCTION_TYPE_SQRT, FUNCTION_TYPE_SQRT,
FUNCTION_TYPE_CEIL,
FUNCTION_TYPE_FLOOR,
FUNCTION_TYPE_ROUND,
FUNCTION_TYPE_SIN,
FUNCTION_TYPE_COS,
FUNCTION_TYPE_TAN, FUNCTION_TYPE_TAN,
FUNCTION_TYPE_ASIN,
FUNCTION_TYPE_ACOS,
FUNCTION_TYPE_ATAN,
// string function // string function
FUNCTION_TYPE_CHAR_LENGTH = 1500, FUNCTION_TYPE_CHAR_LENGTH = 1500,

15
include/libs/scalar/scalar.h
View File

@ -42,6 +42,21 @@ int32_t scalarGenerateSetFromList(void **data, void *pNode, uint32_t type);
int32_t vectorGetConvertType(int32_t type1, int32_t type2); int32_t vectorGetConvertType(int32_t type1, int32_t type2);
int32_t vectorConvertImpl(SScalarParam* pIn, SScalarParam* pOut); int32_t vectorConvertImpl(SScalarParam* pIn, SScalarParam* pOut);
int32_t absFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t logFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t powFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t sqrtFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t sinFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t cosFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t tanFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t asinFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t acosFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t atanFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t ceilFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t floorFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t roundFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
#ifdef __cplusplus #ifdef __cplusplus
} }

4
source/libs/function/CMakeLists.txt
View File

@ -8,5 +8,5 @@ target_include_directories(
target_link_libraries( target_link_libraries(
function function
PRIVATE os util common nodes PRIVATE os util common nodes scalar
) )

131
source/libs/function/src/builtins.c
View File

@ -15,6 +15,7 @@
#include "builtins.h" #include "builtins.h"
#include "builtinsimpl.h" #include "builtinsimpl.h"
#include "scalar.h"
#include "taoserror.h" #include "taoserror.h"
#include "tdatablock.h" #include "tdatablock.h"
@ -151,6 +152,136 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
.processFunc = lastFunction, .processFunc = lastFunction,
.finalizeFunc = functionFinalize .finalizeFunc = functionFinalize
}, },
{
.name = "abs",
.type = FUNCTION_TYPE_ABS,
.classification = FUNC_MGT_SCALAR_FUNC,
.checkFunc = stubCheckAndGetResultType,
.getEnvFunc = NULL,
.initFunc = NULL,
.sprocessFunc = absFunction,
.finalizeFunc = NULL
},
{
.name = "log",
.type = FUNCTION_TYPE_LOG,
.classification = FUNC_MGT_SCALAR_FUNC,
.checkFunc = stubCheckAndGetResultType,
.getEnvFunc = NULL,
.initFunc = NULL,
.sprocessFunc = logFunction,
.finalizeFunc = NULL
},
{
.name = "power",
.type = FUNCTION_TYPE_POW,
.classification = FUNC_MGT_SCALAR_FUNC,
.checkFunc = stubCheckAndGetResultType,
.getEnvFunc = NULL,
.initFunc = NULL,
.sprocessFunc = powFunction,
.finalizeFunc = NULL
},
{
.name = "sqrt",
.type = FUNCTION_TYPE_SQRT,
.classification = FUNC_MGT_SCALAR_FUNC,
.checkFunc = stubCheckAndGetResultType,
.getEnvFunc = NULL,
.initFunc = NULL,
.sprocessFunc = sqrtFunction,
.finalizeFunc = NULL
},
{
.name = "ceil",
.type = FUNCTION_TYPE_CEIL,
.classification = FUNC_MGT_SCALAR_FUNC,
.checkFunc = stubCheckAndGetResultType,
.getEnvFunc = NULL,
.initFunc = NULL,
.sprocessFunc = ceilFunction,
.finalizeFunc = NULL
},
{
.name = "floor",
.type = FUNCTION_TYPE_FLOOR,
.classification = FUNC_MGT_SCALAR_FUNC,
.checkFunc = stubCheckAndGetResultType,
.getEnvFunc = NULL,
.initFunc = NULL,
.sprocessFunc = floorFunction,
.finalizeFunc = NULL
},
{
.name = "round",
.type = FUNCTION_TYPE_ROUND,
.classification = FUNC_MGT_SCALAR_FUNC,
.checkFunc = stubCheckAndGetResultType,
.getEnvFunc = NULL,
.initFunc = NULL,
.sprocessFunc = roundFunction,
.finalizeFunc = NULL
},
{
.name = "sin",
.type = FUNCTION_TYPE_SIN,
.classification = FUNC_MGT_SCALAR_FUNC,
.checkFunc = stubCheckAndGetResultType,
.getEnvFunc = NULL,
.initFunc = NULL,
.sprocessFunc = sinFunction,
.finalizeFunc = NULL
},
{
.name = "cos",
.type = FUNCTION_TYPE_COS,
.classification = FUNC_MGT_SCALAR_FUNC,
.checkFunc = stubCheckAndGetResultType,
.getEnvFunc = NULL,
.initFunc = NULL,
.sprocessFunc = cosFunction,
.finalizeFunc = NULL
},
{
.name = "tan",
.type = FUNCTION_TYPE_TAN,
.classification = FUNC_MGT_SCALAR_FUNC,
.checkFunc = stubCheckAndGetResultType,
.getEnvFunc = NULL,
.initFunc = NULL,
.sprocessFunc = tanFunction,
.finalizeFunc = NULL
},
{
.name = "asin",
.type = FUNCTION_TYPE_ASIN,
.classification = FUNC_MGT_SCALAR_FUNC,
.checkFunc = stubCheckAndGetResultType,
.getEnvFunc = NULL,
.initFunc = NULL,
.sprocessFunc = asinFunction,
.finalizeFunc = NULL
},
{
.name = "acos",
.type = FUNCTION_TYPE_ACOS,
.classification = FUNC_MGT_SCALAR_FUNC,
.checkFunc = stubCheckAndGetResultType,
.getEnvFunc = NULL,
.initFunc = NULL,
.sprocessFunc = acosFunction,
.finalizeFunc = NULL
},
{
.name = "atan",
.type = FUNCTION_TYPE_ATAN,
.classification = FUNC_MGT_SCALAR_FUNC,
.checkFunc = stubCheckAndGetResultType,
.getEnvFunc = NULL,
.initFunc = NULL,
.sprocessFunc = atanFunction,
.finalizeFunc = NULL
},
{ {
.name = "concat", .name = "concat",
.type = FUNCTION_TYPE_CONCAT, .type = FUNCTION_TYPE_CONCAT,

15
source/libs/scalar/inc/sclfunc.h
View File

@ -36,21 +36,6 @@ extern struct SScalarFunctionInfo scalarFunc[8];
int32_t evaluateExprNodeTree(tExprNode* pExprs, int32_t numOfRows, SScalarParam* pOutput, int32_t evaluateExprNodeTree(tExprNode* pExprs, int32_t numOfRows, SScalarParam* pOutput,
void* param, char* (*getSourceDataBlock)(void*, const char*, int32_t)); void* param, char* (*getSourceDataBlock)(void*, const char*, int32_t));
int32_t abs_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t log_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t pow_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t sqrt_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t sin_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t cos_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t tan_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t asin_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t acos_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t atan_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t ceil_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t floor_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t round_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
#ifdef __cplusplus #ifdef __cplusplus
} }

26
source/libs/scalar/src/sclfunc.c
View File

@ -8,7 +8,7 @@ static void assignBasicParaInfo(struct SScalarParam* dst, const struct SScalarPa
} }
/** Math functions **/ /** Math functions **/
int32_t abs_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { int32_t absFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
assignBasicParaInfo(pOutput, pInput); assignBasicParaInfo(pOutput, pInput);
if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) { if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) {
return TSDB_CODE_FAILED; return TSDB_CODE_FAILED;
@ -93,7 +93,7 @@ int32_t abs_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
int32_t log_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { int32_t logFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
if (inputNum != 2 || !IS_NUMERIC_TYPE(pInput[0].type) || !IS_NUMERIC_TYPE(pInput[1].type)) { if (inputNum != 2 || !IS_NUMERIC_TYPE(pInput[0].type) || !IS_NUMERIC_TYPE(pInput[1].type)) {
return TSDB_CODE_FAILED; return TSDB_CODE_FAILED;
} }
@ -136,7 +136,7 @@ int32_t log_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
int32_t pow_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { int32_t powFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
if (inputNum != 2 || !IS_NUMERIC_TYPE(pInput[0].type) || !IS_NUMERIC_TYPE(pInput[1].type)) { if (inputNum != 2 || !IS_NUMERIC_TYPE(pInput[0].type) || !IS_NUMERIC_TYPE(pInput[1].type)) {
return TSDB_CODE_FAILED; return TSDB_CODE_FAILED;
} }
@ -179,7 +179,7 @@ int32_t pow_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
int32_t sqrt_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { int32_t sqrtFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) { if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) {
return TSDB_CODE_FAILED; return TSDB_CODE_FAILED;
} }
@ -210,7 +210,7 @@ int32_t sqrt_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOut
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
int32_t sin_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { int32_t sinFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) { if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) {
return TSDB_CODE_FAILED; return TSDB_CODE_FAILED;
} }
@ -241,7 +241,7 @@ int32_t sin_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
int32_t cos_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { int32_t cosFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) { if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) {
return TSDB_CODE_FAILED; return TSDB_CODE_FAILED;
} }
@ -272,7 +272,7 @@ int32_t cos_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
int32_t tan_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { int32_t tanFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) { if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) {
return TSDB_CODE_FAILED; return TSDB_CODE_FAILED;
} }
@ -303,7 +303,7 @@ int32_t tan_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
int32_t asin_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { int32_t asinFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) { if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) {
return TSDB_CODE_FAILED; return TSDB_CODE_FAILED;
} }
@ -334,7 +334,7 @@ int32_t asin_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOut
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
int32_t acos_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { int32_t acosFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) { if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) {
return TSDB_CODE_FAILED; return TSDB_CODE_FAILED;
} }
@ -365,7 +365,7 @@ int32_t acos_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOut
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
int32_t atan_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { int32_t atanFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) { if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) {
return TSDB_CODE_FAILED; return TSDB_CODE_FAILED;
} }
@ -396,7 +396,7 @@ int32_t atan_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOut
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
int32_t ceil_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { int32_t ceilFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) { if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) {
return TSDB_CODE_FAILED; return TSDB_CODE_FAILED;
} }
@ -442,7 +442,7 @@ int32_t ceil_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOut
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
int32_t floor_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { int32_t floorFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
assignBasicParaInfo(pOutput, pInput); assignBasicParaInfo(pOutput, pInput);
if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) { if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) {
return TSDB_CODE_FAILED; return TSDB_CODE_FAILED;
@ -489,7 +489,7 @@ int32_t floor_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOu
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
int32_t round_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { int32_t roundFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
assignBasicParaInfo(pOutput, pInput); assignBasicParaInfo(pOutput, pInput);
if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) { if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) {
return TSDB_CODE_FAILED; return TSDB_CODE_FAILED;

201
source/libs/scalar/test/scalar/scalarTests.cpp
View File

@ -36,7 +36,6 @@
#include "tdatablock.h" #include "tdatablock.h"
#include "stub.h" #include "stub.h"
#include "scalar.h" #include "scalar.h"
#include "sclfunc.h"
#include "nodes.h" #include "nodes.h"
#include "tlog.h" #include "tlog.h"
@ -1492,7 +1491,7 @@ void scltDestroyDataBlock(SScalarParam *pInput) {
free(pInput); free(pInput);
} }
TEST(ScalarFunctionTest, abs_function_constant) { TEST(ScalarFunctionTest, absFunction_constant) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
int32_t rowNum = 3; int32_t rowNum = 3;
@ -1504,7 +1503,7 @@ TEST(ScalarFunctionTest, abs_function_constant) {
scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false); scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
code = abs_function(pInput, 1, pOutput); code = absFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((int8_t *)pOutput->data + i), val_tinyint); ASSERT_EQ(*((int8_t *)pOutput->data + i), val_tinyint);
@ -1516,7 +1515,7 @@ TEST(ScalarFunctionTest, abs_function_constant) {
scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false); scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
code = abs_function(pInput, 1, pOutput); code = absFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((int8_t *)pOutput->data + i), -val_tinyint); ASSERT_EQ(*((int8_t *)pOutput->data + i), -val_tinyint);
@ -1530,7 +1529,7 @@ TEST(ScalarFunctionTest, abs_function_constant) {
scltMakeDataBlock(&pInput, type, &val_smallint, 1, true); scltMakeDataBlock(&pInput, type, &val_smallint, 1, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false); scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
code = abs_function(pInput, 1, pOutput); code = absFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((int16_t *)pOutput->data + i), val_smallint); ASSERT_EQ(*((int16_t *)pOutput->data + i), val_smallint);
@ -1542,7 +1541,7 @@ TEST(ScalarFunctionTest, abs_function_constant) {
scltMakeDataBlock(&pInput, type, &val_smallint, 1, true); scltMakeDataBlock(&pInput, type, &val_smallint, 1, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false); scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
code = abs_function(pInput, 1, pOutput); code = absFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((int16_t *)pOutput->data + i), -val_smallint); ASSERT_EQ(*((int16_t *)pOutput->data + i), -val_smallint);
@ -1556,7 +1555,7 @@ TEST(ScalarFunctionTest, abs_function_constant) {
scltMakeDataBlock(&pInput, type, &val_int, 1, true); scltMakeDataBlock(&pInput, type, &val_int, 1, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false); scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
code = abs_function(pInput, 1, pOutput); code = absFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((int32_t *)pOutput->data + i), val_int); ASSERT_EQ(*((int32_t *)pOutput->data + i), val_int);
@ -1568,7 +1567,7 @@ TEST(ScalarFunctionTest, abs_function_constant) {
scltMakeDataBlock(&pInput, type, &val_int, 1, true); scltMakeDataBlock(&pInput, type, &val_int, 1, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false); scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
code = abs_function(pInput, 1, pOutput); code = absFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((int32_t *)pOutput->data + i), -val_int); ASSERT_EQ(*((int32_t *)pOutput->data + i), -val_int);
@ -1582,7 +1581,7 @@ TEST(ScalarFunctionTest, abs_function_constant) {
scltMakeDataBlock(&pInput, type, &val_bigint, 1, true); scltMakeDataBlock(&pInput, type, &val_bigint, 1, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false); scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
code = abs_function(pInput, 1, pOutput); code = absFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((int64_t *)pOutput->data + i), val_bigint); ASSERT_EQ(*((int64_t *)pOutput->data + i), val_bigint);
@ -1594,7 +1593,7 @@ TEST(ScalarFunctionTest, abs_function_constant) {
scltMakeDataBlock(&pInput, type, &val_bigint, rowNum, true); scltMakeDataBlock(&pInput, type, &val_bigint, rowNum, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false); scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
code = abs_function(pInput, 1, pOutput); code = absFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((int64_t *)pOutput->data + i), -val_bigint); ASSERT_EQ(*((int64_t *)pOutput->data + i), -val_bigint);
@ -1609,7 +1608,7 @@ TEST(ScalarFunctionTest, abs_function_constant) {
scltMakeDataBlock(&pOutput, type, 0, rowNum, false); scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
PRINTF("float before ABS:%f\n", *(float *)pInput->data); PRINTF("float before ABS:%f\n", *(float *)pInput->data);
code = abs_function(pInput, 1, pOutput); code = absFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((float *)pOutput->data + i), val_float); ASSERT_EQ(*((float *)pOutput->data + i), val_float);
@ -1623,7 +1622,7 @@ TEST(ScalarFunctionTest, abs_function_constant) {
scltMakeDataBlock(&pOutput, type, 0, rowNum, false); scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
PRINTF("float before ABS:%f\n", *(float *)pInput->data); PRINTF("float before ABS:%f\n", *(float *)pInput->data);
code = abs_function(pInput, 1, pOutput); code = absFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((float *)pOutput->data + i), -val_float); ASSERT_EQ(*((float *)pOutput->data + i), -val_float);
@ -1638,7 +1637,7 @@ TEST(ScalarFunctionTest, abs_function_constant) {
scltMakeDataBlock(&pInput, type, &val_double, 1, true); scltMakeDataBlock(&pInput, type, &val_double, 1, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false); scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
code = abs_function(pInput, 1, pOutput); code = absFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), val_double); ASSERT_EQ(*((double *)pOutput->data + i), val_double);
@ -1650,7 +1649,7 @@ TEST(ScalarFunctionTest, abs_function_constant) {
scltMakeDataBlock(&pInput, type, &val_double, rowNum, true); scltMakeDataBlock(&pInput, type, &val_double, rowNum, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false); scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
code = abs_function(pInput, 1, pOutput); code = absFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), -val_double); ASSERT_EQ(*((double *)pOutput->data + i), -val_double);
@ -1660,7 +1659,7 @@ TEST(ScalarFunctionTest, abs_function_constant) {
} }
TEST(ScalarFunctionTest, abs_function_column) { TEST(ScalarFunctionTest, absFunction_column) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
int32_t rowNum = 5; int32_t rowNum = 5;
@ -1676,7 +1675,7 @@ TEST(ScalarFunctionTest, abs_function_column) {
PRINTF("tiny_int before ABS:%d\n", *((int8_t *)pInput->data + i)); PRINTF("tiny_int before ABS:%d\n", *((int8_t *)pInput->data + i));
} }
code = abs_function(pInput, 1, pOutput); code = absFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((int8_t *)pOutput->data + i), val_tinyint + i); ASSERT_EQ(*((int8_t *)pOutput->data + i), val_tinyint + i);
@ -1693,7 +1692,7 @@ TEST(ScalarFunctionTest, abs_function_column) {
PRINTF("tiny_int before ABS:%d\n", *((int8_t *)pInput->data + i)); PRINTF("tiny_int before ABS:%d\n", *((int8_t *)pInput->data + i));
} }
code = abs_function(pInput, 1, pOutput); code = absFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((int8_t *)pOutput->data + i), -(val_tinyint + i)); ASSERT_EQ(*((int8_t *)pOutput->data + i), -(val_tinyint + i));
@ -1713,7 +1712,7 @@ TEST(ScalarFunctionTest, abs_function_column) {
} }
code = abs_function(pInput, 1, pOutput); code = absFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((int16_t *)pOutput->data + i), val_smallint + i); ASSERT_EQ(*((int16_t *)pOutput->data + i), val_smallint + i);
@ -1730,7 +1729,7 @@ TEST(ScalarFunctionTest, abs_function_column) {
PRINTF("small_int before ABS:%d\n", *((int16_t *)pInput->data + i)); PRINTF("small_int before ABS:%d\n", *((int16_t *)pInput->data + i));
} }
code = abs_function(pInput, 1, pOutput); code = absFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((int16_t *)pOutput->data + i), -(val_smallint + i)); ASSERT_EQ(*((int16_t *)pOutput->data + i), -(val_smallint + i));
@ -1750,7 +1749,7 @@ TEST(ScalarFunctionTest, abs_function_column) {
} }
code = abs_function(pInput, 1, pOutput); code = absFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((int32_t *)pOutput->data + i), val_int + i); ASSERT_EQ(*((int32_t *)pOutput->data + i), val_int + i);
@ -1767,7 +1766,7 @@ TEST(ScalarFunctionTest, abs_function_column) {
PRINTF("int before ABS:%d\n", *((int32_t *)pInput->data + i)); PRINTF("int before ABS:%d\n", *((int32_t *)pInput->data + i));
} }
code = abs_function(pInput, 1, pOutput); code = absFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((int32_t *)pOutput->data + i), -(val_int + i)); ASSERT_EQ(*((int32_t *)pOutput->data + i), -(val_int + i));
@ -1786,7 +1785,7 @@ TEST(ScalarFunctionTest, abs_function_column) {
PRINTF("float before ABS:%f\n", *((float *)pInput->data + i)); PRINTF("float before ABS:%f\n", *((float *)pInput->data + i));
} }
code = abs_function(pInput, 1, pOutput); code = absFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((float *)pOutput->data + i), val_float + i); ASSERT_EQ(*((float *)pOutput->data + i), val_float + i);
@ -1803,7 +1802,7 @@ TEST(ScalarFunctionTest, abs_function_column) {
PRINTF("float before ABS:%f\n", *((float *)pInput->data + i)); PRINTF("float before ABS:%f\n", *((float *)pInput->data + i));
} }
code = abs_function(pInput, 1, pOutput); code = absFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((float *)pOutput->data + i), -(val_float + i)); ASSERT_EQ(*((float *)pOutput->data + i), -(val_float + i));
@ -1822,7 +1821,7 @@ TEST(ScalarFunctionTest, abs_function_column) {
PRINTF("double before ABS:%f\n", *((double *)pInput->data + i)); PRINTF("double before ABS:%f\n", *((double *)pInput->data + i));
} }
code = abs_function(pInput, 1, pOutput); code = absFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), val_double + i); ASSERT_EQ(*((double *)pOutput->data + i), val_double + i);
@ -1839,7 +1838,7 @@ TEST(ScalarFunctionTest, abs_function_column) {
PRINTF("double before ABS:%f\n", *((double *)pInput->data + i)); PRINTF("double before ABS:%f\n", *((double *)pInput->data + i));
} }
code = abs_function(pInput, 1, pOutput); code = absFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), -(val_double + i)); ASSERT_EQ(*((double *)pOutput->data + i), -(val_double + i));
@ -1850,7 +1849,7 @@ TEST(ScalarFunctionTest, abs_function_column) {
scltDestroyDataBlock(pOutput); scltDestroyDataBlock(pOutput);
} }
TEST(ScalarFunctionTest, sin_function_constant) { TEST(ScalarFunctionTest, sinFunction_constant) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
int32_t rowNum = 3; int32_t rowNum = 3;
@ -1865,7 +1864,7 @@ TEST(ScalarFunctionTest, sin_function_constant) {
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("tiny_int before SIN:%d\n", *((int8_t *)pInput->data)); PRINTF("tiny_int before SIN:%d\n", *((int8_t *)pInput->data));
code = sin_function(pInput, 1, pOutput); code = sinFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result); ASSERT_EQ(*((double *)pOutput->data + i), result);
@ -1881,7 +1880,7 @@ TEST(ScalarFunctionTest, sin_function_constant) {
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("float before SIN:%f\n", *((float *)pInput->data)); PRINTF("float before SIN:%f\n", *((float *)pInput->data));
code = sin_function(pInput, 1, pOutput); code = sinFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result); ASSERT_EQ(*((double *)pOutput->data + i), result);
@ -1893,7 +1892,7 @@ TEST(ScalarFunctionTest, sin_function_constant) {
} }
TEST(ScalarFunctionTest, sin_function_column) { TEST(ScalarFunctionTest, sinFunction_column) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
int32_t rowNum = 3; int32_t rowNum = 3;
@ -1912,7 +1911,7 @@ TEST(ScalarFunctionTest, sin_function_column) {
PRINTF("tiny_int before SIN:%d\n", *((int8_t *)pInput->data + i)); PRINTF("tiny_int before SIN:%d\n", *((int8_t *)pInput->data + i));
} }
code = sin_function(pInput, 1, pOutput); code = sinFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result[i]); ASSERT_EQ(*((double *)pOutput->data + i), result[i]);
@ -1931,7 +1930,7 @@ TEST(ScalarFunctionTest, sin_function_column) {
PRINTF("float before SIN:%f\n", *((float *)pInput->data + i)); PRINTF("float before SIN:%f\n", *((float *)pInput->data + i));
} }
code = sin_function(pInput, 1, pOutput); code = sinFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result[i]); ASSERT_EQ(*((double *)pOutput->data + i), result[i]);
@ -1942,7 +1941,7 @@ TEST(ScalarFunctionTest, sin_function_column) {
scltDestroyDataBlock(pOutput); scltDestroyDataBlock(pOutput);
} }
TEST(ScalarFunctionTest, cos_function_constant) { TEST(ScalarFunctionTest, cosFunction_constant) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
int32_t rowNum = 3; int32_t rowNum = 3;
@ -1957,7 +1956,7 @@ TEST(ScalarFunctionTest, cos_function_constant) {
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("tiny_int before COS:%d\n", *((int8_t *)pInput->data)); PRINTF("tiny_int before COS:%d\n", *((int8_t *)pInput->data));
code = cos_function(pInput, 1, pOutput); code = cosFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result); ASSERT_EQ(*((double *)pOutput->data + i), result);
@ -1973,7 +1972,7 @@ TEST(ScalarFunctionTest, cos_function_constant) {
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("float before COS:%f\n", *((float *)pInput->data)); PRINTF("float before COS:%f\n", *((float *)pInput->data));
code = cos_function(pInput, 1, pOutput); code = cosFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result); ASSERT_EQ(*((double *)pOutput->data + i), result);
@ -1984,7 +1983,7 @@ TEST(ScalarFunctionTest, cos_function_constant) {
scltDestroyDataBlock(pOutput); scltDestroyDataBlock(pOutput);
} }
TEST(ScalarFunctionTest, cos_function_column) { TEST(ScalarFunctionTest, cosFunction_column) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
int32_t rowNum = 3; int32_t rowNum = 3;
@ -2002,7 +2001,7 @@ TEST(ScalarFunctionTest, cos_function_column) {
PRINTF("tiny_int before COS:%d\n", *((int8_t *)pInput->data + i)); PRINTF("tiny_int before COS:%d\n", *((int8_t *)pInput->data + i));
} }
code = cos_function(pInput, 1, pOutput); code = cosFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result[i]); ASSERT_EQ(*((double *)pOutput->data + i), result[i]);
@ -2021,7 +2020,7 @@ TEST(ScalarFunctionTest, cos_function_column) {
PRINTF("float before COS:%f\n", *((float *)pInput->data + i)); PRINTF("float before COS:%f\n", *((float *)pInput->data + i));
} }
code = cos_function(pInput, 1, pOutput); code = cosFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result[i]); ASSERT_EQ(*((double *)pOutput->data + i), result[i]);
@ -2032,7 +2031,7 @@ TEST(ScalarFunctionTest, cos_function_column) {
scltDestroyDataBlock(pOutput); scltDestroyDataBlock(pOutput);
} }
TEST(ScalarFunctionTest, tan_function_constant) { TEST(ScalarFunctionTest, tanFunction_constant) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
int32_t rowNum = 3; int32_t rowNum = 3;
@ -2047,7 +2046,7 @@ TEST(ScalarFunctionTest, tan_function_constant) {
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("tiny_int before TAN:%d\n", *((int8_t *)pInput->data)); PRINTF("tiny_int before TAN:%d\n", *((int8_t *)pInput->data));
code = tan_function(pInput, 1, pOutput); code = tanFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result); ASSERT_EQ(*((double *)pOutput->data + i), result);
@ -2063,7 +2062,7 @@ TEST(ScalarFunctionTest, tan_function_constant) {
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("float before TAN:%f\n", *((float *)pInput->data)); PRINTF("float before TAN:%f\n", *((float *)pInput->data));
code = tan_function(pInput, 1, pOutput); code = tanFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result); ASSERT_EQ(*((double *)pOutput->data + i), result);
@ -2074,7 +2073,7 @@ TEST(ScalarFunctionTest, tan_function_constant) {
scltDestroyDataBlock(pOutput); scltDestroyDataBlock(pOutput);
} }
TEST(ScalarFunctionTest, tan_function_column) { TEST(ScalarFunctionTest, tanFunction_column) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
int32_t rowNum = 3; int32_t rowNum = 3;
@ -2092,7 +2091,7 @@ TEST(ScalarFunctionTest, tan_function_column) {
PRINTF("tiny_int before TAN:%d\n", *((int8_t *)pInput->data + i)); PRINTF("tiny_int before TAN:%d\n", *((int8_t *)pInput->data + i));
} }
code = tan_function(pInput, 1, pOutput); code = tanFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result[i]); ASSERT_EQ(*((double *)pOutput->data + i), result[i]);
@ -2111,7 +2110,7 @@ TEST(ScalarFunctionTest, tan_function_column) {
PRINTF("float before TAN:%f\n", *((float *)pInput->data + i)); PRINTF("float before TAN:%f\n", *((float *)pInput->data + i));
} }
code = tan_function(pInput, 1, pOutput); code = tanFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result[i]); ASSERT_EQ(*((double *)pOutput->data + i), result[i]);
@ -2122,7 +2121,7 @@ TEST(ScalarFunctionTest, tan_function_column) {
scltDestroyDataBlock(pOutput); scltDestroyDataBlock(pOutput);
} }
TEST(ScalarFunctionTest, asin_function_constant) { TEST(ScalarFunctionTest, asinFunction_constant) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
int32_t rowNum = 3; int32_t rowNum = 3;
@ -2137,7 +2136,7 @@ TEST(ScalarFunctionTest, asin_function_constant) {
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("tiny_int before ASIN:%d\n", *((int8_t *)pInput->data)); PRINTF("tiny_int before ASIN:%d\n", *((int8_t *)pInput->data));
code = asin_function(pInput, 1, pOutput); code = asinFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result); ASSERT_EQ(*((double *)pOutput->data + i), result);
@ -2153,7 +2152,7 @@ TEST(ScalarFunctionTest, asin_function_constant) {
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("float before ASIN:%f\n", *((float *)pInput->data)); PRINTF("float before ASIN:%f\n", *((float *)pInput->data));
code = asin_function(pInput, 1, pOutput); code = asinFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result); ASSERT_EQ(*((double *)pOutput->data + i), result);
@ -2164,7 +2163,7 @@ TEST(ScalarFunctionTest, asin_function_constant) {
scltDestroyDataBlock(pOutput); scltDestroyDataBlock(pOutput);
} }
TEST(ScalarFunctionTest, asin_function_column) { TEST(ScalarFunctionTest, asinFunction_column) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
int32_t rowNum = 3; int32_t rowNum = 3;
@ -2183,7 +2182,7 @@ TEST(ScalarFunctionTest, asin_function_column) {
PRINTF("tiny_int before ASIN:%d\n", *((int8_t *)pInput->data + i)); PRINTF("tiny_int before ASIN:%d\n", *((int8_t *)pInput->data + i));
} }
code = asin_function(pInput, 1, pOutput); code = asinFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result[i]); ASSERT_EQ(*((double *)pOutput->data + i), result[i]);
@ -2202,7 +2201,7 @@ TEST(ScalarFunctionTest, asin_function_column) {
PRINTF("float before ASIN:%f\n", *((float *)pInput->data + i)); PRINTF("float before ASIN:%f\n", *((float *)pInput->data + i));
} }
code = asin_function(pInput, 1, pOutput); code = asinFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result[i]); ASSERT_EQ(*((double *)pOutput->data + i), result[i]);
@ -2213,7 +2212,7 @@ TEST(ScalarFunctionTest, asin_function_column) {
scltDestroyDataBlock(pOutput); scltDestroyDataBlock(pOutput);
} }
TEST(ScalarFunctionTest, acos_function_constant) { TEST(ScalarFunctionTest, acosFunction_constant) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
int32_t rowNum = 3; int32_t rowNum = 3;
@ -2228,7 +2227,7 @@ TEST(ScalarFunctionTest, acos_function_constant) {
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("tiny_int before ACOS:%d\n", *((int8_t *)pInput->data)); PRINTF("tiny_int before ACOS:%d\n", *((int8_t *)pInput->data));
code = acos_function(pInput, 1, pOutput); code = acosFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result); ASSERT_EQ(*((double *)pOutput->data + i), result);
@ -2244,7 +2243,7 @@ TEST(ScalarFunctionTest, acos_function_constant) {
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("float before ACOS:%f\n", *((float *)pInput->data)); PRINTF("float before ACOS:%f\n", *((float *)pInput->data));
code = acos_function(pInput, 1, pOutput); code = acosFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result); ASSERT_EQ(*((double *)pOutput->data + i), result);
@ -2255,7 +2254,7 @@ TEST(ScalarFunctionTest, acos_function_constant) {
scltDestroyDataBlock(pOutput); scltDestroyDataBlock(pOutput);
} }
TEST(ScalarFunctionTest, acos_function_column) { TEST(ScalarFunctionTest, acosFunction_column) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
int32_t rowNum = 3; int32_t rowNum = 3;
@ -2273,7 +2272,7 @@ TEST(ScalarFunctionTest, acos_function_column) {
PRINTF("tiny_int before ACOS:%d\n", *((int8_t *)pInput->data + i)); PRINTF("tiny_int before ACOS:%d\n", *((int8_t *)pInput->data + i));
} }
code = acos_function(pInput, 1, pOutput); code = acosFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result[i]); ASSERT_EQ(*((double *)pOutput->data + i), result[i]);
@ -2292,7 +2291,7 @@ TEST(ScalarFunctionTest, acos_function_column) {
PRINTF("float before ACOS:%f\n", *((float *)pInput->data + i)); PRINTF("float before ACOS:%f\n", *((float *)pInput->data + i));
} }
code = acos_function(pInput, 1, pOutput); code = acosFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result[i]); ASSERT_EQ(*((double *)pOutput->data + i), result[i]);
@ -2303,7 +2302,7 @@ TEST(ScalarFunctionTest, acos_function_column) {
scltDestroyDataBlock(pOutput); scltDestroyDataBlock(pOutput);
} }
TEST(ScalarFunctionTest, atan_function_constant) { TEST(ScalarFunctionTest, atanFunction_constant) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
int32_t rowNum = 3; int32_t rowNum = 3;
@ -2318,7 +2317,7 @@ TEST(ScalarFunctionTest, atan_function_constant) {
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("tiny_int before ATAN:%d\n", *((int8_t *)pInput->data)); PRINTF("tiny_int before ATAN:%d\n", *((int8_t *)pInput->data));
code = atan_function(pInput, 1, pOutput); code = atanFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result); ASSERT_EQ(*((double *)pOutput->data + i), result);
@ -2334,7 +2333,7 @@ TEST(ScalarFunctionTest, atan_function_constant) {
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("float before ATAN:%f\n", *((float *)pInput->data)); PRINTF("float before ATAN:%f\n", *((float *)pInput->data));
code = atan_function(pInput, 1, pOutput); code = atanFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result); ASSERT_EQ(*((double *)pOutput->data + i), result);
@ -2345,7 +2344,7 @@ TEST(ScalarFunctionTest, atan_function_constant) {
scltDestroyDataBlock(pOutput); scltDestroyDataBlock(pOutput);
} }
TEST(ScalarFunctionTest, atan_function_column) { TEST(ScalarFunctionTest, atanFunction_column) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
int32_t rowNum = 3; int32_t rowNum = 3;
@ -2363,7 +2362,7 @@ TEST(ScalarFunctionTest, atan_function_column) {
PRINTF("tiny_int before ATAN:%d\n", *((int8_t *)pInput->data + i)); PRINTF("tiny_int before ATAN:%d\n", *((int8_t *)pInput->data + i));
} }
code = atan_function(pInput, 1, pOutput); code = atanFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result[i]); ASSERT_EQ(*((double *)pOutput->data + i), result[i]);
@ -2382,7 +2381,7 @@ TEST(ScalarFunctionTest, atan_function_column) {
PRINTF("float before ATAN:%f\n", *((float *)pInput->data + i)); PRINTF("float before ATAN:%f\n", *((float *)pInput->data + i));
} }
code = atan_function(pInput, 1, pOutput); code = atanFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result[i]); ASSERT_EQ(*((double *)pOutput->data + i), result[i]);
@ -2393,7 +2392,7 @@ TEST(ScalarFunctionTest, atan_function_column) {
scltDestroyDataBlock(pOutput); scltDestroyDataBlock(pOutput);
} }
TEST(ScalarFunctionTest, ceil_function_constant) { TEST(ScalarFunctionTest, ceilFunction_constant) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
int32_t rowNum = 3; int32_t rowNum = 3;
@ -2407,7 +2406,7 @@ TEST(ScalarFunctionTest, ceil_function_constant) {
scltMakeDataBlock(&pOutput, type, 0, rowNum, false); scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
PRINTF("tiny_int before CEIL:%d\n", *((int8_t *)pInput->data)); PRINTF("tiny_int before CEIL:%d\n", *((int8_t *)pInput->data));
code = ceil_function(pInput, 1, pOutput); code = ceilFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((int8_t *)pOutput->data + i), (int8_t)result); ASSERT_EQ(*((int8_t *)pOutput->data + i), (int8_t)result);
@ -2423,7 +2422,7 @@ TEST(ScalarFunctionTest, ceil_function_constant) {
scltMakeDataBlock(&pOutput, type, 0, rowNum, false); scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
PRINTF("float before CEIL:%f\n", *((float *)pInput->data)); PRINTF("float before CEIL:%f\n", *((float *)pInput->data));
code = ceil_function(pInput, 1, pOutput); code = ceilFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((float *)pOutput->data + i), (float)result); ASSERT_EQ(*((float *)pOutput->data + i), (float)result);
@ -2434,7 +2433,7 @@ TEST(ScalarFunctionTest, ceil_function_constant) {
scltDestroyDataBlock(pOutput); scltDestroyDataBlock(pOutput);
} }
TEST(ScalarFunctionTest, ceil_function_column) { TEST(ScalarFunctionTest, ceilFunction_column) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
int32_t rowNum = 3; int32_t rowNum = 3;
@ -2451,7 +2450,7 @@ TEST(ScalarFunctionTest, ceil_function_column) {
PRINTF("tiny_int before CEIL:%d\n", *((int8_t *)pInput->data + i)); PRINTF("tiny_int before CEIL:%d\n", *((int8_t *)pInput->data + i));
} }
code = ceil_function(pInput, 1, pOutput); code = ceilFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((int8_t *)pOutput->data + i), result[i]); ASSERT_EQ(*((int8_t *)pOutput->data + i), result[i]);
@ -2470,7 +2469,7 @@ TEST(ScalarFunctionTest, ceil_function_column) {
PRINTF("float before CEIL:%f\n", *((float *)pInput->data + i)); PRINTF("float before CEIL:%f\n", *((float *)pInput->data + i));
} }
code = ceil_function(pInput, 1, pOutput); code = ceilFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((float *)pOutput->data + i), result[i]); ASSERT_EQ(*((float *)pOutput->data + i), result[i]);
@ -2481,7 +2480,7 @@ TEST(ScalarFunctionTest, ceil_function_column) {
scltDestroyDataBlock(pOutput); scltDestroyDataBlock(pOutput);
} }
TEST(ScalarFunctionTest, floor_function_constant) { TEST(ScalarFunctionTest, floorFunction_constant) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
int32_t rowNum = 3; int32_t rowNum = 3;
@ -2495,7 +2494,7 @@ TEST(ScalarFunctionTest, floor_function_constant) {
scltMakeDataBlock(&pOutput, type, 0, rowNum, false); scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
PRINTF("tiny_int before FLOOR:%d\n", *((int8_t *)pInput->data)); PRINTF("tiny_int before FLOOR:%d\n", *((int8_t *)pInput->data));
code = floor_function(pInput, 1, pOutput); code = floorFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((int8_t *)pOutput->data + i), (int8_t)result); ASSERT_EQ(*((int8_t *)pOutput->data + i), (int8_t)result);
@ -2511,7 +2510,7 @@ TEST(ScalarFunctionTest, floor_function_constant) {
scltMakeDataBlock(&pOutput, type, 0, rowNum, false); scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
PRINTF("float before FLOOR:%f\n", *((float *)pInput->data)); PRINTF("float before FLOOR:%f\n", *((float *)pInput->data));
code = floor_function(pInput, 1, pOutput); code = floorFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((float *)pOutput->data + i), (float)result); ASSERT_EQ(*((float *)pOutput->data + i), (float)result);
@ -2522,7 +2521,7 @@ TEST(ScalarFunctionTest, floor_function_constant) {
scltDestroyDataBlock(pOutput); scltDestroyDataBlock(pOutput);
} }
TEST(ScalarFunctionTest, floor_function_column) { TEST(ScalarFunctionTest, floorFunction_column) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
int32_t rowNum = 3; int32_t rowNum = 3;
@ -2539,7 +2538,7 @@ TEST(ScalarFunctionTest, floor_function_column) {
PRINTF("tiny_int before FLOOR:%d\n", *((int8_t *)pInput->data + i)); PRINTF("tiny_int before FLOOR:%d\n", *((int8_t *)pInput->data + i));
} }
code = floor_function(pInput, 1, pOutput); code = floorFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((int8_t *)pOutput->data + i), result[i]); ASSERT_EQ(*((int8_t *)pOutput->data + i), result[i]);
@ -2558,7 +2557,7 @@ TEST(ScalarFunctionTest, floor_function_column) {
PRINTF("float before FLOOR:%f\n", *((float *)pInput->data + i)); PRINTF("float before FLOOR:%f\n", *((float *)pInput->data + i));
} }
code = floor_function(pInput, 1, pOutput); code = floorFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((float *)pOutput->data + i), result[i]); ASSERT_EQ(*((float *)pOutput->data + i), result[i]);
@ -2569,7 +2568,7 @@ TEST(ScalarFunctionTest, floor_function_column) {
scltDestroyDataBlock(pOutput); scltDestroyDataBlock(pOutput);
} }
TEST(ScalarFunctionTest, round_function_constant) { TEST(ScalarFunctionTest, roundFunction_constant) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
int32_t rowNum = 3; int32_t rowNum = 3;
@ -2583,7 +2582,7 @@ TEST(ScalarFunctionTest, round_function_constant) {
scltMakeDataBlock(&pOutput, type, 0, rowNum, false); scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
PRINTF("tiny_int before ROUND:%d\n", *((int8_t *)pInput->data)); PRINTF("tiny_int before ROUND:%d\n", *((int8_t *)pInput->data));
code = round_function(pInput, 1, pOutput); code = roundFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((int8_t *)pOutput->data + i), (int8_t)result); ASSERT_EQ(*((int8_t *)pOutput->data + i), (int8_t)result);
@ -2599,7 +2598,7 @@ TEST(ScalarFunctionTest, round_function_constant) {
scltMakeDataBlock(&pOutput, type, 0, rowNum, false); scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
PRINTF("float before ROUND:%f\n", *((float *)pInput->data)); PRINTF("float before ROUND:%f\n", *((float *)pInput->data));
code = round_function(pInput, 1, pOutput); code = roundFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((float *)pOutput->data + i), (float)result); ASSERT_EQ(*((float *)pOutput->data + i), (float)result);
@ -2610,7 +2609,7 @@ TEST(ScalarFunctionTest, round_function_constant) {
scltDestroyDataBlock(pOutput); scltDestroyDataBlock(pOutput);
} }
TEST(ScalarFunctionTest, round_function_column) { TEST(ScalarFunctionTest, roundFunction_column) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
int32_t rowNum = 3; int32_t rowNum = 3;
@ -2627,7 +2626,7 @@ TEST(ScalarFunctionTest, round_function_column) {
PRINTF("tiny_int before ROUND:%d\n", *((int8_t *)pInput->data + i)); PRINTF("tiny_int before ROUND:%d\n", *((int8_t *)pInput->data + i));
} }
code = round_function(pInput, 1, pOutput); code = roundFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((int8_t *)pOutput->data + i), result[i]); ASSERT_EQ(*((int8_t *)pOutput->data + i), result[i]);
@ -2646,7 +2645,7 @@ TEST(ScalarFunctionTest, round_function_column) {
PRINTF("float before ROUND:%f\n", *((float *)pInput->data + i)); PRINTF("float before ROUND:%f\n", *((float *)pInput->data + i));
} }
code = round_function(pInput, 1, pOutput); code = roundFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((float *)pOutput->data + i), result[i]); ASSERT_EQ(*((float *)pOutput->data + i), result[i]);
@ -2657,7 +2656,7 @@ TEST(ScalarFunctionTest, round_function_column) {
scltDestroyDataBlock(pOutput); scltDestroyDataBlock(pOutput);
} }
TEST(ScalarFunctionTest, sqrt_function_constant) { TEST(ScalarFunctionTest, sqrtFunction_constant) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
int32_t rowNum = 3; int32_t rowNum = 3;
@ -2672,7 +2671,7 @@ TEST(ScalarFunctionTest, sqrt_function_constant) {
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("tiny_int before SQRT:%d\n", *((int8_t *)pInput->data)); PRINTF("tiny_int before SQRT:%d\n", *((int8_t *)pInput->data));
code = sqrt_function(pInput, 1, pOutput); code = sqrtFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result); ASSERT_EQ(*((double *)pOutput->data + i), result);
@ -2688,7 +2687,7 @@ TEST(ScalarFunctionTest, sqrt_function_constant) {
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("float before SQRT:%f\n", *((float *)pInput->data)); PRINTF("float before SQRT:%f\n", *((float *)pInput->data));
code = sqrt_function(pInput, 1, pOutput); code = sqrtFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result); ASSERT_EQ(*((double *)pOutput->data + i), result);
@ -2699,7 +2698,7 @@ TEST(ScalarFunctionTest, sqrt_function_constant) {
scltDestroyDataBlock(pOutput); scltDestroyDataBlock(pOutput);
} }
TEST(ScalarFunctionTest, sqrt_function_column) { TEST(ScalarFunctionTest, sqrtFunction_column) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
int32_t rowNum = 3; int32_t rowNum = 3;
@ -2717,7 +2716,7 @@ TEST(ScalarFunctionTest, sqrt_function_column) {
PRINTF("tiny_int before SQRT:%d\n", *((int8_t *)pInput->data + i)); PRINTF("tiny_int before SQRT:%d\n", *((int8_t *)pInput->data + i));
} }
code = sqrt_function(pInput, 1, pOutput); code = sqrtFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result[i]); ASSERT_EQ(*((double *)pOutput->data + i), result[i]);
@ -2736,7 +2735,7 @@ TEST(ScalarFunctionTest, sqrt_function_column) {
PRINTF("float before SQRT:%f\n", *((float *)pInput->data + i)); PRINTF("float before SQRT:%f\n", *((float *)pInput->data + i));
} }
code = sqrt_function(pInput, 1, pOutput); code = sqrtFunction(pInput, 1, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result[i]); ASSERT_EQ(*((double *)pOutput->data + i), result[i]);
@ -2747,7 +2746,7 @@ TEST(ScalarFunctionTest, sqrt_function_column) {
scltDestroyDataBlock(pOutput); scltDestroyDataBlock(pOutput);
} }
TEST(ScalarFunctionTest, log_function_constant) { TEST(ScalarFunctionTest, logFunction_constant) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
SScalarParam *input[2]; SScalarParam *input[2];
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
@ -2768,7 +2767,7 @@ TEST(ScalarFunctionTest, log_function_constant) {
PRINTF("tiny_int before LOG: %d,%d\n", *((int8_t *)pInput[0].data), PRINTF("tiny_int before LOG: %d,%d\n", *((int8_t *)pInput[0].data),
*((int8_t *)pInput[1].data)); *((int8_t *)pInput[1].data));
code = log_function(pInput, 2, pOutput); code = logFunction(pInput, 2, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result); ASSERT_EQ(*((double *)pOutput->data + i), result);
@ -2789,7 +2788,7 @@ TEST(ScalarFunctionTest, log_function_constant) {
PRINTF("float before LOG: %f,%f\n", *((float *)pInput[0].data), PRINTF("float before LOG: %f,%f\n", *((float *)pInput[0].data),
*((float *)pInput[1].data)); *((float *)pInput[1].data));
code = log_function(pInput, 2, pOutput); code = logFunction(pInput, 2, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result); ASSERT_EQ(*((double *)pOutput->data + i), result);
@ -2810,7 +2809,7 @@ TEST(ScalarFunctionTest, log_function_constant) {
PRINTF("tiny_int,float before LOG: %d,%f\n", *((int8_t *)pInput[0].data), *((float *)pInput[1].data)); PRINTF("tiny_int,float before LOG: %d,%f\n", *((int8_t *)pInput[0].data), *((float *)pInput[1].data));
code = log_function(pInput, 2, pOutput); code = logFunction(pInput, 2, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result); ASSERT_EQ(*((double *)pOutput->data + i), result);
@ -2823,7 +2822,7 @@ TEST(ScalarFunctionTest, log_function_constant) {
free(pInput); free(pInput);
} }
TEST(ScalarFunctionTest, log_function_column) { TEST(ScalarFunctionTest, logFunction_column) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
SScalarParam *input[2]; SScalarParam *input[2];
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
@ -2848,7 +2847,7 @@ TEST(ScalarFunctionTest, log_function_column) {
} }
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
code = log_function(pInput, 2, pOutput); code = logFunction(pInput, 2, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result[i]); ASSERT_EQ(*((double *)pOutput->data + i), result[i]);
@ -2873,7 +2872,7 @@ TEST(ScalarFunctionTest, log_function_column) {
} }
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
code = log_function(pInput, 2, pOutput); code = logFunction(pInput, 2, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result[i]); ASSERT_EQ(*((double *)pOutput->data + i), result[i]);
@ -2901,7 +2900,7 @@ TEST(ScalarFunctionTest, log_function_column) {
*((int8_t *)pInput[0].data + 2), *((float *)pInput[1].data + 2)); *((int8_t *)pInput[0].data + 2), *((float *)pInput[1].data + 2));
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
code = log_function(pInput, 2, pOutput); code = logFunction(pInput, 2, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result[i]); ASSERT_EQ(*((double *)pOutput->data + i), result[i]);
@ -2914,7 +2913,7 @@ TEST(ScalarFunctionTest, log_function_column) {
free(pInput); free(pInput);
} }
TEST(ScalarFunctionTest, pow_function_constant) { TEST(ScalarFunctionTest, powFunction_constant) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
SScalarParam *input[2]; SScalarParam *input[2];
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
@ -2935,7 +2934,7 @@ TEST(ScalarFunctionTest, pow_function_constant) {
PRINTF("tiny_int before POW: %d,%d\n", *((int8_t *)pInput[0].data), PRINTF("tiny_int before POW: %d,%d\n", *((int8_t *)pInput[0].data),
*((int8_t *)pInput[1].data)); *((int8_t *)pInput[1].data));
code = pow_function(pInput, 2, pOutput); code = powFunction(pInput, 2, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result); ASSERT_EQ(*((double *)pOutput->data + i), result);
@ -2956,7 +2955,7 @@ TEST(ScalarFunctionTest, pow_function_constant) {
PRINTF("float before POW: %f,%f\n", *((float *)pInput[0].data), PRINTF("float before POW: %f,%f\n", *((float *)pInput[0].data),
*((float *)pInput[1].data)); *((float *)pInput[1].data));
code = pow_function(pInput, 2, pOutput); code = powFunction(pInput, 2, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result); ASSERT_EQ(*((double *)pOutput->data + i), result);
@ -2977,7 +2976,7 @@ TEST(ScalarFunctionTest, pow_function_constant) {
PRINTF("tiny_int,float before POW: %d,%f\n", *((int8_t *)pInput[0].data), *((float *)pInput[1].data)); PRINTF("tiny_int,float before POW: %d,%f\n", *((int8_t *)pInput[0].data), *((float *)pInput[1].data));
code = pow_function(pInput, 2, pOutput); code = powFunction(pInput, 2, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result); ASSERT_EQ(*((double *)pOutput->data + i), result);
@ -2990,7 +2989,7 @@ TEST(ScalarFunctionTest, pow_function_constant) {
free(pInput); free(pInput);
} }
TEST(ScalarFunctionTest, pow_function_column) { TEST(ScalarFunctionTest, powFunction_column) {
SScalarParam *pInput, *pOutput; SScalarParam *pInput, *pOutput;
SScalarParam *input[2]; SScalarParam *input[2];
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
@ -3015,7 +3014,7 @@ TEST(ScalarFunctionTest, pow_function_column) {
} }
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
code = pow_function(pInput, 2, pOutput); code = powFunction(pInput, 2, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result[i]); ASSERT_EQ(*((double *)pOutput->data + i), result[i]);
@ -3041,7 +3040,7 @@ TEST(ScalarFunctionTest, pow_function_column) {
} }
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
code = pow_function(pInput, 2, pOutput); code = powFunction(pInput, 2, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result[i]); ASSERT_EQ(*((double *)pOutput->data + i), result[i]);
@ -3069,7 +3068,7 @@ TEST(ScalarFunctionTest, pow_function_column) {
*((int8_t *)pInput[0].data + 2), *((float *)pInput[1].data + 2)); *((int8_t *)pInput[0].data + 2), *((float *)pInput[1].data + 2));
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
code = pow_function(pInput, 2, pOutput); code = powFunction(pInput, 2, pOutput);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
for (int32_t i = 0; i < rowNum; ++i) { for (int32_t i = 0; i < rowNum; ++i) {
ASSERT_EQ(*((double *)pOutput->data + i), result[i]); ASSERT_EQ(*((double *)pOutput->data + i), result[i]);