From 79002a6e3d5bc43dc914d7123ba811799a09c132 Mon Sep 17 00:00:00 2001 From: Ganlin Zhao Date: Fri, 25 Mar 2022 16:24:36 +0800 Subject: [PATCH 1/5] [TD-14240]: add math functions --- source/libs/scalar/inc/sclfunc.h | 14 + source/libs/scalar/src/sclfunc.c | 667 ++++++++++++++++++++++++------- 2 files changed, 543 insertions(+), 138 deletions(-) diff --git a/source/libs/scalar/inc/sclfunc.h b/source/libs/scalar/inc/sclfunc.h index 8e03470033..bffd96ea5d 100644 --- a/source/libs/scalar/inc/sclfunc.h +++ b/source/libs/scalar/inc/sclfunc.h @@ -36,7 +36,21 @@ extern struct SScalarFunctionInfo scalarFunc[8]; int32_t evaluateExprNodeTree(tExprNode* pExprs, int32_t numOfRows, SScalarParam* pOutput, 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 } diff --git a/source/libs/scalar/src/sclfunc.c b/source/libs/scalar/src/sclfunc.c index fd900afcda..96f24ade17 100644 --- a/source/libs/scalar/src/sclfunc.c +++ b/source/libs/scalar/src/sclfunc.c @@ -4,145 +4,536 @@ static void assignBasicParaInfo(struct SScalarParam* dst, const struct SScalarParam* src) { dst->type = src->type; dst->bytes = src->bytes; - dst->num = src->num; + //dst->num = src->num; } -static void tceil(SScalarParam* pOutput, size_t numOfInput, const SScalarParam *pLeft) { - assignBasicParaInfo(pOutput, pLeft); - assert(numOfInput == 1); - - switch (pLeft->bytes) { - case TSDB_DATA_TYPE_FLOAT: { - float* p = (float*) pLeft->data; - float* out = (float*) pOutput->data; - for (int32_t i = 0; i < pLeft->num; ++i) { - out[i] = ceilf(p[i]); - } - } - - case TSDB_DATA_TYPE_DOUBLE: { - double* p = (double*) pLeft->data; - double* out = (double*)pOutput->data; - for (int32_t i = 0; i < pLeft->num; ++i) { - out[i] = ceil(p[i]); - } - } - - default: - memcpy(pOutput->data, pLeft->data, pLeft->num* pLeft->bytes); +/** Math functions **/ +int32_t abs_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { + assignBasicParaInfo(pOutput, pInput); + if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->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; + + if (isNull(input, pInput->type)) { + setNull(output, pOutput->type, pOutput->bytes); + continue; + } + + switch (pInput->type) { + case TSDB_DATA_TYPE_FLOAT: { + float v; + GET_TYPED_DATA(v, float, pInput->type, input); + float result; + result = (v > 0) ? v : -v; + SET_TYPED_DATA(output, pOutput->type, result); + break; + } + + case TSDB_DATA_TYPE_DOUBLE: { + double v; + GET_TYPED_DATA(v, double, pInput->type, input); + double result; + result = (v > 0) ? v : -v; + SET_TYPED_DATA(output, pOutput->type, result); + break; + } + + case TSDB_DATA_TYPE_TINYINT: { + int8_t v; + GET_TYPED_DATA(v, int8_t, pInput->type, input); + int8_t result; + result = (v > 0) ? v : -v; + SET_TYPED_DATA(output, pOutput->type, result); + break; + } + + case TSDB_DATA_TYPE_SMALLINT: { + int16_t v; + GET_TYPED_DATA(v, int16_t, pInput->type, input); + int16_t result; + result = (v > 0) ? v : -v; + SET_TYPED_DATA(output, pOutput->type, result); + break; + } + + case TSDB_DATA_TYPE_INT: { + int32_t v; + GET_TYPED_DATA(v, int32_t, pInput->type, input); + int32_t result; + result = (v > 0) ? v : -v; + SET_TYPED_DATA(output, pOutput->type, result); + break; + } + + case TSDB_DATA_TYPE_BIGINT: { + int64_t v; + GET_TYPED_DATA(v, int64_t, pInput->type, input); + int64_t result; + result = (v > 0) ? v : -v; + SET_TYPED_DATA(output, pOutput->type, result); + break; + } + + default: { + memcpy(output, input, pInput->bytes); + break; + } + } + } + + return TSDB_CODE_SUCCESS; } -static void tfloor(SScalarParam* pOutput, size_t numOfInput, const SScalarParam *pLeft) { - assignBasicParaInfo(pOutput, pLeft); - assert(numOfInput == 1); - - switch (pLeft->bytes) { - case TSDB_DATA_TYPE_FLOAT: { - float* p = (float*) pLeft->data; - float* out = (float*) pOutput->data; - - for (int32_t i = 0; i < pLeft->num; ++i) { - out[i] = floorf(p[i]); - } - } - - case TSDB_DATA_TYPE_DOUBLE: { - double* p = (double*) pLeft->data; - double* out = (double*) pOutput->data; - - for (int32_t i = 0; i < pLeft->num; ++i) { - out[i] = floor(p[i]); - } - } - - default: - memcpy(pOutput->data, pLeft->data, pLeft->num* pLeft->bytes); +int32_t log_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { + if (inputNum != 2 || !IS_NUMERIC_TYPE(pInput[0].type) || !IS_NUMERIC_TYPE(pInput[1].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 = calloc(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); + } + + free(input); + + return TSDB_CODE_SUCCESS; } -static void _tabs(SScalarParam* pOutput, size_t numOfInput, const SScalarParam *pLeft) { - assignBasicParaInfo(pOutput, pLeft); - assert(numOfInput == 1); - - switch (pLeft->bytes) { - case TSDB_DATA_TYPE_FLOAT: { - float* p = (float*) pLeft->data; - float* out = (float*) pOutput->data; - for (int32_t i = 0; i < pLeft->num; ++i) { - out[i] = (p[i] > 0)? p[i]:-p[i]; - } - } - - case TSDB_DATA_TYPE_DOUBLE: { - double* p = (double*) pLeft->data; - double* out = (double*) pOutput->data; - for (int32_t i = 0; i < pLeft->num; ++i) { - out[i] = (p[i] > 0)? p[i]:-p[i]; - } - } - - case TSDB_DATA_TYPE_TINYINT: { - int8_t* p = (int8_t*) pLeft->data; - int8_t* out = (int8_t*) pOutput->data; - for (int32_t i = 0; i < pLeft->num; ++i) { - out[i] = (p[i] > 0)? p[i]:-p[i]; - } - } - - case TSDB_DATA_TYPE_SMALLINT: { - int16_t* p = (int16_t*) pLeft->data; - int16_t* out = (int16_t*) pOutput->data; - for (int32_t i = 0; i < pLeft->num; ++i) { - out[i] = (p[i] > 0)? p[i]:-p[i]; - } - } - - case TSDB_DATA_TYPE_INT: { - int32_t* p = (int32_t*) pLeft->data; - int32_t* out = (int32_t*) pOutput->data; - for (int32_t i = 0; i < pLeft->num; ++i) { - out[i] = (p[i] > 0)? p[i]:-p[i]; - } - } - - case TSDB_DATA_TYPE_BIGINT: { - int64_t* p = (int64_t*) pLeft->data; - int64_t* out = (int64_t*) pOutput->data; - for (int32_t i = 0; i < pLeft->num; ++i) { - out[i] = (p[i] > 0)? p[i]:-p[i]; - } - } - - default: - memcpy(pOutput->data, pLeft->data, pLeft->num* pLeft->bytes); +int32_t pow_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { + if (inputNum != 2 || !IS_NUMERIC_TYPE(pInput[0].type) || !IS_NUMERIC_TYPE(pInput[1].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 = calloc(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 = pow(v, base); + SET_TYPED_DATA(output, pOutput->type, result); + } + + free(input); + + return TSDB_CODE_SUCCESS; } -static void tround(SScalarParam* pOutput, size_t numOfInput, const SScalarParam *pLeft) { - assignBasicParaInfo(pOutput, pLeft); - assert(numOfInput == 1); - - switch (pLeft->bytes) { - case TSDB_DATA_TYPE_FLOAT: { - float* p = (float*) pLeft->data; - float* out = (float*) pOutput->data; - for (int32_t i = 0; i < pLeft->num; ++i) { - out[i] = roundf(p[i]); - } - } - - case TSDB_DATA_TYPE_DOUBLE: { - double* p = (double*) pLeft->data; - double* out = (double*) pOutput->data; - for (int32_t i = 0; i < pLeft->num; ++i) { - out[i] = round(p[i]); - } - } - - default: - memcpy(pOutput->data, pLeft->data, pLeft->num* pLeft->bytes); +int32_t sqrt_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { + if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) { + return TSDB_CODE_FAILED; } + + pOutput->type = TSDB_DATA_TYPE_DOUBLE; + pOutput->bytes = tDataTypes[TSDB_DATA_TYPE_DOUBLE].bytes; + + 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; + + if (isNull(input, pInput->type)) { + setNull(output, pOutput->type, pOutput->bytes); + continue; + } + + double v; + GET_TYPED_DATA(v, double, pInput->type, input); + double result = sqrt(v); + SET_TYPED_DATA(output, pOutput->type, result); + } + + return TSDB_CODE_SUCCESS; +} + +int32_t sin_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { + if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) { + return TSDB_CODE_FAILED; + } + + pOutput->type = TSDB_DATA_TYPE_DOUBLE; + pOutput->bytes = tDataTypes[TSDB_DATA_TYPE_DOUBLE].bytes; + + 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; + + if (isNull(input, pInput->type)) { + setNull(output, pOutput->type, pOutput->bytes); + continue; + } + + double v; + GET_TYPED_DATA(v, double, pInput->type, input); + double result = sin(v); + SET_TYPED_DATA(output, pOutput->type, result); + } + + return TSDB_CODE_SUCCESS; +} + +int32_t cos_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { + if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) { + return TSDB_CODE_FAILED; + } + + pOutput->type = TSDB_DATA_TYPE_DOUBLE; + pOutput->bytes = tDataTypes[TSDB_DATA_TYPE_DOUBLE].bytes; + + 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; + + if (isNull(input, pInput->type)) { + setNull(output, pOutput->type, pOutput->bytes); + continue; + } + + double v; + GET_TYPED_DATA(v, double, pInput->type, input); + double result = cos(v); + SET_TYPED_DATA(output, pOutput->type, result); + } + + return TSDB_CODE_SUCCESS; +} + +int32_t tan_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { + if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) { + return TSDB_CODE_FAILED; + } + + pOutput->type = TSDB_DATA_TYPE_DOUBLE; + pOutput->bytes = tDataTypes[TSDB_DATA_TYPE_DOUBLE].bytes; + + 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; + + if (isNull(input, pInput->type)) { + setNull(output, pOutput->type, pOutput->bytes); + continue; + } + + double v; + GET_TYPED_DATA(v, double, pInput->type, input); + double result = tan(v); + SET_TYPED_DATA(output, pOutput->type, result); + } + + return TSDB_CODE_SUCCESS; +} + +int32_t asin_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { + if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) { + return TSDB_CODE_FAILED; + } + + pOutput->type = TSDB_DATA_TYPE_DOUBLE; + pOutput->bytes = tDataTypes[TSDB_DATA_TYPE_DOUBLE].bytes; + + 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; + + if (isNull(input, pInput->type)) { + setNull(output, pOutput->type, pOutput->bytes); + continue; + } + + double v; + GET_TYPED_DATA(v, double, pInput->type, input); + double result = asin(v); + SET_TYPED_DATA(output, pOutput->type, result); + } + + return TSDB_CODE_SUCCESS; +} + +int32_t acos_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { + if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) { + return TSDB_CODE_FAILED; + } + + pOutput->type = TSDB_DATA_TYPE_DOUBLE; + pOutput->bytes = tDataTypes[TSDB_DATA_TYPE_DOUBLE].bytes; + + 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; + + if (isNull(input, pInput->type)) { + setNull(output, pOutput->type, pOutput->bytes); + continue; + } + + double v; + GET_TYPED_DATA(v, double, pInput->type, input); + double result = acos(v); + SET_TYPED_DATA(output, pOutput->type, result); + } + + return TSDB_CODE_SUCCESS; +} + +int32_t atan_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { + if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) { + return TSDB_CODE_FAILED; + } + + pOutput->type = TSDB_DATA_TYPE_DOUBLE; + pOutput->bytes = tDataTypes[TSDB_DATA_TYPE_DOUBLE].bytes; + + 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; + + if (isNull(input, pInput->type)) { + setNull(output, pOutput->type, pOutput->bytes); + continue; + } + + double v; + GET_TYPED_DATA(v, double, pInput->type, input); + double result = atan(v); + SET_TYPED_DATA(output, pOutput->type, result); + } + + return TSDB_CODE_SUCCESS; +} + +int32_t ceil_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { + if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->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; + + if (isNull(input, pInput->type)) { + setNull(output, pOutput->type, pOutput->bytes); + continue; + } + + 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 v; + GET_TYPED_DATA(v, double, pInput->type, input); + double result = ceil(v); + SET_TYPED_DATA(output, pOutput->type, result); + break; + } + + default: { + memcpy(output, input, pInput->bytes); + break; + } + } + } + + return TSDB_CODE_SUCCESS; +} + +int32_t floor_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { + assignBasicParaInfo(pOutput, pInput); + if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->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; + + if (isNull(input, pInput->type)) { + setNull(output, pOutput->type, pOutput->bytes); + continue; + } + + 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 v; + GET_TYPED_DATA(v, double, pInput->type, input); + double result = floor(v); + SET_TYPED_DATA(output, pOutput->type, result); + break; + } + + default: { + memcpy(output, input, pInput->bytes); + break; + } + } + } + + return TSDB_CODE_SUCCESS; +} + +int32_t round_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { + assignBasicParaInfo(pOutput, pInput); + if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->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; + + if (isNull(input, pInput->type)) { + setNull(output, pOutput->type, pOutput->bytes); + continue; + } + + 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 v; + GET_TYPED_DATA(v, double, pInput->type, input); + double result = round(v); + SET_TYPED_DATA(output, pOutput->type, result); + break; + } + + default: { + memcpy(output, input, pInput->bytes); + break; + } + } + } + + return TSDB_CODE_SUCCESS; } static void tlength(SScalarParam* pOutput, size_t numOfInput, const SScalarParam *pLeft) { @@ -361,16 +752,16 @@ int32_t evaluateExprNodeTree(tExprNode* pExprs, int32_t numOfRows, SScalarFuncPa #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}, -}; +//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; @@ -411,4 +802,4 @@ void destroyScalarFuncSupport(struct SScalarFunctionSupport* pSupport, int32_t n } tfree(pSupport); -} \ No newline at end of file +} From c08ccb75dfab006349e475ed9c98382ab03e310e Mon Sep 17 00:00:00 2001 From: Ganlin Zhao Date: Fri, 25 Mar 2022 16:24:36 +0800 Subject: [PATCH 2/5] [TD-14240]: add math functions --- .../libs/scalar/test/scalar/scalarTests.cpp | 1640 +++++++++++++++++ 1 file changed, 1640 insertions(+) diff --git a/source/libs/scalar/test/scalar/scalarTests.cpp b/source/libs/scalar/test/scalar/scalarTests.cpp index d6a73d99bb..2acd046a95 100644 --- a/source/libs/scalar/test/scalar/scalarTests.cpp +++ b/source/libs/scalar/test/scalar/scalarTests.cpp @@ -36,6 +36,7 @@ #include "tdatablock.h" #include "stub.h" #include "scalar.h" +#include "sclfunc.h" #include "nodes.h" #include "tlog.h" @@ -1433,6 +1434,1645 @@ TEST(columnTest, greater_and_lower) { nodesDestroyNode(logicNode); } +void scltMakeDataBlock(SScalarParam **pInput, int32_t type, void *pVal, int32_t num, bool setVal) { + SScalarParam *input = (SScalarParam *)calloc(1, sizeof(SScalarParam)); + int32_t bytes; + switch (type) { + case TSDB_DATA_TYPE_TINYINT: { + bytes = sizeof(int8_t); + break; + } + case TSDB_DATA_TYPE_SMALLINT: { + bytes = sizeof(int16_t); + break; + } + case TSDB_DATA_TYPE_INT: { + bytes = sizeof(int32_t); + break; + } + case TSDB_DATA_TYPE_BIGINT: { + bytes = sizeof(int64_t); + break; + } + case TSDB_DATA_TYPE_FLOAT: { + bytes = sizeof(float); + break; + } + case TSDB_DATA_TYPE_DOUBLE: { + bytes = sizeof(double); + break; + } + } + + input->type = type; + input->num = num; + input->data = calloc(num, bytes); + input->bytes = bytes; + if (setVal) { + for (int32_t i = 0; i < num; ++i) { + memcpy(input->data + i * bytes, pVal, bytes); + } + } else { + memset(input->data, 0, num * bytes); + } + + *pInput = input; +} + +void scltDestroyDataBlock(SScalarParam *pInput) { + free(pInput->data); + free(pInput); +} + +TEST(ScalarFunctionTest, abs_function_constant) { + SScalarParam *pInput, *pOutput; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + + //TINYINT + int8_t val_tinyint = 10; + type = TSDB_DATA_TYPE_TINYINT; + scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + + code = abs_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((int8_t *)pOutput->data + i), val_tinyint); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + val_tinyint = -10; + scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + + code = abs_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((int8_t *)pOutput->data + i), -val_tinyint); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //SMALLINT + int16_t val_smallint = 10; + type = TSDB_DATA_TYPE_SMALLINT; + scltMakeDataBlock(&pInput, type, &val_smallint, 1, true); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + + code = abs_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((int16_t *)pOutput->data + i), val_smallint); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + val_smallint = -10; + scltMakeDataBlock(&pInput, type, &val_smallint, 1, true); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + + code = abs_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((int16_t *)pOutput->data + i), -val_smallint); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //INT + int32_t val_int = 10; + type = TSDB_DATA_TYPE_INT; + scltMakeDataBlock(&pInput, type, &val_int, 1, true); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + + code = abs_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((int32_t *)pOutput->data + i), val_int); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + val_int = -10; + scltMakeDataBlock(&pInput, type, &val_int, 1, true); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + + code = abs_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((int32_t *)pOutput->data + i), -val_int); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //BIGINT + int64_t val_bigint = 10; + type = TSDB_DATA_TYPE_BIGINT; + scltMakeDataBlock(&pInput, type, &val_bigint, 1, true); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + + code = abs_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((int64_t *)pOutput->data + i), val_bigint); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + val_bigint = -10; + scltMakeDataBlock(&pInput, type, &val_bigint, rowNum, true); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + + code = abs_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((int64_t *)pOutput->data + i), -val_bigint); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float = 10.15; + type = TSDB_DATA_TYPE_FLOAT; + scltMakeDataBlock(&pInput, type, &val_float, 1, true); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + printf("float before ABS:%f\n", *(float *)pInput->data); + + code = abs_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((float *)pOutput->data + i), val_float); + printf("float after ABS:%f\n", *((float *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + val_float = -10.15; + scltMakeDataBlock(&pInput, type, &val_float, 1, true); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + printf("float before ABS:%f\n", *(float *)pInput->data); + + code = abs_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((float *)pOutput->data + i), -val_float); + printf("float after ABS:%f\n", *((float *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //DOUBLE + double val_double = 10.15; + type = TSDB_DATA_TYPE_DOUBLE; + scltMakeDataBlock(&pInput, type, &val_double, 1, true); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + + code = abs_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), val_double); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + val_double = -10.15; + scltMakeDataBlock(&pInput, type, &val_double, rowNum, true); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + + code = abs_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), -val_double); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + +} + +TEST(ScalarFunctionTest, abs_function_column) { + SScalarParam *pInput, *pOutput; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 5; + int32_t type; + + //TINYINT + int8_t val_tinyint = 10; + type = TSDB_DATA_TYPE_TINYINT; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((int8_t *)pInput->data + i) = val_tinyint + i; + printf("tiny_int before ABS:%d\n", *((int8_t *)pInput->data + i)); + } + + code = abs_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((int8_t *)pOutput->data + i), val_tinyint + i); + printf("tiny_int after ABS:%d\n", *((int8_t *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + val_tinyint = -10; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((int8_t *)pInput->data + i) = val_tinyint + i; + printf("tiny_int before ABS:%d\n", *((int8_t *)pInput->data + i)); + } + + code = abs_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((int8_t *)pOutput->data + i), -(val_tinyint + i)); + printf("tiny_int after ABS:%d\n", *((int8_t *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //SMALLINT + int16_t val_smallint = 10; + type = TSDB_DATA_TYPE_SMALLINT; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((int16_t *)pInput->data + i) = val_smallint + i; + printf("small_int before ABS:%d\n", *((int16_t *)pInput->data + i)); + } + + + code = abs_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((int16_t *)pOutput->data + i), val_smallint + i); + printf("small_int after ABS:%d\n", *((int16_t *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + val_smallint = -10; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((int16_t *)pInput->data + i) = val_smallint + i; + printf("small_int before ABS:%d\n", *((int16_t *)pInput->data + i)); + } + + code = abs_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((int16_t *)pOutput->data + i), -(val_smallint + i)); + printf("small_int after ABS:%d\n", *((int16_t *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //INT + int32_t val_int = 10; + type = TSDB_DATA_TYPE_INT; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((int32_t *)pInput->data + i) = val_int + i; + printf("int before ABS:%d\n", *((int32_t *)pInput->data + i)); + } + + + code = abs_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((int32_t *)pOutput->data + i), val_int + i); + printf("int after ABS:%d\n", *((int32_t *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + val_int = -10; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((int32_t *)pInput->data + i) = val_int + i; + printf("int before ABS:%d\n", *((int32_t *)pInput->data + i)); + } + + code = abs_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((int32_t *)pOutput->data + i), -(val_int + i)); + printf("int after ABS:%d\n", *((int32_t *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float = 10.15; + type = TSDB_DATA_TYPE_FLOAT; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((float *)pInput->data + i) = val_float + i; + printf("float before ABS:%f\n", *((float *)pInput->data + i)); + } + + code = abs_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((float *)pOutput->data + i), val_float + i); + printf("float after ABS:%f\n", *((float *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + val_float = -10.15; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((float *)pInput->data + i) = val_float + i; + printf("float before ABS:%f\n", *((float *)pInput->data + i)); + } + + code = abs_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((float *)pOutput->data + i), -(val_float + i)); + printf("float after ABS:%f\n", *((float *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //DOUBLE + double val_double = 10.15; + type = TSDB_DATA_TYPE_DOUBLE; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((double *)pInput->data + i) = val_double + i; + printf("double before ABS:%f\n", *((double *)pInput->data + i)); + } + + code = abs_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), val_double + i); + printf("double after ABS:%f\n", *((double *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + val_double = -10.15; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((double *)pInput->data + i) = val_double + i; + printf("double before ABS:%f\n", *((double *)pInput->data + i)); + } + + code = abs_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), -(val_double + i)); + printf("double after ABS:%f\n", *((double *)pOutput->data + i)); + } + + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); +} + +TEST(ScalarFunctionTest, sin_function_constant) { + SScalarParam *pInput, *pOutput; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + int32_t otype = TSDB_DATA_TYPE_DOUBLE; + double result = 0.42016703682664092; + + //TINYINT + int8_t val_tinyint = 13; + type = TSDB_DATA_TYPE_TINYINT; + scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + printf("tiny_int before SIN:%d\n", *((int8_t *)pInput->data)); + + code = sin_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result); + printf("tiny_int after SIN:%f\n", *((double *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float = 13.00; + type = TSDB_DATA_TYPE_FLOAT; + scltMakeDataBlock(&pInput, type, &val_float, 1, true); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + printf("float before SIN:%f\n", *((float *)pInput->data)); + + code = sin_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result); + printf("float after SIN:%f\n", *((double *)pOutput->data + i)); + } + + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + +} + +TEST(ScalarFunctionTest, sin_function_column) { + SScalarParam *pInput, *pOutput; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + int32_t otype = TSDB_DATA_TYPE_DOUBLE; + double result[] = {0.42016703682664092, 0.99060735569487035, 0.65028784015711683}; + + + //TINYINT + int8_t val_tinyint[] = {13, 14, 15}; + type = TSDB_DATA_TYPE_TINYINT; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((int8_t *)pInput->data + i) = val_tinyint[i]; + printf("tiny_int before SIN:%d\n", *((int8_t *)pInput->data + i)); + } + + code = sin_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result[i]); + printf("tiny_int after SIN:%f\n", *((double *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float[] = {13.00, 14.00, 15.00}; + type = TSDB_DATA_TYPE_FLOAT; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((float *)pInput->data + i) = val_float[i]; + printf("float before SIN:%f\n", *((float *)pInput->data + i)); + } + + code = sin_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result[i]); + printf("float after SIN:%f\n", *((double *)pOutput->data + i)); + } + + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); +} + +TEST(ScalarFunctionTest, cos_function_constant) { + SScalarParam *pInput, *pOutput; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + int32_t otype = TSDB_DATA_TYPE_DOUBLE; + double result = 0.90744678145019619; + + //TINYINT + int8_t val_tinyint = 13; + type = TSDB_DATA_TYPE_TINYINT; + scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + printf("tiny_int before COS:%d\n", *((int8_t *)pInput->data)); + + code = cos_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result); + printf("tiny_int after COS:%f\n", *((double *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float = 13.00; + type = TSDB_DATA_TYPE_FLOAT; + scltMakeDataBlock(&pInput, type, &val_float, 1, true); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + printf("float before COS:%f\n", *((float *)pInput->data)); + + code = cos_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result); + printf("float after COS:%f\n", *((double *)pOutput->data + i)); + } + + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); +} + +TEST(ScalarFunctionTest, cos_function_column) { + SScalarParam *pInput, *pOutput; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + int32_t otype = TSDB_DATA_TYPE_DOUBLE; + double result[] = {0.90744678145019619, 0.13673721820783361, -0.75968791285882131}; + + //TINYINT + int8_t val_tinyint[] = {13, 14, 15}; + type = TSDB_DATA_TYPE_TINYINT; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((int8_t *)pInput->data + i) = val_tinyint[i]; + printf("tiny_int before COS:%d\n", *((int8_t *)pInput->data + i)); + } + + code = cos_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result[i]); + printf("tiny_int after COS:%f\n", *((double *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float[] = {13.00, 14.00, 15.00}; + type = TSDB_DATA_TYPE_FLOAT; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((float *)pInput->data + i) = val_float[i]; + printf("float before COS:%f\n", *((float *)pInput->data + i)); + } + + code = cos_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result[i]); + printf("float after COS:%f\n", *((double *)pOutput->data + i)); + } + + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); +} + +TEST(ScalarFunctionTest, tan_function_constant) { + SScalarParam *pInput, *pOutput; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + int32_t otype = TSDB_DATA_TYPE_DOUBLE; + double result = 0.46302113293648961; + + //TINYINT + int8_t val_tinyint = 13; + type = TSDB_DATA_TYPE_TINYINT; + scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + printf("tiny_int before TAN:%d\n", *((int8_t *)pInput->data)); + + code = tan_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result); + printf("tiny_int after TAN:%f\n", *((double *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float = 13.00; + type = TSDB_DATA_TYPE_FLOAT; + scltMakeDataBlock(&pInput, type, &val_float, 1, true); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + printf("float before TAN:%f\n", *((float *)pInput->data)); + + code = tan_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result); + printf("float after TAN:%f\n", *((double *)pOutput->data + i)); + } + + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); +} + +TEST(ScalarFunctionTest, tan_function_column) { + SScalarParam *pInput, *pOutput; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + int32_t otype = TSDB_DATA_TYPE_DOUBLE; + double result[] = {0.46302113293648961, 7.24460661609480550, -0.85599340090851872}; + + //TINYINT + int8_t val_tinyint[] = {13, 14, 15}; + type = TSDB_DATA_TYPE_TINYINT; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((int8_t *)pInput->data + i) = val_tinyint[i]; + printf("tiny_int before TAN:%d\n", *((int8_t *)pInput->data + i)); + } + + code = tan_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result[i]); + printf("tiny_int after TAN:%f\n", *((double *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float[] = {13.00, 14.00, 15.00}; + type = TSDB_DATA_TYPE_FLOAT; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((float *)pInput->data + i) = val_float[i]; + printf("float before TAN:%f\n", *((float *)pInput->data + i)); + } + + code = tan_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result[i]); + printf("float after TAN:%f\n", *((double *)pOutput->data + i)); + } + + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); +} + +TEST(ScalarFunctionTest, asin_function_constant) { + SScalarParam *pInput, *pOutput; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + int32_t otype = TSDB_DATA_TYPE_DOUBLE; + double result = 1.57079632679489656; + + //TINYINT + int8_t val_tinyint = 1; + type = TSDB_DATA_TYPE_TINYINT; + scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + printf("tiny_int before ASIN:%d\n", *((int8_t *)pInput->data)); + + code = asin_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result); + printf("tiny_int after ASIN:%f\n", *((double *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float = 1.00; + type = TSDB_DATA_TYPE_FLOAT; + scltMakeDataBlock(&pInput, type, &val_float, 1, true); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + printf("float before ASIN:%f\n", *((float *)pInput->data)); + + code = asin_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result); + printf("float after ASIN:%f\n", *((double *)pOutput->data + i)); + } + + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); +} + +TEST(ScalarFunctionTest, asin_function_column) { + SScalarParam *pInput, *pOutput; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + int32_t otype = TSDB_DATA_TYPE_DOUBLE; + double result[] = {-1.57079632679489656, 0.0, 1.57079632679489656}; + + + //TINYINT + int8_t val_tinyint[] = {-1, 0, 1}; + type = TSDB_DATA_TYPE_TINYINT; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((int8_t *)pInput->data + i) = val_tinyint[i]; + printf("tiny_int before ASIN:%d\n", *((int8_t *)pInput->data + i)); + } + + code = asin_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result[i]); + printf("tiny_int after ASIN:%f\n", *((double *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float[] = {-1.0, 0.0, 1.0}; + type = TSDB_DATA_TYPE_FLOAT; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((float *)pInput->data + i) = val_float[i]; + printf("float before ASIN:%f\n", *((float *)pInput->data + i)); + } + + code = asin_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result[i]); + printf("float after ASIN:%f\n", *((double *)pOutput->data + i)); + } + + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); +} + +TEST(ScalarFunctionTest, acos_function_constant) { + SScalarParam *pInput, *pOutput; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + int32_t otype = TSDB_DATA_TYPE_DOUBLE; + double result = 0.0; + + //TINYINT + int8_t val_tinyint = 1; + type = TSDB_DATA_TYPE_TINYINT; + scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + printf("tiny_int before ACOS:%d\n", *((int8_t *)pInput->data)); + + code = acos_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result); + printf("tiny_int after ACOS:%f\n", *((double *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float = 1.00; + type = TSDB_DATA_TYPE_FLOAT; + scltMakeDataBlock(&pInput, type, &val_float, 1, true); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + printf("float before ACOS:%f\n", *((float *)pInput->data)); + + code = acos_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result); + printf("float after ACOS:%f\n", *((double *)pOutput->data + i)); + } + + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); +} + +TEST(ScalarFunctionTest, acos_function_column) { + SScalarParam *pInput, *pOutput; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + int32_t otype = TSDB_DATA_TYPE_DOUBLE; + double result[] = {3.14159265358979312, 1.57079632679489656, 0.0}; + + //TINYINT + int8_t val_tinyint[] = {-1, 0, 1}; + type = TSDB_DATA_TYPE_TINYINT; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((int8_t *)pInput->data + i) = val_tinyint[i]; + printf("tiny_int before ACOS:%d\n", *((int8_t *)pInput->data + i)); + } + + code = acos_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result[i]); + printf("tiny_int after ACOS:%f\n", *((double *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float[] = {-1.0, 0.0, 1.0}; + type = TSDB_DATA_TYPE_FLOAT; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((float *)pInput->data + i) = val_float[i]; + printf("float before ACOS:%f\n", *((float *)pInput->data + i)); + } + + code = acos_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result[i]); + printf("float after ACOS:%f\n", *((double *)pOutput->data + i)); + } + + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); +} + +TEST(ScalarFunctionTest, atan_function_constant) { + SScalarParam *pInput, *pOutput; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + int32_t otype = TSDB_DATA_TYPE_DOUBLE; + double result = 0.78539816339744828; + + //TINYINT + int8_t val_tinyint = 1; + type = TSDB_DATA_TYPE_TINYINT; + scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + printf("tiny_int before ATAN:%d\n", *((int8_t *)pInput->data)); + + code = atan_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result); + printf("tiny_int after ATAN:%f\n", *((double *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float = 1.00; + type = TSDB_DATA_TYPE_FLOAT; + scltMakeDataBlock(&pInput, type, &val_float, 1, true); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + printf("float before ATAN:%f\n", *((float *)pInput->data)); + + code = atan_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result); + printf("float after ATAN:%f\n", *((double *)pOutput->data + i)); + } + + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); +} + +TEST(ScalarFunctionTest, atan_function_column) { + SScalarParam *pInput, *pOutput; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + int32_t otype = TSDB_DATA_TYPE_DOUBLE; + double result[] = {-0.78539816339744828, 0.0, 0.78539816339744828}; + + //TINYINT + int8_t val_tinyint[] = {-1, 0, 1}; + type = TSDB_DATA_TYPE_TINYINT; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((int8_t *)pInput->data + i) = val_tinyint[i]; + printf("tiny_int before ATAN:%d\n", *((int8_t *)pInput->data + i)); + } + + code = atan_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result[i]); + printf("tiny_int after ATAN:%f\n", *((double *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float[] = {-1.0, 0.0, 1.0}; + type = TSDB_DATA_TYPE_FLOAT; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((float *)pInput->data + i) = val_float[i]; + printf("float before ATAN:%f\n", *((float *)pInput->data + i)); + } + + code = atan_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result[i]); + printf("float after ATAN:%f\n", *((double *)pOutput->data + i)); + } + + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); +} + +TEST(ScalarFunctionTest, ceil_function_constant) { + SScalarParam *pInput, *pOutput; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + double result = 10.0; + + //TINYINT + int8_t val_tinyint = 10; + type = TSDB_DATA_TYPE_TINYINT; + scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + printf("tiny_int before CEIL:%d\n", *((int8_t *)pInput->data)); + + code = ceil_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((int8_t *)pOutput->data + i), (int8_t)result); + printf("tiny_int after CEIL:%d\n", *((int8_t *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float = 9.5; + type = TSDB_DATA_TYPE_FLOAT; + scltMakeDataBlock(&pInput, type, &val_float, 1, true); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + printf("float before CEIL:%f\n", *((float *)pInput->data)); + + code = ceil_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((float *)pOutput->data + i), (float)result); + printf("float after CEIL:%f\n", *((float *)pOutput->data + i)); + } + + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); +} + +TEST(ScalarFunctionTest, ceil_function_column) { + SScalarParam *pInput, *pOutput; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + double result[] = {-10.0, 0.0, 10.0}; + + //TINYINT + int8_t val_tinyint[] = {-10, 0, 10}; + type = TSDB_DATA_TYPE_TINYINT; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((int8_t *)pInput->data + i) = val_tinyint[i]; + printf("tiny_int before CEIL:%d\n", *((int8_t *)pInput->data + i)); + } + + code = ceil_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((int8_t *)pOutput->data + i), result[i]); + printf("tiny_int after CEIL:%d\n", *((int8_t *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float[] = {-10.5, 0.0, 9.5}; + type = TSDB_DATA_TYPE_FLOAT; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((float *)pInput->data + i) = val_float[i]; + printf("float before CEIL:%f\n", *((float *)pInput->data + i)); + } + + code = ceil_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((float *)pOutput->data + i), result[i]); + printf("float after CEIL:%f\n", *((float *)pOutput->data + i)); + } + + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); +} + +TEST(ScalarFunctionTest, floor_function_constant) { + SScalarParam *pInput, *pOutput; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + double result = 10.0; + + //TINYINT + int8_t val_tinyint = 10; + type = TSDB_DATA_TYPE_TINYINT; + scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + printf("tiny_int before FLOOR:%d\n", *((int8_t *)pInput->data)); + + code = floor_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((int8_t *)pOutput->data + i), (int8_t)result); + printf("tiny_int after FLOOR:%d\n", *((int8_t *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float = 10.5; + type = TSDB_DATA_TYPE_FLOAT; + scltMakeDataBlock(&pInput, type, &val_float, 1, true); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + printf("float before FLOOR:%f\n", *((float *)pInput->data)); + + code = floor_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((float *)pOutput->data + i), (float)result); + printf("float after FLOOR:%f\n", *((float *)pOutput->data + i)); + } + + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); +} + +TEST(ScalarFunctionTest, floor_function_column) { + SScalarParam *pInput, *pOutput; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + double result[] = {-10.0, 0.0, 10.0}; + + //TINYINT + int8_t val_tinyint[] = {-10, 0, 10}; + type = TSDB_DATA_TYPE_TINYINT; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((int8_t *)pInput->data + i) = val_tinyint[i]; + printf("tiny_int before FLOOR:%d\n", *((int8_t *)pInput->data + i)); + } + + code = floor_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((int8_t *)pOutput->data + i), result[i]); + printf("tiny_int after FLOOR:%d\n", *((int8_t *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float[] = {-9.5, 0.0, 10.5}; + type = TSDB_DATA_TYPE_FLOAT; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((float *)pInput->data + i) = val_float[i]; + printf("float before FLOOR:%f\n", *((float *)pInput->data + i)); + } + + code = floor_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((float *)pOutput->data + i), result[i]); + printf("float after FLOOR:%f\n", *((float *)pOutput->data + i)); + } + + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); +} + +TEST(ScalarFunctionTest, round_function_constant) { + SScalarParam *pInput, *pOutput; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + double result = 10.0; + + //TINYINT + int8_t val_tinyint = 10; + type = TSDB_DATA_TYPE_TINYINT; + scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + printf("tiny_int before ROUND:%d\n", *((int8_t *)pInput->data)); + + code = round_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((int8_t *)pOutput->data + i), (int8_t)result); + printf("tiny_int after ROUND:%d\n", *((int8_t *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float = 9.5; + type = TSDB_DATA_TYPE_FLOAT; + scltMakeDataBlock(&pInput, type, &val_float, 1, true); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + printf("float before ROUND:%f\n", *((float *)pInput->data)); + + code = round_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((float *)pOutput->data + i), (float)result); + printf("float after ROUND:%f\n", *((float *)pOutput->data + i)); + } + + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); +} + +TEST(ScalarFunctionTest, round_function_column) { + SScalarParam *pInput, *pOutput; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + double result[] = {-10.0, 0.0, 10.0}; + + //TINYINT + int8_t val_tinyint[] = {-10, 0, 10}; + type = TSDB_DATA_TYPE_TINYINT; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((int8_t *)pInput->data + i) = val_tinyint[i]; + printf("tiny_int before ROUND:%d\n", *((int8_t *)pInput->data + i)); + } + + code = round_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((int8_t *)pOutput->data + i), result[i]); + printf("tiny_int after ROUND:%d\n", *((int8_t *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float[] = {-9.5, 0.0, 9.5}; + type = TSDB_DATA_TYPE_FLOAT; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((float *)pInput->data + i) = val_float[i]; + printf("float before ROUND:%f\n", *((float *)pInput->data + i)); + } + + code = round_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((float *)pOutput->data + i), result[i]); + printf("float after ROUND:%f\n", *((float *)pOutput->data + i)); + } + + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); +} + +TEST(ScalarFunctionTest, sqrt_function_constant) { + SScalarParam *pInput, *pOutput; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + int32_t otype = TSDB_DATA_TYPE_DOUBLE; + double result = 5.0; + + //TINYINT + int8_t val_tinyint = 25; + type = TSDB_DATA_TYPE_TINYINT; + scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + printf("tiny_int before SQRT:%d\n", *((int8_t *)pInput->data)); + + code = sqrt_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result); + printf("tiny_int after SQRT:%f\n", *((double *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float = 25.0; + type = TSDB_DATA_TYPE_FLOAT; + scltMakeDataBlock(&pInput, type, &val_float, 1, true); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + printf("float before SQRT:%f\n", *((float *)pInput->data)); + + code = sqrt_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result); + printf("float after SQRT:%f\n", *((double *)pOutput->data + i)); + } + + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); +} + +TEST(ScalarFunctionTest, sqrt_function_column) { + SScalarParam *pInput, *pOutput; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + int32_t otype = TSDB_DATA_TYPE_DOUBLE; + double result[] = {5.0, 9.0, 10.0}; + + //TINYINT + int8_t val_tinyint[] = {25, 81, 100}; + type = TSDB_DATA_TYPE_TINYINT; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((int8_t *)pInput->data + i) = val_tinyint[i]; + printf("tiny_int before SQRT:%d\n", *((int8_t *)pInput->data + i)); + } + + code = sqrt_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result[i]); + printf("tiny_int after SQRT:%f\n", *((double *)pOutput->data + i)); + } + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float[] = {25.0, 81.0, 100.0}; + type = TSDB_DATA_TYPE_FLOAT; + scltMakeDataBlock(&pInput, type, 0, rowNum, false); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + for (int32_t i = 0; i < rowNum; ++i) { + *((float *)pInput->data + i) = val_float[i]; + printf("float before SQRT:%f\n", *((float *)pInput->data + i)); + } + + code = sqrt_function(pInput, 1, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result[i]); + printf("float after SQRT:%f\n", *((double *)pOutput->data + i)); + } + + scltDestroyDataBlock(pInput); + scltDestroyDataBlock(pOutput); +} + +TEST(ScalarFunctionTest, log_function_constant) { + SScalarParam *pInput, *pOutput; + SScalarParam *input[2]; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + int32_t otype = TSDB_DATA_TYPE_DOUBLE; + double result = 3.0; + pInput = (SScalarParam *)calloc(2, sizeof(SScalarParam)); + + //TINYINT + int8_t val_tinyint[] = {27, 3}; + type = TSDB_DATA_TYPE_TINYINT; + for (int32_t i = 0; i < 2; ++i) { + scltMakeDataBlock(&input[i], type, &val_tinyint[i], 1, true); + pInput[i] = *input[i]; + } + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + printf("tiny_int before LOG: %d,%d\n", *((int8_t *)pInput[0].data), + *((int8_t *)pInput[1].data)); + + code = log_function(pInput, 2, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result); + printf("tiny_int after LOG:%f\n", *((double *)pOutput->data + i)); + } + scltDestroyDataBlock(input[0]); + scltDestroyDataBlock(input[1]); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float[] = {64.0, 4.0}; + type = TSDB_DATA_TYPE_FLOAT; + for (int32_t i = 0; i < 2; ++i) { + scltMakeDataBlock(&input[i], type, &val_float[i], 1, true); + pInput[i] = *input[i]; + } + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + printf("float before LOG: %f,%f\n", *((float *)pInput[0].data), + *((float *)pInput[1].data)); + + code = log_function(pInput, 2, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result); + printf("float after LOG:%f\n", *((double *)pOutput->data + i)); + } + scltDestroyDataBlock(input[0]); + scltDestroyDataBlock(input[1]); + scltDestroyDataBlock(pOutput); + + //TINYINT AND FLOAT + int8_t param0 = 64; + float param1 = 4.0; + scltMakeDataBlock(&input[0], TSDB_DATA_TYPE_TINYINT, ¶m0, 1, true); + pInput[0] = *input[0]; + scltMakeDataBlock(&input[1], TSDB_DATA_TYPE_FLOAT, ¶m1, 1, true); + pInput[1] = *input[1]; + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + + printf("tiny_int,float before LOG: %d,%f\n", *((int8_t *)pInput[0].data), *((float *)pInput[1].data)); + + code = log_function(pInput, 2, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result); + printf("tiny_int,float after LOG:%f\n", *((double *)pOutput->data + i)); + } + + scltDestroyDataBlock(input[0]); + scltDestroyDataBlock(input[1]); + scltDestroyDataBlock(pOutput); + free(pInput); +} + +TEST(ScalarFunctionTest, log_function_column) { + SScalarParam *pInput, *pOutput; + SScalarParam *input[2]; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + int32_t otype = TSDB_DATA_TYPE_DOUBLE; + double result[] = {2.0, 4.0, 3.0}; + pInput = (SScalarParam *)calloc(2, sizeof(SScalarParam)); + + //TINYINT + int8_t val_tinyint[2][3] = {{25, 81, 64}, {5, 3, 4}}; + 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) { + *((int8_t *)pInput[i].data + j) = val_tinyint[i][j]; + } + printf("tiny_int before LOG:%d,%d,%d\n", *((int8_t *)pInput[i].data + 0), + *((int8_t *)pInput[i].data + 1), + *((int8_t *)pInput[i].data + 2)); + } + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + + code = log_function(pInput, 2, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result[i]); + printf("tiny_int after LOG:%f\n", *((double *)pOutput->data + i)); + } + scltDestroyDataBlock(input[0]); + scltDestroyDataBlock(input[1]); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float[2][3] = {{25.0, 81.0, 64.0}, {5.0, 3.0, 4.0}}; + type = TSDB_DATA_TYPE_FLOAT; + 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) { + *((float *)pInput[i].data + j) = val_float[i][j]; + } + printf("float before LOG:%f,%f,%f\n", *((float *)pInput[i].data + 0), + *((float *)pInput[i].data + 1), + *((float *)pInput[i].data + 2)); + } + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + + code = log_function(pInput, 2, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result[i]); + printf("float after LOG:%f\n", *((double *)pOutput->data + i)); + } + scltDestroyDataBlock(input[0]); + scltDestroyDataBlock(input[1]); + scltDestroyDataBlock(pOutput); + + //TINYINT AND FLOAT + int8_t param0[] = {25, 81, 64}; + float param1[] = {5.0, 3.0, 4.0}; + scltMakeDataBlock(&input[0], TSDB_DATA_TYPE_TINYINT, 0, rowNum, false); + pInput[0] = *input[0]; + for (int32_t i = 0; i < rowNum; ++i) { + *((int8_t *)pInput[0].data + i) = param0[i]; + } + scltMakeDataBlock(&input[1], TSDB_DATA_TYPE_FLOAT, 0, rowNum, false); + pInput[1] = *input[1]; + for (int32_t i = 0; i < rowNum; ++i) { + *((float *)pInput[1].data + i) = param1[i]; + } + printf("tiny_int, float before LOG:{%d,%f}, {%d,%f}, {%d,%f}\n", *((int8_t *)pInput[0].data + 0), *((float *)pInput[1].data + 0), + *((int8_t *)pInput[0].data + 1), *((float *)pInput[1].data + 1), + *((int8_t *)pInput[0].data + 2), *((float *)pInput[1].data + 2)); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + + code = log_function(pInput, 2, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result[i]); + printf("tiny_int,float after LOG:%f\n", *((double *)pOutput->data + i)); + } + + scltDestroyDataBlock(input[0]); + scltDestroyDataBlock(input[1]); + scltDestroyDataBlock(pOutput); + free(pInput); +} + +TEST(ScalarFunctionTest, pow_function_constant) { + SScalarParam *pInput, *pOutput; + SScalarParam *input[2]; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + int32_t otype = TSDB_DATA_TYPE_DOUBLE; + double result = 16.0; + pInput = (SScalarParam *)calloc(2, sizeof(SScalarParam)); + + //TINYINT + int8_t val_tinyint[] = {2, 4}; + type = TSDB_DATA_TYPE_TINYINT; + for (int32_t i = 0; i < 2; ++i) { + scltMakeDataBlock(&input[i], type, &val_tinyint[i], 1, true); + pInput[i] = *input[i]; + } + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + printf("tiny_int before POW: %d,%d\n", *((int8_t *)pInput[0].data), + *((int8_t *)pInput[1].data)); + + code = pow_function(pInput, 2, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result); + printf("tiny_int after POW:%f\n", *((double *)pOutput->data + i)); + } + scltDestroyDataBlock(input[0]); + scltDestroyDataBlock(input[1]); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float[] = {2.0, 4.0}; + type = TSDB_DATA_TYPE_FLOAT; + for (int32_t i = 0; i < 2; ++i) { + scltMakeDataBlock(&input[i], type, &val_float[i], 1, true); + pInput[i] = *input[i]; + } + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + printf("float before POW: %f,%f\n", *((float *)pInput[0].data), + *((float *)pInput[1].data)); + + code = pow_function(pInput, 2, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result); + printf("float after POW:%f\n", *((double *)pOutput->data + i)); + } + scltDestroyDataBlock(input[0]); + scltDestroyDataBlock(input[1]); + scltDestroyDataBlock(pOutput); + + //TINYINT AND FLOAT + int8_t param0 = 2; + float param1 = 4.0; + scltMakeDataBlock(&input[0], TSDB_DATA_TYPE_TINYINT, ¶m0, 1, true); + pInput[0] = *input[0]; + scltMakeDataBlock(&input[1], TSDB_DATA_TYPE_FLOAT, ¶m1, 1, true); + pInput[1] = *input[1]; + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + + printf("tiny_int,float before POW: %d,%f\n", *((int8_t *)pInput[0].data), *((float *)pInput[1].data)); + + code = pow_function(pInput, 2, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result); + printf("tiny_int,float after POW:%f\n", *((double *)pOutput->data + i)); + } + + scltDestroyDataBlock(input[0]); + scltDestroyDataBlock(input[1]); + scltDestroyDataBlock(pOutput); + free(pInput); +} + +TEST(ScalarFunctionTest, pow_function_column) { + SScalarParam *pInput, *pOutput; + SScalarParam *input[2]; + int32_t code = TSDB_CODE_SUCCESS; + int32_t rowNum = 3; + int32_t type; + int32_t otype = TSDB_DATA_TYPE_DOUBLE; + double result[] = {32.0, 27.0, 16.0}; + pInput = (SScalarParam *)calloc(2, sizeof(SScalarParam)); + + //TINYINT + int8_t val_tinyint[2][3] = {{2, 3, 4}, {5, 3, 2}}; + 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) { + *((int8_t *)pInput[i].data + j) = val_tinyint[i][j]; + } + printf("tiny_int before POW:%d,%d,%d\n", *((int8_t *)pInput[i].data + 0), + *((int8_t *)pInput[i].data + 1), + *((int8_t *)pInput[i].data + 2)); + } + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + + code = pow_function(pInput, 2, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result[i]); + printf("tiny_int after POW:%f\n", *((double *)pOutput->data + i)); + } + + scltDestroyDataBlock(input[0]); + scltDestroyDataBlock(input[1]); + scltDestroyDataBlock(pOutput); + + //FLOAT + float val_float[2][3] = {{2.0, 3.0, 4.0}, {5.0, 3.0, 2.0}}; + type = TSDB_DATA_TYPE_FLOAT; + 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) { + *((float *)pInput[i].data + j) = val_float[i][j]; + } + printf("float before POW:%f,%f,%f\n", *((float *)pInput[i].data + 0), + *((float *)pInput[i].data + 1), + *((float *)pInput[i].data + 2)); + } + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + + code = pow_function(pInput, 2, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result[i]); + printf("float after POW:%f\n", *((double *)pOutput->data + i)); + } + scltDestroyDataBlock(input[0]); + scltDestroyDataBlock(input[1]); + scltDestroyDataBlock(pOutput); + + //TINYINT AND FLOAT + int8_t param0[] = {2, 3, 4}; + float param1[] = {5.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) { + *((int8_t *)pInput[0].data + i) = param0[i]; + } + scltMakeDataBlock(&input[1], TSDB_DATA_TYPE_FLOAT, 0, rowNum, false); + pInput[1] = *input[1]; + for (int32_t i = 0; i < rowNum; ++i) { + *((float *)pInput[1].data + i) = param1[i]; + } + printf("tiny_int, float before POW:{%d,%f}, {%d,%f}, {%d,%f}\n", *((int8_t *)pInput[0].data + 0), *((float *)pInput[1].data + 0), + *((int8_t *)pInput[0].data + 1), *((float *)pInput[1].data + 1), + *((int8_t *)pInput[0].data + 2), *((float *)pInput[1].data + 2)); + scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + + code = pow_function(pInput, 2, pOutput); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + for (int32_t i = 0; i < rowNum; ++i) { + ASSERT_EQ(*((double *)pOutput->data + i), result[i]); + printf("tiny_int,float after POW:%f\n", *((double *)pOutput->data + i)); + } + + scltDestroyDataBlock(input[0]); + scltDestroyDataBlock(input[1]); + scltDestroyDataBlock(pOutput); + free(pInput); +} int main(int argc, char** argv) { taosSeedRand(taosGetTimestampSec()); From eef9b77490a10cef848b8c561966ea908e1ebd81 Mon Sep 17 00:00:00 2001 From: Ganlin Zhao Date: Fri, 25 Mar 2022 16:24:36 +0800 Subject: [PATCH 3/5] [TD-14240]: add math functions --- .../libs/scalar/test/scalar/scalarTests.cpp | 264 +++++++++--------- 1 file changed, 136 insertions(+), 128 deletions(-) diff --git a/source/libs/scalar/test/scalar/scalarTests.cpp b/source/libs/scalar/test/scalar/scalarTests.cpp index 2acd046a95..7e75a4ef94 100644 --- a/source/libs/scalar/test/scalar/scalarTests.cpp +++ b/source/libs/scalar/test/scalar/scalarTests.cpp @@ -40,6 +40,14 @@ #include "nodes.h" #include "tlog.h" +#define _DEBUG_PRINT_ 0 + +#if _DEBUG_PRINT_ +#define PRINTF(...) printf(__VA_ARGS__) +#else +#define PRINTF(...) +#endif + namespace { SColumnInfo createColumnInfo(int32_t colId, int32_t type, int32_t bytes) { @@ -1599,13 +1607,13 @@ TEST(ScalarFunctionTest, abs_function_constant) { type = TSDB_DATA_TYPE_FLOAT; scltMakeDataBlock(&pInput, type, &val_float, 1, true); 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((float *)pOutput->data + i), val_float); - printf("float after ABS:%f\n", *((float *)pOutput->data + i)); + PRINTF("float after ABS:%f\n", *((float *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -1613,13 +1621,13 @@ TEST(ScalarFunctionTest, abs_function_constant) { val_float = -10.15; scltMakeDataBlock(&pInput, type, &val_float, 1, true); 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((float *)pOutput->data + i), -val_float); - printf("float after ABS:%f\n", *((float *)pOutput->data + i)); + PRINTF("float after ABS:%f\n", *((float *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -1665,14 +1673,14 @@ TEST(ScalarFunctionTest, abs_function_column) { scltMakeDataBlock(&pOutput, type, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((int8_t *)pInput->data + i) = val_tinyint + i; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((int8_t *)pOutput->data + i), val_tinyint + i); - printf("tiny_int after ABS:%d\n", *((int8_t *)pOutput->data + i)); + PRINTF("tiny_int after ABS:%d\n", *((int8_t *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -1682,14 +1690,14 @@ TEST(ScalarFunctionTest, abs_function_column) { scltMakeDataBlock(&pOutput, type, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((int8_t *)pInput->data + i) = val_tinyint + i; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((int8_t *)pOutput->data + i), -(val_tinyint + i)); - printf("tiny_int after ABS:%d\n", *((int8_t *)pOutput->data + i)); + PRINTF("tiny_int after ABS:%d\n", *((int8_t *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -1701,7 +1709,7 @@ TEST(ScalarFunctionTest, abs_function_column) { scltMakeDataBlock(&pOutput, type, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((int16_t *)pInput->data + i) = val_smallint + i; - printf("small_int before ABS:%d\n", *((int16_t *)pInput->data + i)); + PRINTF("small_int before ABS:%d\n", *((int16_t *)pInput->data + i)); } @@ -1709,7 +1717,7 @@ TEST(ScalarFunctionTest, abs_function_column) { ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((int16_t *)pOutput->data + i), val_smallint + i); - printf("small_int after ABS:%d\n", *((int16_t *)pOutput->data + i)); + PRINTF("small_int after ABS:%d\n", *((int16_t *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -1719,14 +1727,14 @@ TEST(ScalarFunctionTest, abs_function_column) { scltMakeDataBlock(&pOutput, type, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((int16_t *)pInput->data + i) = val_smallint + i; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((int16_t *)pOutput->data + i), -(val_smallint + i)); - printf("small_int after ABS:%d\n", *((int16_t *)pOutput->data + i)); + PRINTF("small_int after ABS:%d\n", *((int16_t *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -1738,7 +1746,7 @@ TEST(ScalarFunctionTest, abs_function_column) { scltMakeDataBlock(&pOutput, type, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((int32_t *)pInput->data + i) = val_int + i; - printf("int before ABS:%d\n", *((int32_t *)pInput->data + i)); + PRINTF("int before ABS:%d\n", *((int32_t *)pInput->data + i)); } @@ -1746,7 +1754,7 @@ TEST(ScalarFunctionTest, abs_function_column) { ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((int32_t *)pOutput->data + i), val_int + i); - printf("int after ABS:%d\n", *((int32_t *)pOutput->data + i)); + PRINTF("int after ABS:%d\n", *((int32_t *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -1756,14 +1764,14 @@ TEST(ScalarFunctionTest, abs_function_column) { scltMakeDataBlock(&pOutput, type, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((int32_t *)pInput->data + i) = val_int + i; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((int32_t *)pOutput->data + i), -(val_int + i)); - printf("int after ABS:%d\n", *((int32_t *)pOutput->data + i)); + PRINTF("int after ABS:%d\n", *((int32_t *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -1775,14 +1783,14 @@ TEST(ScalarFunctionTest, abs_function_column) { scltMakeDataBlock(&pOutput, type, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((float *)pInput->data + i) = val_float + i; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((float *)pOutput->data + i), val_float + i); - printf("float after ABS:%f\n", *((float *)pOutput->data + i)); + PRINTF("float after ABS:%f\n", *((float *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -1792,14 +1800,14 @@ TEST(ScalarFunctionTest, abs_function_column) { scltMakeDataBlock(&pOutput, type, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((float *)pInput->data + i) = val_float + i; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((float *)pOutput->data + i), -(val_float + i)); - printf("float after ABS:%f\n", *((float *)pOutput->data + i)); + PRINTF("float after ABS:%f\n", *((float *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -1811,14 +1819,14 @@ TEST(ScalarFunctionTest, abs_function_column) { scltMakeDataBlock(&pOutput, type, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((double *)pInput->data + i) = val_double + i; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), val_double + i); - printf("double after ABS:%f\n", *((double *)pOutput->data + i)); + PRINTF("double after ABS:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -1828,14 +1836,14 @@ TEST(ScalarFunctionTest, abs_function_column) { scltMakeDataBlock(&pOutput, type, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((double *)pInput->data + i) = val_double + i; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), -(val_double + i)); - printf("double after ABS:%f\n", *((double *)pOutput->data + i)); + PRINTF("double after ABS:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); @@ -1855,13 +1863,13 @@ TEST(ScalarFunctionTest, sin_function_constant) { type = TSDB_DATA_TYPE_TINYINT; scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); - printf("tiny_int after SIN:%f\n", *((double *)pOutput->data + i)); + PRINTF("tiny_int after SIN:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -1871,13 +1879,13 @@ TEST(ScalarFunctionTest, sin_function_constant) { type = TSDB_DATA_TYPE_FLOAT; scltMakeDataBlock(&pInput, type, &val_float, 1, true); 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); - printf("float after SIN:%f\n", *((double *)pOutput->data + i)); + PRINTF("float after SIN:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); @@ -1901,14 +1909,14 @@ TEST(ScalarFunctionTest, sin_function_column) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((int8_t *)pInput->data + i) = val_tinyint[i]; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); - printf("tiny_int after SIN:%f\n", *((double *)pOutput->data + i)); + PRINTF("tiny_int after SIN:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -1920,14 +1928,14 @@ TEST(ScalarFunctionTest, sin_function_column) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((float *)pInput->data + i) = val_float[i]; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); - printf("float after SIN:%f\n", *((double *)pOutput->data + i)); + PRINTF("float after SIN:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); @@ -1947,13 +1955,13 @@ TEST(ScalarFunctionTest, cos_function_constant) { type = TSDB_DATA_TYPE_TINYINT; scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); - printf("tiny_int after COS:%f\n", *((double *)pOutput->data + i)); + PRINTF("tiny_int after COS:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -1963,13 +1971,13 @@ TEST(ScalarFunctionTest, cos_function_constant) { type = TSDB_DATA_TYPE_FLOAT; scltMakeDataBlock(&pInput, type, &val_float, 1, true); 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); - printf("float after COS:%f\n", *((double *)pOutput->data + i)); + PRINTF("float after COS:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); @@ -1991,14 +1999,14 @@ TEST(ScalarFunctionTest, cos_function_column) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((int8_t *)pInput->data + i) = val_tinyint[i]; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); - printf("tiny_int after COS:%f\n", *((double *)pOutput->data + i)); + PRINTF("tiny_int after COS:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -2010,14 +2018,14 @@ TEST(ScalarFunctionTest, cos_function_column) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((float *)pInput->data + i) = val_float[i]; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); - printf("float after COS:%f\n", *((double *)pOutput->data + i)); + PRINTF("float after COS:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); @@ -2037,13 +2045,13 @@ TEST(ScalarFunctionTest, tan_function_constant) { type = TSDB_DATA_TYPE_TINYINT; scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); - printf("tiny_int after TAN:%f\n", *((double *)pOutput->data + i)); + PRINTF("tiny_int after TAN:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -2053,13 +2061,13 @@ TEST(ScalarFunctionTest, tan_function_constant) { type = TSDB_DATA_TYPE_FLOAT; scltMakeDataBlock(&pInput, type, &val_float, 1, true); 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); - printf("float after TAN:%f\n", *((double *)pOutput->data + i)); + PRINTF("float after TAN:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); @@ -2081,14 +2089,14 @@ TEST(ScalarFunctionTest, tan_function_column) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((int8_t *)pInput->data + i) = val_tinyint[i]; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); - printf("tiny_int after TAN:%f\n", *((double *)pOutput->data + i)); + PRINTF("tiny_int after TAN:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -2100,14 +2108,14 @@ TEST(ScalarFunctionTest, tan_function_column) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((float *)pInput->data + i) = val_float[i]; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); - printf("float after TAN:%f\n", *((double *)pOutput->data + i)); + PRINTF("float after TAN:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); @@ -2127,13 +2135,13 @@ TEST(ScalarFunctionTest, asin_function_constant) { type = TSDB_DATA_TYPE_TINYINT; scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); - printf("tiny_int after ASIN:%f\n", *((double *)pOutput->data + i)); + PRINTF("tiny_int after ASIN:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -2143,13 +2151,13 @@ TEST(ScalarFunctionTest, asin_function_constant) { type = TSDB_DATA_TYPE_FLOAT; scltMakeDataBlock(&pInput, type, &val_float, 1, true); 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); - printf("float after ASIN:%f\n", *((double *)pOutput->data + i)); + PRINTF("float after ASIN:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); @@ -2172,14 +2180,14 @@ TEST(ScalarFunctionTest, asin_function_column) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((int8_t *)pInput->data + i) = val_tinyint[i]; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); - printf("tiny_int after ASIN:%f\n", *((double *)pOutput->data + i)); + PRINTF("tiny_int after ASIN:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -2191,14 +2199,14 @@ TEST(ScalarFunctionTest, asin_function_column) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((float *)pInput->data + i) = val_float[i]; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); - printf("float after ASIN:%f\n", *((double *)pOutput->data + i)); + PRINTF("float after ASIN:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); @@ -2218,13 +2226,13 @@ TEST(ScalarFunctionTest, acos_function_constant) { type = TSDB_DATA_TYPE_TINYINT; scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); - printf("tiny_int after ACOS:%f\n", *((double *)pOutput->data + i)); + PRINTF("tiny_int after ACOS:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -2234,13 +2242,13 @@ TEST(ScalarFunctionTest, acos_function_constant) { type = TSDB_DATA_TYPE_FLOAT; scltMakeDataBlock(&pInput, type, &val_float, 1, true); 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); - printf("float after ACOS:%f\n", *((double *)pOutput->data + i)); + PRINTF("float after ACOS:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); @@ -2262,14 +2270,14 @@ TEST(ScalarFunctionTest, acos_function_column) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((int8_t *)pInput->data + i) = val_tinyint[i]; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); - printf("tiny_int after ACOS:%f\n", *((double *)pOutput->data + i)); + PRINTF("tiny_int after ACOS:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -2281,14 +2289,14 @@ TEST(ScalarFunctionTest, acos_function_column) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((float *)pInput->data + i) = val_float[i]; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); - printf("float after ACOS:%f\n", *((double *)pOutput->data + i)); + PRINTF("float after ACOS:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); @@ -2308,13 +2316,13 @@ TEST(ScalarFunctionTest, atan_function_constant) { type = TSDB_DATA_TYPE_TINYINT; scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); - printf("tiny_int after ATAN:%f\n", *((double *)pOutput->data + i)); + PRINTF("tiny_int after ATAN:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -2324,13 +2332,13 @@ TEST(ScalarFunctionTest, atan_function_constant) { type = TSDB_DATA_TYPE_FLOAT; scltMakeDataBlock(&pInput, type, &val_float, 1, true); 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); - printf("float after ATAN:%f\n", *((double *)pOutput->data + i)); + PRINTF("float after ATAN:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); @@ -2352,14 +2360,14 @@ TEST(ScalarFunctionTest, atan_function_column) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((int8_t *)pInput->data + i) = val_tinyint[i]; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); - printf("tiny_int after ATAN:%f\n", *((double *)pOutput->data + i)); + PRINTF("tiny_int after ATAN:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -2371,14 +2379,14 @@ TEST(ScalarFunctionTest, atan_function_column) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((float *)pInput->data + i) = val_float[i]; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); - printf("float after ATAN:%f\n", *((double *)pOutput->data + i)); + PRINTF("float after ATAN:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); @@ -2397,13 +2405,13 @@ TEST(ScalarFunctionTest, ceil_function_constant) { type = TSDB_DATA_TYPE_TINYINT; scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((int8_t *)pOutput->data + i), (int8_t)result); - printf("tiny_int after CEIL:%d\n", *((int8_t *)pOutput->data + i)); + PRINTF("tiny_int after CEIL:%d\n", *((int8_t *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -2413,13 +2421,13 @@ TEST(ScalarFunctionTest, ceil_function_constant) { type = TSDB_DATA_TYPE_FLOAT; scltMakeDataBlock(&pInput, type, &val_float, 1, true); 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((float *)pOutput->data + i), (float)result); - printf("float after CEIL:%f\n", *((float *)pOutput->data + i)); + PRINTF("float after CEIL:%f\n", *((float *)pOutput->data + i)); } scltDestroyDataBlock(pInput); @@ -2440,14 +2448,14 @@ TEST(ScalarFunctionTest, ceil_function_column) { scltMakeDataBlock(&pOutput, type, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((int8_t *)pInput->data + i) = val_tinyint[i]; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((int8_t *)pOutput->data + i), result[i]); - printf("tiny_int after CEIL:%d\n", *((int8_t *)pOutput->data + i)); + PRINTF("tiny_int after CEIL:%d\n", *((int8_t *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -2459,14 +2467,14 @@ TEST(ScalarFunctionTest, ceil_function_column) { scltMakeDataBlock(&pOutput, type, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((float *)pInput->data + i) = val_float[i]; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((float *)pOutput->data + i), result[i]); - printf("float after CEIL:%f\n", *((float *)pOutput->data + i)); + PRINTF("float after CEIL:%f\n", *((float *)pOutput->data + i)); } scltDestroyDataBlock(pInput); @@ -2485,13 +2493,13 @@ TEST(ScalarFunctionTest, floor_function_constant) { type = TSDB_DATA_TYPE_TINYINT; scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((int8_t *)pOutput->data + i), (int8_t)result); - printf("tiny_int after FLOOR:%d\n", *((int8_t *)pOutput->data + i)); + PRINTF("tiny_int after FLOOR:%d\n", *((int8_t *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -2501,13 +2509,13 @@ TEST(ScalarFunctionTest, floor_function_constant) { type = TSDB_DATA_TYPE_FLOAT; scltMakeDataBlock(&pInput, type, &val_float, 1, true); 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((float *)pOutput->data + i), (float)result); - printf("float after FLOOR:%f\n", *((float *)pOutput->data + i)); + PRINTF("float after FLOOR:%f\n", *((float *)pOutput->data + i)); } scltDestroyDataBlock(pInput); @@ -2528,14 +2536,14 @@ TEST(ScalarFunctionTest, floor_function_column) { scltMakeDataBlock(&pOutput, type, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((int8_t *)pInput->data + i) = val_tinyint[i]; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((int8_t *)pOutput->data + i), result[i]); - printf("tiny_int after FLOOR:%d\n", *((int8_t *)pOutput->data + i)); + PRINTF("tiny_int after FLOOR:%d\n", *((int8_t *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -2547,14 +2555,14 @@ TEST(ScalarFunctionTest, floor_function_column) { scltMakeDataBlock(&pOutput, type, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((float *)pInput->data + i) = val_float[i]; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((float *)pOutput->data + i), result[i]); - printf("float after FLOOR:%f\n", *((float *)pOutput->data + i)); + PRINTF("float after FLOOR:%f\n", *((float *)pOutput->data + i)); } scltDestroyDataBlock(pInput); @@ -2573,13 +2581,13 @@ TEST(ScalarFunctionTest, round_function_constant) { type = TSDB_DATA_TYPE_TINYINT; scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((int8_t *)pOutput->data + i), (int8_t)result); - printf("tiny_int after ROUND:%d\n", *((int8_t *)pOutput->data + i)); + PRINTF("tiny_int after ROUND:%d\n", *((int8_t *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -2589,13 +2597,13 @@ TEST(ScalarFunctionTest, round_function_constant) { type = TSDB_DATA_TYPE_FLOAT; scltMakeDataBlock(&pInput, type, &val_float, 1, true); 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((float *)pOutput->data + i), (float)result); - printf("float after ROUND:%f\n", *((float *)pOutput->data + i)); + PRINTF("float after ROUND:%f\n", *((float *)pOutput->data + i)); } scltDestroyDataBlock(pInput); @@ -2616,14 +2624,14 @@ TEST(ScalarFunctionTest, round_function_column) { scltMakeDataBlock(&pOutput, type, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((int8_t *)pInput->data + i) = val_tinyint[i]; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((int8_t *)pOutput->data + i), result[i]); - printf("tiny_int after ROUND:%d\n", *((int8_t *)pOutput->data + i)); + PRINTF("tiny_int after ROUND:%d\n", *((int8_t *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -2635,14 +2643,14 @@ TEST(ScalarFunctionTest, round_function_column) { scltMakeDataBlock(&pOutput, type, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((float *)pInput->data + i) = val_float[i]; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((float *)pOutput->data + i), result[i]); - printf("float after ROUND:%f\n", *((float *)pOutput->data + i)); + PRINTF("float after ROUND:%f\n", *((float *)pOutput->data + i)); } scltDestroyDataBlock(pInput); @@ -2662,13 +2670,13 @@ TEST(ScalarFunctionTest, sqrt_function_constant) { type = TSDB_DATA_TYPE_TINYINT; scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); - printf("tiny_int after SQRT:%f\n", *((double *)pOutput->data + i)); + PRINTF("tiny_int after SQRT:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -2678,13 +2686,13 @@ TEST(ScalarFunctionTest, sqrt_function_constant) { type = TSDB_DATA_TYPE_FLOAT; scltMakeDataBlock(&pInput, type, &val_float, 1, true); 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); - printf("float after SQRT:%f\n", *((double *)pOutput->data + i)); + PRINTF("float after SQRT:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); @@ -2706,14 +2714,14 @@ TEST(ScalarFunctionTest, sqrt_function_column) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((int8_t *)pInput->data + i) = val_tinyint[i]; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); - printf("tiny_int after SQRT:%f\n", *((double *)pOutput->data + i)); + PRINTF("tiny_int after SQRT:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); scltDestroyDataBlock(pOutput); @@ -2725,14 +2733,14 @@ TEST(ScalarFunctionTest, sqrt_function_column) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { *((float *)pInput->data + i) = val_float[i]; - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); - printf("float after SQRT:%f\n", *((double *)pOutput->data + i)); + PRINTF("float after SQRT:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(pInput); @@ -2757,14 +2765,14 @@ TEST(ScalarFunctionTest, log_function_constant) { pInput[i] = *input[i]; } scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); - 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)); code = log_function(pInput, 2, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); - printf("tiny_int after LOG:%f\n", *((double *)pOutput->data + i)); + PRINTF("tiny_int after LOG:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(input[0]); scltDestroyDataBlock(input[1]); @@ -2778,14 +2786,14 @@ TEST(ScalarFunctionTest, log_function_constant) { pInput[i] = *input[i]; } scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); - 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)); code = log_function(pInput, 2, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); - printf("float after LOG:%f\n", *((double *)pOutput->data + i)); + PRINTF("float after LOG:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(input[0]); scltDestroyDataBlock(input[1]); @@ -2800,13 +2808,13 @@ TEST(ScalarFunctionTest, log_function_constant) { pInput[1] = *input[1]; scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); - printf("tiny_int,float after LOG:%f\n", *((double *)pOutput->data + i)); + PRINTF("tiny_int,float after LOG:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(input[0]); @@ -2834,7 +2842,7 @@ TEST(ScalarFunctionTest, log_function_column) { for (int32_t j = 0; j < rowNum; ++j) { *((int8_t *)pInput[i].data + j) = val_tinyint[i][j]; } - printf("tiny_int before LOG:%d,%d,%d\n", *((int8_t *)pInput[i].data + 0), + PRINTF("tiny_int before LOG:%d,%d,%d\n", *((int8_t *)pInput[i].data + 0), *((int8_t *)pInput[i].data + 1), *((int8_t *)pInput[i].data + 2)); } @@ -2844,7 +2852,7 @@ TEST(ScalarFunctionTest, log_function_column) { ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); - printf("tiny_int after LOG:%f\n", *((double *)pOutput->data + i)); + PRINTF("tiny_int after LOG:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(input[0]); scltDestroyDataBlock(input[1]); @@ -2859,7 +2867,7 @@ TEST(ScalarFunctionTest, log_function_column) { for (int32_t j = 0; j < rowNum; ++j) { *((float *)pInput[i].data + j) = val_float[i][j]; } - printf("float before LOG:%f,%f,%f\n", *((float *)pInput[i].data + 0), + PRINTF("float before LOG:%f,%f,%f\n", *((float *)pInput[i].data + 0), *((float *)pInput[i].data + 1), *((float *)pInput[i].data + 2)); } @@ -2869,7 +2877,7 @@ TEST(ScalarFunctionTest, log_function_column) { ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); - printf("float after LOG:%f\n", *((double *)pOutput->data + i)); + PRINTF("float after LOG:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(input[0]); scltDestroyDataBlock(input[1]); @@ -2888,7 +2896,7 @@ TEST(ScalarFunctionTest, log_function_column) { for (int32_t i = 0; i < rowNum; ++i) { *((float *)pInput[1].data + i) = param1[i]; } - printf("tiny_int, float before LOG:{%d,%f}, {%d,%f}, {%d,%f}\n", *((int8_t *)pInput[0].data + 0), *((float *)pInput[1].data + 0), + PRINTF("tiny_int, float before LOG:{%d,%f}, {%d,%f}, {%d,%f}\n", *((int8_t *)pInput[0].data + 0), *((float *)pInput[1].data + 0), *((int8_t *)pInput[0].data + 1), *((float *)pInput[1].data + 1), *((int8_t *)pInput[0].data + 2), *((float *)pInput[1].data + 2)); scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); @@ -2897,7 +2905,7 @@ TEST(ScalarFunctionTest, log_function_column) { ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); - printf("tiny_int,float after LOG:%f\n", *((double *)pOutput->data + i)); + PRINTF("tiny_int,float after LOG:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(input[0]); @@ -2924,14 +2932,14 @@ TEST(ScalarFunctionTest, pow_function_constant) { pInput[i] = *input[i]; } scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); - 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)); code = pow_function(pInput, 2, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); - printf("tiny_int after POW:%f\n", *((double *)pOutput->data + i)); + PRINTF("tiny_int after POW:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(input[0]); scltDestroyDataBlock(input[1]); @@ -2945,14 +2953,14 @@ TEST(ScalarFunctionTest, pow_function_constant) { pInput[i] = *input[i]; } scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); - 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)); code = pow_function(pInput, 2, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); - printf("float after POW:%f\n", *((double *)pOutput->data + i)); + PRINTF("float after POW:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(input[0]); scltDestroyDataBlock(input[1]); @@ -2967,13 +2975,13 @@ TEST(ScalarFunctionTest, pow_function_constant) { pInput[1] = *input[1]; scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); - 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); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); - printf("tiny_int,float after POW:%f\n", *((double *)pOutput->data + i)); + PRINTF("tiny_int,float after POW:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(input[0]); @@ -3001,7 +3009,7 @@ TEST(ScalarFunctionTest, pow_function_column) { for (int32_t j = 0; j < rowNum; ++j) { *((int8_t *)pInput[i].data + j) = val_tinyint[i][j]; } - printf("tiny_int before POW:%d,%d,%d\n", *((int8_t *)pInput[i].data + 0), + PRINTF("tiny_int before POW:%d,%d,%d\n", *((int8_t *)pInput[i].data + 0), *((int8_t *)pInput[i].data + 1), *((int8_t *)pInput[i].data + 2)); } @@ -3011,7 +3019,7 @@ TEST(ScalarFunctionTest, pow_function_column) { ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); - printf("tiny_int after POW:%f\n", *((double *)pOutput->data + i)); + PRINTF("tiny_int after POW:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(input[0]); @@ -3027,7 +3035,7 @@ TEST(ScalarFunctionTest, pow_function_column) { for (int32_t j = 0; j < rowNum; ++j) { *((float *)pInput[i].data + j) = val_float[i][j]; } - printf("float before POW:%f,%f,%f\n", *((float *)pInput[i].data + 0), + PRINTF("float before POW:%f,%f,%f\n", *((float *)pInput[i].data + 0), *((float *)pInput[i].data + 1), *((float *)pInput[i].data + 2)); } @@ -3037,7 +3045,7 @@ TEST(ScalarFunctionTest, pow_function_column) { ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); - printf("float after POW:%f\n", *((double *)pOutput->data + i)); + PRINTF("float after POW:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(input[0]); scltDestroyDataBlock(input[1]); @@ -3056,7 +3064,7 @@ TEST(ScalarFunctionTest, pow_function_column) { for (int32_t i = 0; i < rowNum; ++i) { *((float *)pInput[1].data + i) = param1[i]; } - printf("tiny_int, float before POW:{%d,%f}, {%d,%f}, {%d,%f}\n", *((int8_t *)pInput[0].data + 0), *((float *)pInput[1].data + 0), + PRINTF("tiny_int, float before POW:{%d,%f}, {%d,%f}, {%d,%f}\n", *((int8_t *)pInput[0].data + 0), *((float *)pInput[1].data + 0), *((int8_t *)pInput[0].data + 1), *((float *)pInput[1].data + 1), *((int8_t *)pInput[0].data + 2), *((float *)pInput[1].data + 2)); scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); @@ -3065,7 +3073,7 @@ TEST(ScalarFunctionTest, pow_function_column) { ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); - printf("tiny_int,float after POW:%f\n", *((double *)pOutput->data + i)); + PRINTF("tiny_int,float after POW:%f\n", *((double *)pOutput->data + i)); } scltDestroyDataBlock(input[0]); From 303a853c0c6040c2c9a50e2bceeba50afc2d8013 Mon Sep 17 00:00:00 2001 From: Ganlin Zhao Date: Fri, 25 Mar 2022 16:24:36 +0800 Subject: [PATCH 4/5] [TD-14240]: add math functions --- include/libs/function/functionMgt.h | 17 +- include/libs/scalar/scalar.h | 15 ++ source/libs/function/CMakeLists.txt | 4 +- source/libs/function/src/builtins.c | 131 ++++++++++++ source/libs/scalar/inc/sclfunc.h | 15 -- source/libs/scalar/src/sclfunc.c | 26 +-- .../libs/scalar/test/scalar/scalarTests.cpp | 201 +++++++++--------- 7 files changed, 270 insertions(+), 139 deletions(-) diff --git a/include/libs/function/functionMgt.h b/include/libs/function/functionMgt.h index 35832fa298..85a9cd0b23 100644 --- a/include/libs/function/functionMgt.h +++ b/include/libs/function/functionMgt.h @@ -57,18 +57,19 @@ typedef enum EFunctionType { // math function 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_POW, - FUNCTION_TYPE_ROUND, - FUNCTION_TYPE_SIN, FUNCTION_TYPE_SQRT, + FUNCTION_TYPE_CEIL, + FUNCTION_TYPE_FLOOR, + FUNCTION_TYPE_ROUND, + + FUNCTION_TYPE_SIN, + FUNCTION_TYPE_COS, FUNCTION_TYPE_TAN, + FUNCTION_TYPE_ASIN, + FUNCTION_TYPE_ACOS, + FUNCTION_TYPE_ATAN, // string function FUNCTION_TYPE_CHAR_LENGTH = 1500, diff --git a/include/libs/scalar/scalar.h b/include/libs/scalar/scalar.h index e55c0b9e76..12c03afcb6 100644 --- a/include/libs/scalar/scalar.h +++ b/include/libs/scalar/scalar.h @@ -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 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 } diff --git a/source/libs/function/CMakeLists.txt b/source/libs/function/CMakeLists.txt index a10a542b6b..5d4bf2726e 100644 --- a/source/libs/function/CMakeLists.txt +++ b/source/libs/function/CMakeLists.txt @@ -8,5 +8,5 @@ target_include_directories( target_link_libraries( function - PRIVATE os util common nodes -) \ No newline at end of file + PRIVATE os util common nodes scalar +) diff --git a/source/libs/function/src/builtins.c b/source/libs/function/src/builtins.c index e27d53c1ee..70b2a48da7 100644 --- a/source/libs/function/src/builtins.c +++ b/source/libs/function/src/builtins.c @@ -15,6 +15,7 @@ #include "builtins.h" #include "builtinsimpl.h" +#include "scalar.h" #include "taoserror.h" #include "tdatablock.h" @@ -151,6 +152,136 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = { .processFunc = lastFunction, .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", .type = FUNCTION_TYPE_CONCAT, diff --git a/source/libs/scalar/inc/sclfunc.h b/source/libs/scalar/inc/sclfunc.h index bffd96ea5d..8915f37261 100644 --- a/source/libs/scalar/inc/sclfunc.h +++ b/source/libs/scalar/inc/sclfunc.h @@ -36,21 +36,6 @@ extern struct SScalarFunctionInfo scalarFunc[8]; int32_t evaluateExprNodeTree(tExprNode* pExprs, int32_t numOfRows, SScalarParam* pOutput, 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 } diff --git a/source/libs/scalar/src/sclfunc.c b/source/libs/scalar/src/sclfunc.c index 96f24ade17..a56f6a0925 100644 --- a/source/libs/scalar/src/sclfunc.c +++ b/source/libs/scalar/src/sclfunc.c @@ -8,7 +8,7 @@ static void assignBasicParaInfo(struct SScalarParam* dst, const struct SScalarPa } /** 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); if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) { return TSDB_CODE_FAILED; @@ -93,7 +93,7 @@ int32_t abs_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp 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)) { return TSDB_CODE_FAILED; } @@ -136,7 +136,7 @@ int32_t log_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp 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)) { return TSDB_CODE_FAILED; } @@ -179,7 +179,7 @@ int32_t pow_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp 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)) { return TSDB_CODE_FAILED; } @@ -210,7 +210,7 @@ int32_t sqrt_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOut 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)) { return TSDB_CODE_FAILED; } @@ -241,7 +241,7 @@ int32_t sin_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp 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)) { return TSDB_CODE_FAILED; } @@ -272,7 +272,7 @@ int32_t cos_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp 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)) { return TSDB_CODE_FAILED; } @@ -303,7 +303,7 @@ int32_t tan_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp 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)) { return TSDB_CODE_FAILED; } @@ -334,7 +334,7 @@ int32_t asin_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOut 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)) { return TSDB_CODE_FAILED; } @@ -365,7 +365,7 @@ int32_t acos_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOut 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)) { return TSDB_CODE_FAILED; } @@ -396,7 +396,7 @@ int32_t atan_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOut 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)) { return TSDB_CODE_FAILED; } @@ -442,7 +442,7 @@ int32_t ceil_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOut 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); if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) { return TSDB_CODE_FAILED; @@ -489,7 +489,7 @@ int32_t floor_function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOu 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); if (inputNum != 1 || !IS_NUMERIC_TYPE(pInput->type)) { return TSDB_CODE_FAILED; diff --git a/source/libs/scalar/test/scalar/scalarTests.cpp b/source/libs/scalar/test/scalar/scalarTests.cpp index 7e75a4ef94..d36a117491 100644 --- a/source/libs/scalar/test/scalar/scalarTests.cpp +++ b/source/libs/scalar/test/scalar/scalarTests.cpp @@ -36,7 +36,6 @@ #include "tdatablock.h" #include "stub.h" #include "scalar.h" -#include "sclfunc.h" #include "nodes.h" #include "tlog.h" @@ -1492,7 +1491,7 @@ void scltDestroyDataBlock(SScalarParam *pInput) { free(pInput); } -TEST(ScalarFunctionTest, abs_function_constant) { +TEST(ScalarFunctionTest, absFunction_constant) { SScalarParam *pInput, *pOutput; int32_t code = TSDB_CODE_SUCCESS; int32_t rowNum = 3; @@ -1504,7 +1503,7 @@ TEST(ScalarFunctionTest, abs_function_constant) { scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true); scltMakeDataBlock(&pOutput, type, 0, rowNum, false); - code = abs_function(pInput, 1, pOutput); + code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { 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(&pOutput, type, 0, rowNum, false); - code = abs_function(pInput, 1, pOutput); + code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { 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(&pOutput, type, 0, rowNum, false); - code = abs_function(pInput, 1, pOutput); + code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { 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(&pOutput, type, 0, rowNum, false); - code = abs_function(pInput, 1, pOutput); + code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { 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(&pOutput, type, 0, rowNum, false); - code = abs_function(pInput, 1, pOutput); + code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { 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(&pOutput, type, 0, rowNum, false); - code = abs_function(pInput, 1, pOutput); + code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { 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(&pOutput, type, 0, rowNum, false); - code = abs_function(pInput, 1, pOutput); + code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { 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(&pOutput, type, 0, rowNum, false); - code = abs_function(pInput, 1, pOutput); + code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((int64_t *)pOutput->data + i), -val_bigint); @@ -1609,7 +1608,7 @@ TEST(ScalarFunctionTest, abs_function_constant) { scltMakeDataBlock(&pOutput, type, 0, rowNum, false); 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); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((float *)pOutput->data + i), val_float); @@ -1623,7 +1622,7 @@ TEST(ScalarFunctionTest, abs_function_constant) { scltMakeDataBlock(&pOutput, type, 0, rowNum, false); 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); for (int32_t i = 0; i < rowNum; ++i) { 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(&pOutput, type, 0, rowNum, false); - code = abs_function(pInput, 1, pOutput); + code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { 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(&pOutput, type, 0, rowNum, false); - code = abs_function(pInput, 1, pOutput); + code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { 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; int32_t code = TSDB_CODE_SUCCESS; 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)); } - code = abs_function(pInput, 1, pOutput); + code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++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)); } - code = abs_function(pInput, 1, pOutput); + code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++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); for (int32_t i = 0; i < rowNum; ++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)); } - code = abs_function(pInput, 1, pOutput); + code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++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); for (int32_t i = 0; i < rowNum; ++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)); } - code = abs_function(pInput, 1, pOutput); + code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++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)); } - code = abs_function(pInput, 1, pOutput); + code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++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)); } - code = abs_function(pInput, 1, pOutput); + code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++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)); } - code = abs_function(pInput, 1, pOutput); + code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++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)); } - code = abs_function(pInput, 1, pOutput); + code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), -(val_double + i)); @@ -1850,7 +1849,7 @@ TEST(ScalarFunctionTest, abs_function_column) { scltDestroyDataBlock(pOutput); } -TEST(ScalarFunctionTest, sin_function_constant) { +TEST(ScalarFunctionTest, sinFunction_constant) { SScalarParam *pInput, *pOutput; int32_t code = TSDB_CODE_SUCCESS; int32_t rowNum = 3; @@ -1865,7 +1864,7 @@ TEST(ScalarFunctionTest, sin_function_constant) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); 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); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); @@ -1881,7 +1880,7 @@ TEST(ScalarFunctionTest, sin_function_constant) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); 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); for (int32_t i = 0; i < rowNum; ++i) { 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; int32_t code = TSDB_CODE_SUCCESS; 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)); } - code = sin_function(pInput, 1, pOutput); + code = sinFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++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)); } - code = sin_function(pInput, 1, pOutput); + code = sinFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); @@ -1942,7 +1941,7 @@ TEST(ScalarFunctionTest, sin_function_column) { scltDestroyDataBlock(pOutput); } -TEST(ScalarFunctionTest, cos_function_constant) { +TEST(ScalarFunctionTest, cosFunction_constant) { SScalarParam *pInput, *pOutput; int32_t code = TSDB_CODE_SUCCESS; int32_t rowNum = 3; @@ -1957,7 +1956,7 @@ TEST(ScalarFunctionTest, cos_function_constant) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); 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); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); @@ -1973,7 +1972,7 @@ TEST(ScalarFunctionTest, cos_function_constant) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); 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); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); @@ -1984,7 +1983,7 @@ TEST(ScalarFunctionTest, cos_function_constant) { scltDestroyDataBlock(pOutput); } -TEST(ScalarFunctionTest, cos_function_column) { +TEST(ScalarFunctionTest, cosFunction_column) { SScalarParam *pInput, *pOutput; int32_t code = TSDB_CODE_SUCCESS; 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)); } - code = cos_function(pInput, 1, pOutput); + code = cosFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++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)); } - code = cos_function(pInput, 1, pOutput); + code = cosFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); @@ -2032,7 +2031,7 @@ TEST(ScalarFunctionTest, cos_function_column) { scltDestroyDataBlock(pOutput); } -TEST(ScalarFunctionTest, tan_function_constant) { +TEST(ScalarFunctionTest, tanFunction_constant) { SScalarParam *pInput, *pOutput; int32_t code = TSDB_CODE_SUCCESS; int32_t rowNum = 3; @@ -2047,7 +2046,7 @@ TEST(ScalarFunctionTest, tan_function_constant) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); 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); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); @@ -2063,7 +2062,7 @@ TEST(ScalarFunctionTest, tan_function_constant) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); 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); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); @@ -2074,7 +2073,7 @@ TEST(ScalarFunctionTest, tan_function_constant) { scltDestroyDataBlock(pOutput); } -TEST(ScalarFunctionTest, tan_function_column) { +TEST(ScalarFunctionTest, tanFunction_column) { SScalarParam *pInput, *pOutput; int32_t code = TSDB_CODE_SUCCESS; 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)); } - code = tan_function(pInput, 1, pOutput); + code = tanFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++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)); } - code = tan_function(pInput, 1, pOutput); + code = tanFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); @@ -2122,7 +2121,7 @@ TEST(ScalarFunctionTest, tan_function_column) { scltDestroyDataBlock(pOutput); } -TEST(ScalarFunctionTest, asin_function_constant) { +TEST(ScalarFunctionTest, asinFunction_constant) { SScalarParam *pInput, *pOutput; int32_t code = TSDB_CODE_SUCCESS; int32_t rowNum = 3; @@ -2137,7 +2136,7 @@ TEST(ScalarFunctionTest, asin_function_constant) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); 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); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); @@ -2153,7 +2152,7 @@ TEST(ScalarFunctionTest, asin_function_constant) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); 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); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); @@ -2164,7 +2163,7 @@ TEST(ScalarFunctionTest, asin_function_constant) { scltDestroyDataBlock(pOutput); } -TEST(ScalarFunctionTest, asin_function_column) { +TEST(ScalarFunctionTest, asinFunction_column) { SScalarParam *pInput, *pOutput; int32_t code = TSDB_CODE_SUCCESS; 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)); } - code = asin_function(pInput, 1, pOutput); + code = asinFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++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)); } - code = asin_function(pInput, 1, pOutput); + code = asinFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); @@ -2213,7 +2212,7 @@ TEST(ScalarFunctionTest, asin_function_column) { scltDestroyDataBlock(pOutput); } -TEST(ScalarFunctionTest, acos_function_constant) { +TEST(ScalarFunctionTest, acosFunction_constant) { SScalarParam *pInput, *pOutput; int32_t code = TSDB_CODE_SUCCESS; int32_t rowNum = 3; @@ -2228,7 +2227,7 @@ TEST(ScalarFunctionTest, acos_function_constant) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); 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); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); @@ -2244,7 +2243,7 @@ TEST(ScalarFunctionTest, acos_function_constant) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); 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); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); @@ -2255,7 +2254,7 @@ TEST(ScalarFunctionTest, acos_function_constant) { scltDestroyDataBlock(pOutput); } -TEST(ScalarFunctionTest, acos_function_column) { +TEST(ScalarFunctionTest, acosFunction_column) { SScalarParam *pInput, *pOutput; int32_t code = TSDB_CODE_SUCCESS; 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)); } - code = acos_function(pInput, 1, pOutput); + code = acosFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++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)); } - code = acos_function(pInput, 1, pOutput); + code = acosFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); @@ -2303,7 +2302,7 @@ TEST(ScalarFunctionTest, acos_function_column) { scltDestroyDataBlock(pOutput); } -TEST(ScalarFunctionTest, atan_function_constant) { +TEST(ScalarFunctionTest, atanFunction_constant) { SScalarParam *pInput, *pOutput; int32_t code = TSDB_CODE_SUCCESS; int32_t rowNum = 3; @@ -2318,7 +2317,7 @@ TEST(ScalarFunctionTest, atan_function_constant) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); 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); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); @@ -2334,7 +2333,7 @@ TEST(ScalarFunctionTest, atan_function_constant) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); 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); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); @@ -2345,7 +2344,7 @@ TEST(ScalarFunctionTest, atan_function_constant) { scltDestroyDataBlock(pOutput); } -TEST(ScalarFunctionTest, atan_function_column) { +TEST(ScalarFunctionTest, atanFunction_column) { SScalarParam *pInput, *pOutput; int32_t code = TSDB_CODE_SUCCESS; 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)); } - code = atan_function(pInput, 1, pOutput); + code = atanFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++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)); } - code = atan_function(pInput, 1, pOutput); + code = atanFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); @@ -2393,7 +2392,7 @@ TEST(ScalarFunctionTest, atan_function_column) { scltDestroyDataBlock(pOutput); } -TEST(ScalarFunctionTest, ceil_function_constant) { +TEST(ScalarFunctionTest, ceilFunction_constant) { SScalarParam *pInput, *pOutput; int32_t code = TSDB_CODE_SUCCESS; int32_t rowNum = 3; @@ -2407,7 +2406,7 @@ TEST(ScalarFunctionTest, ceil_function_constant) { scltMakeDataBlock(&pOutput, type, 0, rowNum, false); 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); for (int32_t i = 0; i < rowNum; ++i) { 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); 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); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((float *)pOutput->data + i), (float)result); @@ -2434,7 +2433,7 @@ TEST(ScalarFunctionTest, ceil_function_constant) { scltDestroyDataBlock(pOutput); } -TEST(ScalarFunctionTest, ceil_function_column) { +TEST(ScalarFunctionTest, ceilFunction_column) { SScalarParam *pInput, *pOutput; int32_t code = TSDB_CODE_SUCCESS; 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)); } - code = ceil_function(pInput, 1, pOutput); + code = ceilFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++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)); } - code = ceil_function(pInput, 1, pOutput); + code = ceilFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((float *)pOutput->data + i), result[i]); @@ -2481,7 +2480,7 @@ TEST(ScalarFunctionTest, ceil_function_column) { scltDestroyDataBlock(pOutput); } -TEST(ScalarFunctionTest, floor_function_constant) { +TEST(ScalarFunctionTest, floorFunction_constant) { SScalarParam *pInput, *pOutput; int32_t code = TSDB_CODE_SUCCESS; int32_t rowNum = 3; @@ -2495,7 +2494,7 @@ TEST(ScalarFunctionTest, floor_function_constant) { scltMakeDataBlock(&pOutput, type, 0, rowNum, false); 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); for (int32_t i = 0; i < rowNum; ++i) { 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); 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); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((float *)pOutput->data + i), (float)result); @@ -2522,7 +2521,7 @@ TEST(ScalarFunctionTest, floor_function_constant) { scltDestroyDataBlock(pOutput); } -TEST(ScalarFunctionTest, floor_function_column) { +TEST(ScalarFunctionTest, floorFunction_column) { SScalarParam *pInput, *pOutput; int32_t code = TSDB_CODE_SUCCESS; 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)); } - code = floor_function(pInput, 1, pOutput); + code = floorFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++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)); } - code = floor_function(pInput, 1, pOutput); + code = floorFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((float *)pOutput->data + i), result[i]); @@ -2569,7 +2568,7 @@ TEST(ScalarFunctionTest, floor_function_column) { scltDestroyDataBlock(pOutput); } -TEST(ScalarFunctionTest, round_function_constant) { +TEST(ScalarFunctionTest, roundFunction_constant) { SScalarParam *pInput, *pOutput; int32_t code = TSDB_CODE_SUCCESS; int32_t rowNum = 3; @@ -2583,7 +2582,7 @@ TEST(ScalarFunctionTest, round_function_constant) { scltMakeDataBlock(&pOutput, type, 0, rowNum, false); 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); for (int32_t i = 0; i < rowNum; ++i) { 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); 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); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((float *)pOutput->data + i), (float)result); @@ -2610,7 +2609,7 @@ TEST(ScalarFunctionTest, round_function_constant) { scltDestroyDataBlock(pOutput); } -TEST(ScalarFunctionTest, round_function_column) { +TEST(ScalarFunctionTest, roundFunction_column) { SScalarParam *pInput, *pOutput; int32_t code = TSDB_CODE_SUCCESS; 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)); } - code = round_function(pInput, 1, pOutput); + code = roundFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++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)); } - code = round_function(pInput, 1, pOutput); + code = roundFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((float *)pOutput->data + i), result[i]); @@ -2657,7 +2656,7 @@ TEST(ScalarFunctionTest, round_function_column) { scltDestroyDataBlock(pOutput); } -TEST(ScalarFunctionTest, sqrt_function_constant) { +TEST(ScalarFunctionTest, sqrtFunction_constant) { SScalarParam *pInput, *pOutput; int32_t code = TSDB_CODE_SUCCESS; int32_t rowNum = 3; @@ -2672,7 +2671,7 @@ TEST(ScalarFunctionTest, sqrt_function_constant) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); 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); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); @@ -2688,7 +2687,7 @@ TEST(ScalarFunctionTest, sqrt_function_constant) { scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); 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); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); @@ -2699,7 +2698,7 @@ TEST(ScalarFunctionTest, sqrt_function_constant) { scltDestroyDataBlock(pOutput); } -TEST(ScalarFunctionTest, sqrt_function_column) { +TEST(ScalarFunctionTest, sqrtFunction_column) { SScalarParam *pInput, *pOutput; int32_t code = TSDB_CODE_SUCCESS; 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)); } - code = sqrt_function(pInput, 1, pOutput); + code = sqrtFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++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)); } - code = sqrt_function(pInput, 1, pOutput); + code = sqrtFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); @@ -2747,7 +2746,7 @@ TEST(ScalarFunctionTest, sqrt_function_column) { scltDestroyDataBlock(pOutput); } -TEST(ScalarFunctionTest, log_function_constant) { +TEST(ScalarFunctionTest, logFunction_constant) { SScalarParam *pInput, *pOutput; SScalarParam *input[2]; 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), *((int8_t *)pInput[1].data)); - code = log_function(pInput, 2, pOutput); + code = logFunction(pInput, 2, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { 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), *((float *)pInput[1].data)); - code = log_function(pInput, 2, pOutput); + code = logFunction(pInput, 2, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { 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)); - code = log_function(pInput, 2, pOutput); + code = logFunction(pInput, 2, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); @@ -2823,7 +2822,7 @@ TEST(ScalarFunctionTest, log_function_constant) { free(pInput); } -TEST(ScalarFunctionTest, log_function_column) { +TEST(ScalarFunctionTest, logFunction_column) { SScalarParam *pInput, *pOutput; SScalarParam *input[2]; int32_t code = TSDB_CODE_SUCCESS; @@ -2848,7 +2847,7 @@ TEST(ScalarFunctionTest, log_function_column) { } scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); - code = log_function(pInput, 2, pOutput); + code = logFunction(pInput, 2, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); @@ -2873,7 +2872,7 @@ TEST(ScalarFunctionTest, log_function_column) { } scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); - code = log_function(pInput, 2, pOutput); + code = logFunction(pInput, 2, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++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)); scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); - code = log_function(pInput, 2, pOutput); + code = logFunction(pInput, 2, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); @@ -2914,7 +2913,7 @@ TEST(ScalarFunctionTest, log_function_column) { free(pInput); } -TEST(ScalarFunctionTest, pow_function_constant) { +TEST(ScalarFunctionTest, powFunction_constant) { SScalarParam *pInput, *pOutput; SScalarParam *input[2]; 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), *((int8_t *)pInput[1].data)); - code = pow_function(pInput, 2, pOutput); + code = powFunction(pInput, 2, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { 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), *((float *)pInput[1].data)); - code = pow_function(pInput, 2, pOutput); + code = powFunction(pInput, 2, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { 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)); - code = pow_function(pInput, 2, pOutput); + code = powFunction(pInput, 2, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result); @@ -2990,7 +2989,7 @@ TEST(ScalarFunctionTest, pow_function_constant) { free(pInput); } -TEST(ScalarFunctionTest, pow_function_column) { +TEST(ScalarFunctionTest, powFunction_column) { SScalarParam *pInput, *pOutput; SScalarParam *input[2]; int32_t code = TSDB_CODE_SUCCESS; @@ -3015,7 +3014,7 @@ TEST(ScalarFunctionTest, pow_function_column) { } scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); - code = pow_function(pInput, 2, pOutput); + code = powFunction(pInput, 2, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); @@ -3041,7 +3040,7 @@ TEST(ScalarFunctionTest, pow_function_column) { } scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); - code = pow_function(pInput, 2, pOutput); + code = powFunction(pInput, 2, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++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)); scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); - code = pow_function(pInput, 2, pOutput); + code = powFunction(pInput, 2, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { ASSERT_EQ(*((double *)pOutput->data + i), result[i]); From 8a2623e962fe29665841ac8c059892368794a9b2 Mon Sep 17 00:00:00 2001 From: Ganlin Zhao Date: Sat, 26 Mar 2022 10:43:57 +0800 Subject: [PATCH 5/5] [TD-14240]: add math functions --- source/libs/scalar/src/sclfunc.c | 8 +++---- .../libs/scalar/test/scalar/scalarTests.cpp | 24 +++++++++---------- 2 files changed, 16 insertions(+), 16 deletions(-) diff --git a/source/libs/scalar/src/sclfunc.c b/source/libs/scalar/src/sclfunc.c index 10829c20e3..f2fdb29e4a 100644 --- a/source/libs/scalar/src/sclfunc.c +++ b/source/libs/scalar/src/sclfunc.c @@ -103,7 +103,7 @@ int32_t logFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutpu char **input = NULL, *output = NULL; bool hasNullInput = false; - input = calloc(inputNum, sizeof(char *)); + 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) { @@ -131,7 +131,7 @@ int32_t logFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutpu SET_TYPED_DATA(output, pOutput->type, result); } - free(input); + taosMemoryFree(input); return TSDB_CODE_SUCCESS; } @@ -146,7 +146,7 @@ int32_t powFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutpu char **input = NULL, *output = NULL; bool hasNullInput = false; - input = calloc(inputNum, sizeof(char *)); + 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) { @@ -174,7 +174,7 @@ int32_t powFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutpu SET_TYPED_DATA(output, pOutput->type, result); } - free(input); + taosMemoryFree(input); return TSDB_CODE_SUCCESS; } diff --git a/source/libs/scalar/test/scalar/scalarTests.cpp b/source/libs/scalar/test/scalar/scalarTests.cpp index abff763ce9..f0025de6b8 100644 --- a/source/libs/scalar/test/scalar/scalarTests.cpp +++ b/source/libs/scalar/test/scalar/scalarTests.cpp @@ -1442,7 +1442,7 @@ TEST(columnTest, greater_and_lower) { } void scltMakeDataBlock(SScalarParam **pInput, int32_t type, void *pVal, int32_t num, bool setVal) { - SScalarParam *input = (SScalarParam *)calloc(1, sizeof(SScalarParam)); + SScalarParam *input = (SScalarParam *)taosMemoryCalloc(1, sizeof(SScalarParam)); int32_t bytes; switch (type) { case TSDB_DATA_TYPE_TINYINT: { @@ -1473,7 +1473,7 @@ void scltMakeDataBlock(SScalarParam **pInput, int32_t type, void *pVal, int32_t input->type = type; input->num = num; - input->data = calloc(num, bytes); + input->data = taosMemoryCalloc(num, bytes); input->bytes = bytes; if (setVal) { for (int32_t i = 0; i < num; ++i) { @@ -1487,8 +1487,8 @@ void scltMakeDataBlock(SScalarParam **pInput, int32_t type, void *pVal, int32_t } void scltDestroyDataBlock(SScalarParam *pInput) { - free(pInput->data); - free(pInput); + taosMemoryFree(pInput->data); + taosMemoryFree(pInput); } TEST(ScalarFunctionTest, absFunction_constant) { @@ -2754,7 +2754,7 @@ TEST(ScalarFunctionTest, logFunction_constant) { int32_t type; int32_t otype = TSDB_DATA_TYPE_DOUBLE; double result = 3.0; - pInput = (SScalarParam *)calloc(2, sizeof(SScalarParam)); + pInput = (SScalarParam *)taosMemoryCalloc(2, sizeof(SScalarParam)); //TINYINT int8_t val_tinyint[] = {27, 3}; @@ -2819,7 +2819,7 @@ TEST(ScalarFunctionTest, logFunction_constant) { scltDestroyDataBlock(input[0]); scltDestroyDataBlock(input[1]); scltDestroyDataBlock(pOutput); - free(pInput); + taosMemoryFree(pInput); } TEST(ScalarFunctionTest, logFunction_column) { @@ -2830,7 +2830,7 @@ TEST(ScalarFunctionTest, logFunction_column) { int32_t type; int32_t otype = TSDB_DATA_TYPE_DOUBLE; double result[] = {2.0, 4.0, 3.0}; - pInput = (SScalarParam *)calloc(2, sizeof(SScalarParam)); + pInput = (SScalarParam *)taosMemoryCalloc(2, sizeof(SScalarParam)); //TINYINT int8_t val_tinyint[2][3] = {{25, 81, 64}, {5, 3, 4}}; @@ -2910,7 +2910,7 @@ TEST(ScalarFunctionTest, logFunction_column) { scltDestroyDataBlock(input[0]); scltDestroyDataBlock(input[1]); scltDestroyDataBlock(pOutput); - free(pInput); + taosMemoryFree(pInput); } TEST(ScalarFunctionTest, powFunction_constant) { @@ -2921,7 +2921,7 @@ TEST(ScalarFunctionTest, powFunction_constant) { int32_t type; int32_t otype = TSDB_DATA_TYPE_DOUBLE; double result = 16.0; - pInput = (SScalarParam *)calloc(2, sizeof(SScalarParam)); + pInput = (SScalarParam *)taosMemoryCalloc(2, sizeof(SScalarParam)); //TINYINT int8_t val_tinyint[] = {2, 4}; @@ -2986,7 +2986,7 @@ TEST(ScalarFunctionTest, powFunction_constant) { scltDestroyDataBlock(input[0]); scltDestroyDataBlock(input[1]); scltDestroyDataBlock(pOutput); - free(pInput); + taosMemoryFree(pInput); } TEST(ScalarFunctionTest, powFunction_column) { @@ -2997,7 +2997,7 @@ TEST(ScalarFunctionTest, powFunction_column) { int32_t type; int32_t otype = TSDB_DATA_TYPE_DOUBLE; double result[] = {32.0, 27.0, 16.0}; - pInput = (SScalarParam *)calloc(2, sizeof(SScalarParam)); + pInput = (SScalarParam *)taosMemoryCalloc(2, sizeof(SScalarParam)); //TINYINT int8_t val_tinyint[2][3] = {{2, 3, 4}, {5, 3, 2}}; @@ -3078,7 +3078,7 @@ TEST(ScalarFunctionTest, powFunction_column) { scltDestroyDataBlock(input[0]); scltDestroyDataBlock(input[1]); scltDestroyDataBlock(pOutput); - free(pInput); + taosMemoryFree(pInput); } int main(int argc, char** argv) {