Skip to content

T
TDengine

taosdata / TDengine
大约 2 年 前同步成功

通知 1192
Star 22018
Fork 4786
T
TDengine
提交 a0ba1eb1 编写于 作者: G Ganlin Zhao
浏览文件
操作

Merge branch 'feature/3.0_liaohj' of github.com:taosdata/TDengine into feature/3.0_liaohj

上级 b6015420 bee71f5f
显示空白变更内容
内联 并排
Showing with 390 addition and 324 deletion
include/libs/scalar/scalar.h
浏览文件 @ a0ba1eb1
......@@ -40,7 +40,7 @@ int32_t scalarGetOperatorParamNum(EOperatorType type);
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 vectorConvertImpl(const SScalarParam* pIn, SScalarParam* pOut);
int32_t absFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
int32_t logFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
......
source/client/src/clientImpl.c
浏览文件 @ a0ba1eb1
......@@ -558,15 +558,6 @@ static void doSetOneRowPtr(SReqResultInfo* pResultInfo) {
pResultInfo->length[i] = varDataLen(pStart);
pResultInfo->row[i] = varDataVal(pStart);
if (type == TSDB_DATA_TYPE_NCHAR) {
int32_t len = taosUcs4ToMbs((TdUcs4*)varDataVal(pStart), varDataLen(pStart), varDataVal(pResultInfo->convertBuf[i]));
ASSERT(len <= bytes);
pResultInfo->row[i] = varDataVal(pResultInfo->convertBuf[i]);
varDataSetLen(pResultInfo->convertBuf[i], len);
pResultInfo->length[i] = len;
}
} else {
pResultInfo->row[i] = NULL;
}
......@@ -689,12 +680,6 @@ static int32_t doPrepareResPtr(SReqResultInfo* pResInfo) {
if (pResInfo->row == NULL || pResInfo->pCol == NULL || pResInfo->length == NULL || pResInfo->convertBuf == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
}
for(int32_t i = 0; i < pResInfo->numOfCols; ++i) {
if(pResInfo->fields[i].type == TSDB_DATA_TYPE_NCHAR) {
pResInfo->convertBuf[i] = taosMemoryCalloc(1, NCHAR_WIDTH_TO_BYTES(pResInfo->fields[i].bytes));
}
}
}
return TSDB_CODE_SUCCESS;
......@@ -731,6 +716,35 @@ int32_t setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32
pStart += colLength[i];
}
for (int32_t i = 0; i < numOfCols; ++i) {
int32_t type = pResultInfo->fields[i].type;
int32_t bytes = pResultInfo->fields[i].bytes;
if (type == TSDB_DATA_TYPE_NCHAR) {
char* p = taosMemoryRealloc(pResultInfo->convertBuf[i], colLength[i]);
if (p == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
}
pResultInfo->convertBuf[i] = p;
SResultColumn* pCol = &pResultInfo->pCol[i];
for (int32_t j = 0; j < numOfRows; ++j) {
if (pCol->offset[j] != -1) {
pStart = pCol->offset[j] + pCol->pData;
int32_t len = taosUcs4ToMbs((TdUcs4*)varDataVal(pStart), varDataLen(pStart), varDataVal(p));
ASSERT(len <= bytes);
varDataSetLen(p, len);
pCol->offset[j] = (p - pResultInfo->convertBuf[i]);
p += (len + VARSTR_HEADER_SIZE);
}
}
pResultInfo->pCol[i].pData = pResultInfo->convertBuf[i];
}
}
return TSDB_CODE_SUCCESS;
}
......
source/libs/scalar/src/scalar.c
浏览文件 @ a0ba1eb1
......@@ -64,7 +64,7 @@ int32_t scalarGenerateSetFromList(void **data, void *pNode, uint32_t type) {
int32_t code = 0;
SNodeListNode *nodeList = (SNodeListNode *)pNode;
SListCell *cell = nodeList->pNodeList->pHead;
SScalarParam out = {.columnData = taosMemoryMalloc(sizeof(SColumnInfoData))};
SScalarParam out = {.columnData = taosMemoryCalloc(1, sizeof(SColumnInfoData))};
int32_t len = 0;
void *buf = NULL;
......
source/libs/scalar/src/sclvector.c
浏览文件 @ a0ba1eb1
......@@ -177,7 +177,7 @@ static FORCE_INLINE void varToBool(char *buf, SScalarParam* pOut, int32_t rowInd
colDataAppend(pOut->columnData, rowIndex, (char*) &v, false);
}
int32_t vectorConvertFromVarData(SScalarParam* pIn, SScalarParam* pOut, int32_t inType, int32_t outType) {
int32_t vectorConvertFromVarData(const SScalarParam* pIn, SScalarParam* pOut, int32_t inType, int32_t outType) {
int32_t bufSize = pIn->columnData->info.bytes;
char *tmp = taosMemoryMalloc(bufSize);
......@@ -227,7 +227,7 @@ int32_t vectorConvertFromVarData(SScalarParam* pIn, SScalarParam* pOut, int32_t
}
// TODO opt performance
int32_t vectorConvertImpl(SScalarParam* pIn, SScalarParam* pOut) {
int32_t vectorConvertImpl(const SScalarParam* pIn, SScalarParam* pOut) {
SColumnInfoData* pInputCol = pIn->columnData;
SColumnInfoData* pOutputCol = pOut->columnData;
......@@ -406,27 +406,32 @@ int32_t vectorConvert(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam* p
return TSDB_CODE_SUCCESS;
}
static int32_t doConvertHelper(SScalarParam* pParam, int32_t type) {
SScalarParam param = {0};
enum {
VECTOR_DO_CONVERT = 0x1,
VECTOR_UN_CONVERT = 0x2,
};
static int32_t doConvertHelper(SScalarParam* pDest, int32_t* convert, const SScalarParam* pParam, int32_t type) {
SColumnInfoData* pCol = pParam->columnData;
if (IS_VAR_DATA_TYPE(pCol->info.type)) {
param.numOfRows = pParam->numOfRows;
pDest->numOfRows = pParam->numOfRows;
SDataType t = {.type = type, .bytes = tDataTypes[type].bytes};
param.columnData = createColumnInfoData(&t, pParam->numOfRows);
if (param.columnData == NULL) {
pDest->columnData = createColumnInfoData(&t, pParam->numOfRows);
if (pDest->columnData == NULL) {
sclError("malloc %d failed", (int32_t)(pParam->numOfRows * sizeof(double)));
return TSDB_CODE_OUT_OF_MEMORY;
}
int32_t code = vectorConvertImpl(pParam, &param);
int32_t code = vectorConvertImpl(pParam, pDest);
if (code != TSDB_CODE_SUCCESS) {
return code;
}
colDataDestroy(pParam->columnData);
pParam->columnData = param.columnData;
*convert = VECTOR_DO_CONVERT;
} else {
*convert = VECTOR_UN_CONVERT;
}
return TSDB_CODE_SUCCESS;
......@@ -452,6 +457,29 @@ static void vectorMathAddHelper(SColumnInfoData* pLeftCol, SColumnInfoData* pRig
}
}
static SColumnInfoData* doVectorConvert(SScalarParam* pInput, int32_t* doConvert) {
SScalarParam convertParam = {0};
int32_t code = doConvertHelper(&convertParam, doConvert, pInput, TSDB_DATA_TYPE_DOUBLE);
if (code != TSDB_CODE_SUCCESS) {
terrno = code;
return NULL;
}
if (*doConvert == VECTOR_DO_CONVERT) {
return convertParam.columnData;
} else {
return pInput->columnData;
}
}
static void doReleaseVec(SColumnInfoData* pCol, int32_t type) {
if (type == VECTOR_DO_CONVERT) {
colDataDestroy(pCol);
taosMemoryFree(pCol);
}
}
void vectorMathAdd(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam *pOut, int32_t _ord) {
SColumnInfoData *pOutputCol = pOut->columnData;
......@@ -460,11 +488,9 @@ void vectorMathAdd(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam *pOut
pOut->numOfRows = TMAX(pLeft->numOfRows, pRight->numOfRows);
doConvertHelper(pLeft, TSDB_DATA_TYPE_DOUBLE);
doConvertHelper(pRight, TSDB_DATA_TYPE_DOUBLE);
SColumnInfoData *pLeftCol = pLeft->columnData;
SColumnInfoData *pRightCol = pRight->columnData;
int32_t leftConvert = 0, rightConvert = 0;
SColumnInfoData *pLeftCol = doVectorConvert(pLeft, &leftConvert);
SColumnInfoData *pRightCol = doVectorConvert(pRight, &rightConvert);
_getDoubleValue_fn_t getVectorDoubleValueFnLeft = getVectorDoubleValueFn(pLeftCol->info.type);
_getDoubleValue_fn_t getVectorDoubleValueFnRight = getVectorDoubleValueFn(pRightCol->info.type);
......@@ -488,6 +514,9 @@ void vectorMathAdd(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam *pOut
} else if (pRight->numOfRows == 1) {
vectorMathAddHelper(pLeftCol, pRightCol, pOutputCol, pLeft->numOfRows, step, i);
}
doReleaseVec(pLeftCol, leftConvert);
doReleaseVec(pRightCol, rightConvert);
}
// TODO not correct for descending order scan
......@@ -518,11 +547,9 @@ void vectorMathSub(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam *pOut
int32_t i = ((_ord) == TSDB_ORDER_ASC)? 0 : TMAX(pLeft->numOfRows, pRight->numOfRows) - 1;
int32_t step = ((_ord) == TSDB_ORDER_ASC)? 1 : -1;
doConvertHelper(pLeft, TSDB_DATA_TYPE_DOUBLE);
doConvertHelper(pRight, TSDB_DATA_TYPE_DOUBLE);
SColumnInfoData *pLeftCol = pLeft->columnData;
SColumnInfoData *pRightCol = pRight->columnData;
int32_t leftConvert = 0, rightConvert = 0;
SColumnInfoData *pLeftCol = doVectorConvert(pLeft, &leftConvert);
SColumnInfoData *pRightCol = doVectorConvert(pRight, &rightConvert);
_getDoubleValue_fn_t getVectorDoubleValueFnLeft = getVectorDoubleValueFn(pLeftCol->info.type);
_getDoubleValue_fn_t getVectorDoubleValueFnRight = getVectorDoubleValueFn(pRightCol->info.type);
......@@ -546,6 +573,9 @@ void vectorMathSub(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam *pOut
} else if (pRight->numOfRows == 1) {
vectorMathSubHelper(pLeftCol, pRightCol, pOutputCol, pLeft->numOfRows, step, 1, i);
}
doReleaseVec(pLeftCol, leftConvert);
doReleaseVec(pRightCol, rightConvert);
}
// TODO not correct for descending order scan
......@@ -575,11 +605,9 @@ void vectorMathMultiply(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam
int32_t i = ((_ord) == TSDB_ORDER_ASC)? 0 : TMAX(pLeft->numOfRows, pRight->numOfRows) - 1;
int32_t step = ((_ord) == TSDB_ORDER_ASC)? 1 : -1;
doConvertHelper(pLeft, TSDB_DATA_TYPE_DOUBLE);
doConvertHelper(pRight, TSDB_DATA_TYPE_DOUBLE);
SColumnInfoData *pLeftCol = pLeft->columnData;
SColumnInfoData *pRightCol = pRight->columnData;
int32_t leftConvert = 0, rightConvert = 0;
SColumnInfoData *pLeftCol = doVectorConvert(pLeft, &leftConvert);
SColumnInfoData *pRightCol = doVectorConvert(pRight, &rightConvert);
_getDoubleValue_fn_t getVectorDoubleValueFnLeft = getVectorDoubleValueFn(pLeftCol->info.type);
_getDoubleValue_fn_t getVectorDoubleValueFnRight = getVectorDoubleValueFn(pRightCol->info.type);
......@@ -603,6 +631,9 @@ void vectorMathMultiply(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam
} else if (pRight->numOfRows == 1) {
vectorMathMultiplyHelper(pLeftCol, pRightCol, pOutputCol, pLeft->numOfRows, step, i);
}
doReleaseVec(pLeftCol, leftConvert);
doReleaseVec(pRightCol, rightConvert);
}
void vectorMathDivide(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam *pOut, int32_t _ord) {
......@@ -612,11 +643,9 @@ void vectorMathDivide(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam *p
int32_t i = ((_ord) == TSDB_ORDER_ASC)? 0 : TMAX(pLeft->numOfRows, pRight->numOfRows) - 1;
int32_t step = ((_ord) == TSDB_ORDER_ASC)? 1 : -1;
doConvertHelper(pLeft, TSDB_DATA_TYPE_DOUBLE);
doConvertHelper(pRight, TSDB_DATA_TYPE_DOUBLE);
SColumnInfoData *pLeftCol = pLeft->columnData;
SColumnInfoData *pRightCol = pRight->columnData;
int32_t leftConvert = 0, rightConvert = 0;
SColumnInfoData *pLeftCol = doVectorConvert(pLeft, &leftConvert);
SColumnInfoData *pRightCol = doVectorConvert(pRight, &rightConvert);
_getDoubleValue_fn_t getVectorDoubleValueFnLeft = getVectorDoubleValueFn(pLeftCol->info.type);
_getDoubleValue_fn_t getVectorDoubleValueFnRight = getVectorDoubleValueFn(pRightCol->info.type);
......@@ -660,6 +689,9 @@ void vectorMathDivide(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam *p
}
}
}
doReleaseVec(pLeftCol, leftConvert);
doReleaseVec(pRightCol, rightConvert);
}
void vectorMathRemainder(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam *pOut, int32_t _ord) {
......@@ -669,11 +701,9 @@ void vectorMathRemainder(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam
int32_t i = ((_ord) == TSDB_ORDER_ASC)? 0 : TMAX(pLeft->numOfRows, pRight->numOfRows) - 1;
int32_t step = ((_ord) == TSDB_ORDER_ASC)? 1 : -1;
doConvertHelper(pLeft, TSDB_DATA_TYPE_DOUBLE);
doConvertHelper(pRight, TSDB_DATA_TYPE_DOUBLE);
SColumnInfoData *pLeftCol = pLeft->columnData;
SColumnInfoData *pRightCol = pRight->columnData;
int32_t leftConvert = 0, rightConvert = 0;
SColumnInfoData *pLeftCol = doVectorConvert(pLeft, &leftConvert);
SColumnInfoData *pRightCol = doVectorConvert(pRight, &rightConvert);
_getDoubleValue_fn_t getVectorDoubleValueFnLeft = getVectorDoubleValueFn(pLeftCol->info.type);
_getDoubleValue_fn_t getVectorDoubleValueFnRight = getVectorDoubleValueFn(pRightCol->info.type);
......@@ -738,6 +768,9 @@ void vectorMathRemainder(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam
}
}
}
doReleaseVec(pLeftCol, leftConvert);
doReleaseVec(pRightCol, rightConvert);
}
void vectorConcat(SScalarParam* pLeft, SScalarParam* pRight, void *out, int32_t _ord) {
......@@ -753,7 +786,7 @@ void vectorConcat(SScalarParam* pLeft, SScalarParam* pRight, void *out, int32_t
char* left = POINTER_SHIFT(pLeft->data, pLeft->bytes * i);
char* right = POINTER_SHIFT(pRight->data, pRight->bytes * i);
if (isNull(left, GET_PARAM_TYPE(pLeft)) || isNull(right, GET_PARAM_TYPE(pRight))) {
if (isNull(left, pLeftCol->info.type) || isNull(right, pRight->info.type)) {
setVardataNull(output, TSDB_DATA_TYPE_BINARY);
continue;
}
......@@ -766,7 +799,7 @@ void vectorConcat(SScalarParam* pLeft, SScalarParam* pRight, void *out, int32_t
} else if (pLeft->numOfRows == 1) {
for (; i >= 0 && i < pRight->numOfRows; i += step, output += len) {
char *right = POINTER_SHIFT(pRight->data, pRight->bytes * i);
if (isNull(pLeft->data, GET_PARAM_TYPE(pLeft)) || isNull(right, GET_PARAM_TYPE(pRight))) {
if (isNull(pLeft->data, pLeftCol->info.type) || isNull(right, pRight->info.type)) {
setVardataNull(output, TSDB_DATA_TYPE_BINARY);
continue;
}
......@@ -778,7 +811,7 @@ void vectorConcat(SScalarParam* pLeft, SScalarParam* pRight, void *out, int32_t
} else if (pRight->numOfRows == 1) {
for (; i >= 0 && i < pLeft->numOfRows; i += step, output += len) {
char* left = POINTER_SHIFT(pLeft->data, pLeft->bytes * i);
if (isNull(left, GET_PARAM_TYPE(pLeft)) || isNull(pRight->data, GET_PARAM_TYPE(pRight))) {
if (isNull(left, pLeftCol->info.type) || isNull(pRight->data, pRight->info.type)) {
SET_DOUBLE_NULL(output);
continue;
}
......@@ -817,14 +850,12 @@ void vectorBitAnd(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam *pOut,
int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : TMAX(pLeft->numOfRows, pRight->numOfRows) - 1;
int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1;
doConvertHelper(pLeft, TSDB_DATA_TYPE_BIGINT);
doConvertHelper(pRight, TSDB_DATA_TYPE_BIGINT);
int32_t leftConvert = 0, rightConvert = 0;
SColumnInfoData *pLeftCol = doVectorConvert(pLeft, &leftConvert);
SColumnInfoData *pRightCol = doVectorConvert(pRight, &rightConvert);
SColumnInfoData *pLeftCol = pLeft->columnData;
SColumnInfoData *pRightCol = pRight->columnData;
_getBigintValue_fn_t getVectorBigintValueFnLeft = getVectorBigintValueFn(GET_PARAM_TYPE(pLeft));
_getBigintValue_fn_t getVectorBigintValueFnRight = getVectorBigintValueFn(GET_PARAM_TYPE(pRight));
_getBigintValue_fn_t getVectorBigintValueFnLeft = getVectorBigintValueFn(pLeftCol->info.type);
_getBigintValue_fn_t getVectorBigintValueFnRight = getVectorBigintValueFn(pRightCol->info.type);
int64_t *output = (int64_t *)pOutputCol->pData;
if (pLeft->numOfRows == pRight->numOfRows) {
......@@ -845,6 +876,9 @@ void vectorBitAnd(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam *pOut,
} else if (pRight->numOfRows == 1) {
vectorBitAndHelper(pLeftCol, pRightCol, pOutputCol, pLeft->numOfRows, step, i);
}
doReleaseVec(pLeftCol, leftConvert);
doReleaseVec(pRightCol, rightConvert);
}
static void vectorBitOrHelper(SColumnInfoData* pLeftCol, SColumnInfoData* pRightCol, SColumnInfoData* pOutputCol, int32_t numOfRows, int32_t step, int32_t i) {
......@@ -874,14 +908,12 @@ void vectorBitOr(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam *pOut,
int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : TMAX(pLeft->numOfRows, pRight->numOfRows) - 1;
int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1;
doConvertHelper(pLeft, TSDB_DATA_TYPE_BIGINT);
doConvertHelper(pRight, TSDB_DATA_TYPE_BIGINT);
int32_t leftConvert = 0, rightConvert = 0;
SColumnInfoData *pLeftCol = doVectorConvert(pLeft, &leftConvert);
SColumnInfoData *pRightCol = doVectorConvert(pRight, &rightConvert);
SColumnInfoData *pLeftCol = pLeft->columnData;
SColumnInfoData *pRightCol = pRight->columnData;
_getBigintValue_fn_t getVectorBigintValueFnLeft = getVectorBigintValueFn(GET_PARAM_TYPE(pLeft));
_getBigintValue_fn_t getVectorBigintValueFnRight = getVectorBigintValueFn(GET_PARAM_TYPE(pRight));
_getBigintValue_fn_t getVectorBigintValueFnLeft = getVectorBigintValueFn(pLeftCol->info.type);
_getBigintValue_fn_t getVectorBigintValueFnRight = getVectorBigintValueFn(pRightCol->info.type);
int64_t *output = (int64_t *)pOutputCol->pData;
if (pLeft->numOfRows == pRight->numOfRows) {
......@@ -901,6 +933,9 @@ void vectorBitOr(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam *pOut,
} else if (pRight->numOfRows == 1) {
vectorBitOrHelper(pLeftCol, pRightCol, pOutputCol, pLeft->numOfRows, step, i);
}
doReleaseVec(pLeftCol, leftConvert);
doReleaseVec(pRightCol, rightConvert);
}
void vectorCompareImpl(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam *pOut, int32_t _ord, int32_t optr) {
......
source/libs/scalar/test/scalar/scalarTests.cpp
浏览文件 @ a0ba1eb1
......@@ -1463,23 +1463,26 @@ void scltMakeDataBlock(SScalarParam **pInput, int32_t type, void *pVal, int32_t
}
}
input->type = type;
input->num = num;
input->data = taosMemoryCalloc(num, bytes);
input->bytes = bytes;
input->columnData = (SColumnInfoData*) taosMemoryCalloc(1, sizeof(SColumnInfoData));
input->numOfRows = num;
input->columnData->info = createColumnInfo(0, type, bytes);
blockDataEnsureColumnCapacity(input->columnData, num);
if (setVal) {
for (int32_t i = 0; i < num; ++i) {
memcpy(input->data + i * bytes, pVal, bytes);
colDataAppend(input->columnData, i, (const char*) pVal, false);
}
} else {
memset(input->data, 0, num * bytes);
// memset(input->data, 0, num * bytes);
}
*pInput = input;
}
void scltDestroyDataBlock(SScalarParam *pInput) {
taosMemoryFree(pInput->data);
colDataDestroy(pInput->columnData);
taosMemoryFree(pInput->columnData);
taosMemoryFree(pInput);
}
......@@ -1492,25 +1495,25 @@ TEST(ScalarFunctionTest, absFunction_constant) {
//TINYINT
int8_t val_tinyint = 10;
type = TSDB_DATA_TYPE_TINYINT;
scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true);
scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
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);
ASSERT_EQ(*((int8_t *)colDataGetData(pOutput->columnData, i)), val_tinyint);
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
val_tinyint = -10;
scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true);
scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
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);
ASSERT_EQ(*((int8_t *)colDataGetData(pOutput->columnData, i)), -val_tinyint);
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -1518,25 +1521,25 @@ TEST(ScalarFunctionTest, absFunction_constant) {
//SMALLINT
int16_t val_smallint = 10;
type = TSDB_DATA_TYPE_SMALLINT;
scltMakeDataBlock(&pInput, type, &val_smallint, 1, true);
scltMakeDataBlock(&pInput, type, &val_smallint, rowNum, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
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);
ASSERT_EQ(*((int16_t *)colDataGetData(pOutput->columnData, i)), val_smallint);
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
val_smallint = -10;
scltMakeDataBlock(&pInput, type, &val_smallint, 1, true);
scltMakeDataBlock(&pInput, type, &val_smallint, rowNum, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
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);
ASSERT_EQ(*((int16_t *)colDataGetData(pOutput->columnData, i)), -val_smallint);
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -1544,25 +1547,25 @@ TEST(ScalarFunctionTest, absFunction_constant) {
//INT
int32_t val_int = 10;
type = TSDB_DATA_TYPE_INT;
scltMakeDataBlock(&pInput, type, &val_int, 1, true);
scltMakeDataBlock(&pInput, type, &val_int, rowNum, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
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);
ASSERT_EQ(*((int32_t *)colDataGetData(pOutput->columnData, i)), val_int);
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
val_int = -10;
scltMakeDataBlock(&pInput, type, &val_int, 1, true);
scltMakeDataBlock(&pInput, type, &val_int, rowNum, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
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);
ASSERT_EQ(*((int32_t *)colDataGetData(pOutput->columnData, i)), -val_int);
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -1570,13 +1573,13 @@ TEST(ScalarFunctionTest, absFunction_constant) {
//BIGINT
int64_t val_bigint = 10;
type = TSDB_DATA_TYPE_BIGINT;
scltMakeDataBlock(&pInput, type, &val_bigint, 1, true);
scltMakeDataBlock(&pInput, type, &val_bigint, rowNum, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
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);
ASSERT_EQ(*((int64_t *)colDataGetData(pOutput->columnData, i)), val_bigint);
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -1588,7 +1591,7 @@ TEST(ScalarFunctionTest, absFunction_constant) {
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);
ASSERT_EQ(*((int64_t *)colDataGetData(pOutput->columnData, i)), -val_bigint);
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -1596,29 +1599,29 @@ TEST(ScalarFunctionTest, absFunction_constant) {
//FLOAT
float val_float = 10.15;
type = TSDB_DATA_TYPE_FLOAT;
scltMakeDataBlock(&pInput, type, &val_float, 1, true);
scltMakeDataBlock(&pInput, type, &val_float, rowNum, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
PRINTF("float before ABS:%f\n", *(float *)pInput->data);
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);
PRINTF("float after ABS:%f\n", *((float *)pOutput->data + i));
ASSERT_EQ(*((float *)colDataGetData(pOutput->columnData, i)), val_float);
PRINTF("float after ABS:%f\n", *((float *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
val_float = -10.15;
scltMakeDataBlock(&pInput, type, &val_float, 1, true);
scltMakeDataBlock(&pInput, type, &val_float, rowNum, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
PRINTF("float before ABS:%f\n", *(float *)pInput->data);
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);
PRINTF("float after ABS:%f\n", *((float *)pOutput->data + i));
ASSERT_EQ(*((float *)colDataGetData(pOutput->columnData, i)), -val_float);
PRINTF("float after ABS:%f\n", *((float *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -1626,13 +1629,13 @@ TEST(ScalarFunctionTest, absFunction_constant) {
//DOUBLE
double val_double = 10.15;
type = TSDB_DATA_TYPE_DOUBLE;
scltMakeDataBlock(&pInput, type, &val_double, 1, true);
scltMakeDataBlock(&pInput, type, &val_double, rowNum, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
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);
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), val_double);
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -1644,7 +1647,7 @@ TEST(ScalarFunctionTest, absFunction_constant) {
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);
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), -val_double);
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -1663,15 +1666,16 @@ TEST(ScalarFunctionTest, absFunction_column) {
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));
int8_t v = val_tinyint + i;
colDataAppend(pInput->columnData, i, (const char*) &v, false);
PRINTF("tiny_int before ABS:%d\n", v);
}
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);
PRINTF("tiny_int after ABS:%d\n", *((int8_t *)pOutput->data + i));
ASSERT_EQ(*((int8_t *)colDataGetData(pOutput->columnData, i)), val_tinyint + i);
PRINTF("tiny_int after ABS:%d\n", *((int8_t *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -1680,15 +1684,16 @@ TEST(ScalarFunctionTest, absFunction_column) {
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));
int8_t v = val_tinyint + i;
colDataAppend(pInput->columnData, i, (const char*) &v, false);
PRINTF("tiny_int before ABS:%d\n", v);
}
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));
PRINTF("tiny_int after ABS:%d\n", *((int8_t *)pOutput->data + i));
ASSERT_EQ(*((int8_t *)colDataGetData(pOutput->columnData, i)), -(val_tinyint + i));
PRINTF("tiny_int after ABS:%d\n", *((int8_t *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -1699,16 +1704,16 @@ TEST(ScalarFunctionTest, absFunction_column) {
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));
int16_t v = val_smallint + i;
colDataAppend(pInput->columnData, i, (const char*) &v, false);
PRINTF("small_int before ABS:%d\n", v);
}
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);
PRINTF("small_int after ABS:%d\n", *((int16_t *)pOutput->data + i));
ASSERT_EQ(*((int16_t *)colDataGetData(pOutput->columnData, i)), val_smallint + i);
PRINTF("small_int after ABS:%d\n", *((int16_t *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -1717,15 +1722,16 @@ TEST(ScalarFunctionTest, absFunction_column) {
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));
int16_t v = val_smallint + i;
colDataAppend(pInput->columnData, i, (const char*) &v, false);
PRINTF("small_int before ABS:%d\n", v);
}
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));
PRINTF("small_int after ABS:%d\n", *((int16_t *)pOutput->data + i));
ASSERT_EQ(*((int16_t *)colDataGetData(pOutput->columnData, i)), -(val_smallint + i));
PRINTF("small_int after ABS:%d\n", *((int16_t *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -1736,16 +1742,17 @@ TEST(ScalarFunctionTest, absFunction_column) {
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));
int32_t v = val_int + i;
colDataAppend(pInput->columnData, i, (const char*) &v, false);
PRINTF("int before ABS:%d\n", v);
}
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);
PRINTF("int after ABS:%d\n", *((int32_t *)pOutput->data + i));
ASSERT_EQ(*((int32_t *)colDataGetData(pOutput->columnData, i)), val_int + i);
PRINTF("int after ABS:%d\n", *((int32_t *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -1754,15 +1761,16 @@ TEST(ScalarFunctionTest, absFunction_column) {
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));
int32_t v = val_int + i;
colDataAppend(pInput->columnData, i, (const char*) &v, false);
PRINTF("int before ABS:%d\n", v);
}
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));
PRINTF("int after ABS:%d\n", *((int32_t *)pOutput->data + i));
ASSERT_EQ(*((int32_t *)colDataGetData(pOutput->columnData, i)), -(val_int + i));
PRINTF("int after ABS:%d\n", *((int32_t *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -1773,15 +1781,16 @@ TEST(ScalarFunctionTest, absFunction_column) {
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));
float v = val_float + i;
colDataAppend(pInput->columnData, i, (const char*) &v, false);
PRINTF("float before ABS:%f\n", v);
}
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);
PRINTF("float after ABS:%f\n", *((float *)pOutput->data + i));
ASSERT_EQ(*((float *)colDataGetData(pOutput->columnData, i)), val_float + i);
PRINTF("float after ABS:%f\n", *((float *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -1790,15 +1799,16 @@ TEST(ScalarFunctionTest, absFunction_column) {
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));
float v = val_float + i;
colDataAppend(pInput->columnData, i, (const char*) &v, false);
PRINTF("float before ABS:%f\n", v);
}
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));
PRINTF("float after ABS:%f\n", *((float *)pOutput->data + i));
ASSERT_EQ(*((float *)colDataGetData(pOutput->columnData, i)), -(val_float + i));
PRINTF("float after ABS:%f\n", *((float *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -1809,15 +1819,16 @@ TEST(ScalarFunctionTest, absFunction_column) {
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));
double v = val_double + i;
colDataAppend(pInput->columnData, i, (const char*) &v, false);
PRINTF("double before ABS:%f\n", v);
}
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);
PRINTF("double after ABS:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), val_double + i);
PRINTF("double after ABS:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -1826,15 +1837,16 @@ TEST(ScalarFunctionTest, absFunction_column) {
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));
double v = val_double + i;
colDataAppend(pInput->columnData, i, (const char*) &v, false);
PRINTF("double before ABS:%f\n", v);
}
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));
PRINTF("double after ABS:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), -(val_double + i));
PRINTF("double after ABS:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
......@@ -1852,15 +1864,15 @@ TEST(ScalarFunctionTest, sinFunction_constant) {
//TINYINT
int8_t val_tinyint = 13;
type = TSDB_DATA_TYPE_TINYINT;
scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true);
scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true);
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("tiny_int before SIN:%d\n", *((int8_t *)pInput->data));
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);
PRINTF("tiny_int after SIN:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result);
PRINTF("tiny_int after SIN:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -1868,15 +1880,15 @@ TEST(ScalarFunctionTest, sinFunction_constant) {
//FLOAT
float val_float = 13.00;
type = TSDB_DATA_TYPE_FLOAT;
scltMakeDataBlock(&pInput, type, &val_float, 1, true);
scltMakeDataBlock(&pInput, type, &val_float, rowNum, true);
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("float before SIN:%f\n", *((float *)pInput->data));
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);
PRINTF("float after SIN:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result);
PRINTF("float after SIN:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
......@@ -1899,15 +1911,15 @@ TEST(ScalarFunctionTest, sinFunction_column) {
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));
colDataAppend(pInput->columnData, i, (const char*) &val_tinyint[i], false);
PRINTF("tiny_int before SIN:%d\n", *(int8_t *)colDataGetData(pInput->columnData, i));
}
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]);
PRINTF("tiny_int after SIN:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("tiny_int after SIN:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -1918,15 +1930,15 @@ TEST(ScalarFunctionTest, sinFunction_column) {
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));
colDataAppend(pInput->columnData, i, (const char*) &val_float[i], false);
PRINTF("float before SIN:%f\n", *((float *)colDataGetData(pInput->columnData, i)));
}
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]);
PRINTF("float after SIN:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("float after SIN:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
......@@ -1944,15 +1956,15 @@ TEST(ScalarFunctionTest, cosFunction_constant) {
//TINYINT
int8_t val_tinyint = 13;
type = TSDB_DATA_TYPE_TINYINT;
scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true);
scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true);
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("tiny_int before COS:%d\n", *((int8_t *)pInput->data));
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);
PRINTF("tiny_int after COS:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result);
PRINTF("tiny_int after COS:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -1960,15 +1972,15 @@ TEST(ScalarFunctionTest, cosFunction_constant) {
//FLOAT
float val_float = 13.00;
type = TSDB_DATA_TYPE_FLOAT;
scltMakeDataBlock(&pInput, type, &val_float, 1, true);
scltMakeDataBlock(&pInput, type, &val_float, rowNum, true);
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("float before COS:%f\n", *((float *)pInput->data));
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);
PRINTF("float after COS:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result);
PRINTF("float after COS:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
......@@ -1989,15 +2001,15 @@ TEST(ScalarFunctionTest, cosFunction_column) {
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));
colDataAppend(pInput->columnData, i, (const char*) &val_tinyint[i], false);
PRINTF("tiny_int before COS:%d\n", *(int8_t *)colDataGetData(pInput->columnData, i));
}
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]);
PRINTF("tiny_int after COS:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("tiny_int after COS:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -2008,15 +2020,15 @@ TEST(ScalarFunctionTest, cosFunction_column) {
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));
colDataAppend(pInput->columnData, i, (const char*) &val_float[i], false);
PRINTF("float before COS:%f\n", *(float *)colDataGetData(pInput->columnData, i));
}
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]);
PRINTF("float after COS:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("float after COS:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
......@@ -2034,15 +2046,15 @@ TEST(ScalarFunctionTest, tanFunction_constant) {
//TINYINT
int8_t val_tinyint = 13;
type = TSDB_DATA_TYPE_TINYINT;
scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true);
scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true);
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("tiny_int before TAN:%d\n", *((int8_t *)pInput->data));
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);
PRINTF("tiny_int after TAN:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result);
PRINTF("tiny_int after TAN:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -2050,15 +2062,15 @@ TEST(ScalarFunctionTest, tanFunction_constant) {
//FLOAT
float val_float = 13.00;
type = TSDB_DATA_TYPE_FLOAT;
scltMakeDataBlock(&pInput, type, &val_float, 1, true);
scltMakeDataBlock(&pInput, type, &val_float, rowNum, true);
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("float before TAN:%f\n", *((float *)pInput->data));
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);
PRINTF("float after TAN:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result);
PRINTF("float after TAN:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
......@@ -2079,15 +2091,15 @@ TEST(ScalarFunctionTest, tanFunction_column) {
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));
colDataAppend(pInput->columnData, i, (const char*) &val_tinyint[i], false);
PRINTF("tiny_int before TAN:%d\n", *((int8_t *)colDataGetData(pInput->columnData, i)));
}
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]);
PRINTF("tiny_int after TAN:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("tiny_int after TAN:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -2098,15 +2110,15 @@ TEST(ScalarFunctionTest, tanFunction_column) {
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));
colDataAppend(pInput->columnData, i, (const char*) &val_float[i], false);
PRINTF("float before TAN:%f\n", *((float *)colDataGetData(pInput->columnData, i)));
}
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]);
PRINTF("float after TAN:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("float after TAN:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
......@@ -2124,15 +2136,15 @@ TEST(ScalarFunctionTest, asinFunction_constant) {
//TINYINT
int8_t val_tinyint = 1;
type = TSDB_DATA_TYPE_TINYINT;
scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true);
scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true);
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("tiny_int before ASIN:%d\n", *((int8_t *)pInput->data));
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);
PRINTF("tiny_int after ASIN:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result);
PRINTF("tiny_int after ASIN:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -2140,15 +2152,15 @@ TEST(ScalarFunctionTest, asinFunction_constant) {
//FLOAT
float val_float = 1.00;
type = TSDB_DATA_TYPE_FLOAT;
scltMakeDataBlock(&pInput, type, &val_float, 1, true);
scltMakeDataBlock(&pInput, type, &val_float, rowNum, true);
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("float before ASIN:%f\n", *((float *)pInput->data));
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);
PRINTF("float after ASIN:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result);
PRINTF("float after ASIN:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
......@@ -2170,15 +2182,15 @@ TEST(ScalarFunctionTest, asinFunction_column) {
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));
colDataAppend(pInput->columnData, i, (const char*) &val_tinyint[i], false);
PRINTF("tiny_int before ASIN:%d\n", *((int8_t *)colDataGetData(pInput->columnData, i)));
}
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]);
PRINTF("tiny_int after ASIN:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("tiny_int after ASIN:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -2189,15 +2201,15 @@ TEST(ScalarFunctionTest, asinFunction_column) {
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));
*((float *)colDataGetData(pInput->columnData, i)) = val_float[i];
PRINTF("float before ASIN:%f\n", *((float *)colDataGetData(pInput->columnData, i)));
}
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]);
PRINTF("float after ASIN:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("float after ASIN:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
......@@ -2215,15 +2227,15 @@ TEST(ScalarFunctionTest, acosFunction_constant) {
//TINYINT
int8_t val_tinyint = 1;
type = TSDB_DATA_TYPE_TINYINT;
scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true);
scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true);
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("tiny_int before ACOS:%d\n", *((int8_t *)pInput->data));
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);
PRINTF("tiny_int after ACOS:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result);
PRINTF("tiny_int after ACOS:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -2231,15 +2243,15 @@ TEST(ScalarFunctionTest, acosFunction_constant) {
//FLOAT
float val_float = 1.00;
type = TSDB_DATA_TYPE_FLOAT;
scltMakeDataBlock(&pInput, type, &val_float, 1, true);
scltMakeDataBlock(&pInput, type, &val_float, rowNum, true);
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("float before ACOS:%f\n", *((float *)pInput->data));
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);
PRINTF("float after ACOS:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result);
PRINTF("float after ACOS:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
......@@ -2260,15 +2272,15 @@ TEST(ScalarFunctionTest, acosFunction_column) {
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));
*((int8_t *)colDataGetData(pInput->columnData, i)) = val_tinyint[i];
PRINTF("tiny_int before ACOS:%d\n", *((int8_t *)colDataGetData(pInput->columnData, i)));
}
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]);
PRINTF("tiny_int after ACOS:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("tiny_int after ACOS:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -2279,15 +2291,15 @@ TEST(ScalarFunctionTest, acosFunction_column) {
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));
*((float *)colDataGetData(pInput->columnData, i)) = val_float[i];
PRINTF("float before ACOS:%f\n", *((float *)colDataGetData(pInput->columnData, i)));
}
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]);
PRINTF("float after ACOS:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("float after ACOS:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
......@@ -2305,15 +2317,15 @@ TEST(ScalarFunctionTest, atanFunction_constant) {
//TINYINT
int8_t val_tinyint = 1;
type = TSDB_DATA_TYPE_TINYINT;
scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true);
scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true);
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("tiny_int before ATAN:%d\n", *((int8_t *)pInput->data));
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);
PRINTF("tiny_int after ATAN:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result);
PRINTF("tiny_int after ATAN:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -2321,15 +2333,15 @@ TEST(ScalarFunctionTest, atanFunction_constant) {
//FLOAT
float val_float = 1.00;
type = TSDB_DATA_TYPE_FLOAT;
scltMakeDataBlock(&pInput, type, &val_float, 1, true);
scltMakeDataBlock(&pInput, type, &val_float, rowNum, true);
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("float before ATAN:%f\n", *((float *)pInput->data));
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);
PRINTF("float after ATAN:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result);
PRINTF("float after ATAN:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
......@@ -2350,15 +2362,15 @@ TEST(ScalarFunctionTest, atanFunction_column) {
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));
*((int8_t *)colDataGetData(pInput->columnData, i)) = val_tinyint[i];
PRINTF("tiny_int before ATAN:%d\n", *((int8_t *)colDataGetData(pInput->columnData, i)));
}
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]);
PRINTF("tiny_int after ATAN:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("tiny_int after ATAN:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -2369,15 +2381,15 @@ TEST(ScalarFunctionTest, atanFunction_column) {
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));
*((float *)colDataGetData(pInput->columnData, i)) = val_float[i];
PRINTF("float before ATAN:%f\n", *((float *)colDataGetData(pInput->columnData, i)));
}
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]);
PRINTF("float after ATAN:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("float after ATAN:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
......@@ -2394,15 +2406,15 @@ TEST(ScalarFunctionTest, ceilFunction_constant) {
//TINYINT
int8_t val_tinyint = 10;
type = TSDB_DATA_TYPE_TINYINT;
scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true);
scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
PRINTF("tiny_int before CEIL:%d\n", *((int8_t *)pInput->data));
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);
PRINTF("tiny_int after CEIL:%d\n", *((int8_t *)pOutput->data + i));
ASSERT_EQ(*((int8_t *)colDataGetData(pOutput->columnData, i)), (int8_t)result);
PRINTF("tiny_int after CEIL:%d\n", *((int8_t *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -2410,15 +2422,15 @@ TEST(ScalarFunctionTest, ceilFunction_constant) {
//FLOAT
float val_float = 9.5;
type = TSDB_DATA_TYPE_FLOAT;
scltMakeDataBlock(&pInput, type, &val_float, 1, true);
scltMakeDataBlock(&pInput, type, &val_float, rowNum, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
PRINTF("float before CEIL:%f\n", *((float *)pInput->data));
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);
PRINTF("float after CEIL:%f\n", *((float *)pOutput->data + i));
ASSERT_EQ(*((float *)colDataGetData(pOutput->columnData, i)), (float)result);
PRINTF("float after CEIL:%f\n", *((float *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
......@@ -2438,15 +2450,15 @@ TEST(ScalarFunctionTest, ceilFunction_column) {
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));
*((int8_t *)colDataGetData(pInput->columnData, i)) = val_tinyint[i];
PRINTF("tiny_int before CEIL:%d\n", *((int8_t *)colDataGetData(pInput->columnData, i)));
}
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]);
PRINTF("tiny_int after CEIL:%d\n", *((int8_t *)pOutput->data + i));
ASSERT_EQ(*((int8_t *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("tiny_int after CEIL:%d\n", *((int8_t *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -2457,15 +2469,15 @@ TEST(ScalarFunctionTest, ceilFunction_column) {
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));
*((float *)colDataGetData(pInput->columnData, i)) = val_float[i];
PRINTF("float before CEIL:%f\n", *((float *)colDataGetData(pInput->columnData, i)));
}
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]);
PRINTF("float after CEIL:%f\n", *((float *)pOutput->data + i));
ASSERT_EQ(*((float *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("float after CEIL:%f\n", *((float *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
......@@ -2482,15 +2494,15 @@ TEST(ScalarFunctionTest, floorFunction_constant) {
//TINYINT
int8_t val_tinyint = 10;
type = TSDB_DATA_TYPE_TINYINT;
scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true);
scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
PRINTF("tiny_int before FLOOR:%d\n", *((int8_t *)pInput->data));
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);
PRINTF("tiny_int after FLOOR:%d\n", *((int8_t *)pOutput->data + i));
ASSERT_EQ(*((int8_t *)colDataGetData(pOutput->columnData, i)), (int8_t)result);
PRINTF("tiny_int after FLOOR:%d\n", *((int8_t *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -2498,15 +2510,15 @@ TEST(ScalarFunctionTest, floorFunction_constant) {
//FLOAT
float val_float = 10.5;
type = TSDB_DATA_TYPE_FLOAT;
scltMakeDataBlock(&pInput, type, &val_float, 1, true);
scltMakeDataBlock(&pInput, type, &val_float, rowNum, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
PRINTF("float before FLOOR:%f\n", *((float *)pInput->data));
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);
PRINTF("float after FLOOR:%f\n", *((float *)pOutput->data + i));
ASSERT_EQ(*((float *)colDataGetData(pOutput->columnData, i)), (float)result);
PRINTF("float after FLOOR:%f\n", *((float *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
......@@ -2526,15 +2538,15 @@ TEST(ScalarFunctionTest, floorFunction_column) {
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));
*((int8_t *)colDataGetData(pInput->columnData, i)) = val_tinyint[i];
PRINTF("tiny_int before FLOOR:%d\n", *((int8_t *)colDataGetData(pInput->columnData, i)));
}
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]);
PRINTF("tiny_int after FLOOR:%d\n", *((int8_t *)pOutput->data + i));
ASSERT_EQ(*((int8_t *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("tiny_int after FLOOR:%d\n", *((int8_t *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -2545,15 +2557,15 @@ TEST(ScalarFunctionTest, floorFunction_column) {
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));
*((float *)colDataGetData(pInput->columnData, i)) = val_float[i];
PRINTF("float before FLOOR:%f\n", *((float *)colDataGetData(pInput->columnData, i)));
}
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]);
PRINTF("float after FLOOR:%f\n", *((float *)pOutput->data + i));
ASSERT_EQ(*((float *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("float after FLOOR:%f\n", *((float *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
......@@ -2570,15 +2582,15 @@ TEST(ScalarFunctionTest, roundFunction_constant) {
//TINYINT
int8_t val_tinyint = 10;
type = TSDB_DATA_TYPE_TINYINT;
scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true);
scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
PRINTF("tiny_int before ROUND:%d\n", *((int8_t *)pInput->data));
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);
PRINTF("tiny_int after ROUND:%d\n", *((int8_t *)pOutput->data + i));
ASSERT_EQ(*((int8_t *)colDataGetData(pOutput->columnData, i)), (int8_t)result);
PRINTF("tiny_int after ROUND:%d\n", *((int8_t *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -2586,15 +2598,15 @@ TEST(ScalarFunctionTest, roundFunction_constant) {
//FLOAT
float val_float = 9.5;
type = TSDB_DATA_TYPE_FLOAT;
scltMakeDataBlock(&pInput, type, &val_float, 1, true);
scltMakeDataBlock(&pInput, type, &val_float, rowNum, true);
scltMakeDataBlock(&pOutput, type, 0, rowNum, false);
PRINTF("float before ROUND:%f\n", *((float *)pInput->data));
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);
PRINTF("float after ROUND:%f\n", *((float *)pOutput->data + i));
ASSERT_EQ(*((float *)colDataGetData(pOutput->columnData, i)), (float)result);
PRINTF("float after ROUND:%f\n", *((float *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
......@@ -2614,15 +2626,15 @@ TEST(ScalarFunctionTest, roundFunction_column) {
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));
*((int8_t *)colDataGetData(pInput->columnData, i)) = val_tinyint[i];
PRINTF("tiny_int before ROUND:%d\n", *((int8_t *)colDataGetData(pInput->columnData, i)));
}
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]);
PRINTF("tiny_int after ROUND:%d\n", *((int8_t *)pOutput->data + i));
ASSERT_EQ(*((int8_t *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("tiny_int after ROUND:%d\n", *((int8_t *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -2633,15 +2645,15 @@ TEST(ScalarFunctionTest, roundFunction_column) {
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));
*((float *)colDataGetData(pInput->columnData, i)) = val_float[i];
PRINTF("float before ROUND:%f\n", *((float *)colDataGetData(pInput->columnData, i)));
}
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]);
PRINTF("float after ROUND:%f\n", *((float *)pOutput->data + i));
ASSERT_EQ(*((float *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("float after ROUND:%f\n", *((float *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
......@@ -2659,15 +2671,15 @@ TEST(ScalarFunctionTest, sqrtFunction_constant) {
//TINYINT
int8_t val_tinyint = 25;
type = TSDB_DATA_TYPE_TINYINT;
scltMakeDataBlock(&pInput, type, &val_tinyint, 1, true);
scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true);
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("tiny_int before SQRT:%d\n", *((int8_t *)pInput->data));
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);
PRINTF("tiny_int after SQRT:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result);
PRINTF("tiny_int after SQRT:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -2675,15 +2687,15 @@ TEST(ScalarFunctionTest, sqrtFunction_constant) {
//FLOAT
float val_float = 25.0;
type = TSDB_DATA_TYPE_FLOAT;
scltMakeDataBlock(&pInput, type, &val_float, 1, true);
scltMakeDataBlock(&pInput, type, &val_float, rowNum, true);
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
PRINTF("float before SQRT:%f\n", *((float *)pInput->data));
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);
PRINTF("float after SQRT:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result);
PRINTF("float after SQRT:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
......@@ -2704,15 +2716,15 @@ TEST(ScalarFunctionTest, sqrtFunction_column) {
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));
*((int8_t *)colDataGetData(pInput->columnData, i)) = val_tinyint[i];
PRINTF("tiny_int before SQRT:%d\n", *((int8_t *)colDataGetData(pInput->columnData, i)));
}
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]);
PRINTF("tiny_int after SQRT:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("tiny_int after SQRT:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
scltDestroyDataBlock(pOutput);
......@@ -2723,15 +2735,15 @@ TEST(ScalarFunctionTest, sqrtFunction_column) {
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));
*((float *)colDataGetData(pInput->columnData, i)) = val_float[i];
PRINTF("float before SQRT:%f\n", *((float *)colDataGetData(pInput->columnData, i)));
}
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]);
PRINTF("float after SQRT:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("float after SQRT:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(pInput);
......@@ -2752,7 +2764,7 @@ TEST(ScalarFunctionTest, logFunction_constant) {
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);
scltMakeDataBlock(&input[i], type, &val_tinyint[i], rowNum, true);
pInput[i] = *input[i];
}
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
......@@ -2762,8 +2774,8 @@ TEST(ScalarFunctionTest, logFunction_constant) {
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);
PRINTF("tiny_int after LOG:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result);
PRINTF("tiny_int after LOG:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(input[0]);
scltDestroyDataBlock(input[1]);
......@@ -2773,7 +2785,7 @@ TEST(ScalarFunctionTest, logFunction_constant) {
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);
scltMakeDataBlock(&input[i], type, &val_float[i], rowNum, true);
pInput[i] = *input[i];
}
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
......@@ -2783,8 +2795,8 @@ TEST(ScalarFunctionTest, logFunction_constant) {
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);
PRINTF("float after LOG:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result);
PRINTF("float after LOG:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(input[0]);
scltDestroyDataBlock(input[1]);
......@@ -2793,9 +2805,9 @@ TEST(ScalarFunctionTest, logFunction_constant) {
//TINYINT AND FLOAT
int8_t param0 = 64;
float param1 = 4.0;
scltMakeDataBlock(&input[0], TSDB_DATA_TYPE_TINYINT, &param0, 1, true);
scltMakeDataBlock(&input[0], TSDB_DATA_TYPE_TINYINT, &param0, rowNum, true);
pInput[0] = *input[0];
scltMakeDataBlock(&input[1], TSDB_DATA_TYPE_FLOAT, &param1, 1, true);
scltMakeDataBlock(&input[1], TSDB_DATA_TYPE_FLOAT, &param1, rowNum, true);
pInput[1] = *input[1];
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
......@@ -2804,8 +2816,8 @@ TEST(ScalarFunctionTest, logFunction_constant) {
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);
PRINTF("tiny_int,float after LOG:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result);
PRINTF("tiny_int,float after LOG:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(input[0]);
......@@ -2831,7 +2843,8 @@ TEST(ScalarFunctionTest, logFunction_column) {
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];
colDataAppend(pInput[i].columnData, j, (const char*) &val_tinyint[i][j], false);
}
PRINTF("tiny_int before LOG:%d,%d,%d\n", *((int8_t *)pInput[i].data + 0),
*((int8_t *)pInput[i].data + 1),
......@@ -2842,8 +2855,8 @@ TEST(ScalarFunctionTest, logFunction_column) {
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]);
PRINTF("tiny_int after LOG:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("tiny_int after LOG:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(input[0]);
scltDestroyDataBlock(input[1]);
......@@ -2856,19 +2869,19 @@ TEST(ScalarFunctionTest, logFunction_column) {
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];
colDataAppend(pInput[i].columnData, j, (const char*) &val_float[i][j], false);
}
PRINTF("float before LOG:%f,%f,%f\n", *((float *)pInput[i].data + 0),
*((float *)pInput[i].data + 1),
*((float *)pInput[i].data + 2));
PRINTF("float before LOG:%f,%f,%f\n", *((float *)colDataGetData(pInput[i], 0)),
*((float *)colDataGetData(pInput[i], 1)),
*((float *)colDataGetData(pInput[i], 2)));
}
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
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]);
PRINTF("float after LOG:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("float after LOG:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(input[0]);
scltDestroyDataBlock(input[1]);
......@@ -2880,12 +2893,14 @@ TEST(ScalarFunctionTest, logFunction_column) {
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];
colDataAppend(pInput[0].columnData, i, (const char*) &param0[i], false);
}
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];
colDataAppend(pInput[1].columnData, i, (const char*) &param1[i], false);
}
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),
......@@ -2895,8 +2910,8 @@ TEST(ScalarFunctionTest, logFunction_column) {
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]);
PRINTF("tiny_int,float after LOG:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("tiny_int,float after LOG:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(input[0]);
......@@ -2919,7 +2934,7 @@ TEST(ScalarFunctionTest, powFunction_constant) {
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);
scltMakeDataBlock(&input[i], type, &val_tinyint[i], rowNum, true);
pInput[i] = *input[i];
}
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
......@@ -2929,8 +2944,8 @@ TEST(ScalarFunctionTest, powFunction_constant) {
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);
PRINTF("tiny_int after POW:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result);
PRINTF("tiny_int after POW:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(input[0]);
scltDestroyDataBlock(input[1]);
......@@ -2940,7 +2955,7 @@ TEST(ScalarFunctionTest, powFunction_constant) {
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);
scltMakeDataBlock(&input[i], type, &val_float[i], rowNum, true);
pInput[i] = *input[i];
}
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
......@@ -2950,8 +2965,8 @@ TEST(ScalarFunctionTest, powFunction_constant) {
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);
PRINTF("float after POW:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result);
PRINTF("float after POW:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(input[0]);
scltDestroyDataBlock(input[1]);
......@@ -2960,9 +2975,9 @@ TEST(ScalarFunctionTest, powFunction_constant) {
//TINYINT AND FLOAT
int8_t param0 = 2;
float param1 = 4.0;
scltMakeDataBlock(&input[0], TSDB_DATA_TYPE_TINYINT, &param0, 1, true);
scltMakeDataBlock(&input[0], TSDB_DATA_TYPE_TINYINT, &param0, rowNum, true);
pInput[0] = *input[0];
scltMakeDataBlock(&input[1], TSDB_DATA_TYPE_FLOAT, &param1, 1, true);
scltMakeDataBlock(&input[1], TSDB_DATA_TYPE_FLOAT, &param1, rowNum, true);
pInput[1] = *input[1];
scltMakeDataBlock(&pOutput, otype, 0, rowNum, false);
......@@ -2971,8 +2986,8 @@ TEST(ScalarFunctionTest, powFunction_constant) {
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);
PRINTF("tiny_int,float after POW:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result);
PRINTF("tiny_int,float after POW:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(input[0]);
......@@ -2998,7 +3013,8 @@ TEST(ScalarFunctionTest, powFunction_column) {
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];
colDataAppend(pInput[i].columnData, i, (const char*) &val_tinyint[i][j], false);
}
PRINTF("tiny_int before POW:%d,%d,%d\n", *((int8_t *)pInput[i].data + 0),
*((int8_t *)pInput[i].data + 1),
......@@ -3009,8 +3025,8 @@ TEST(ScalarFunctionTest, powFunction_column) {
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]);
PRINTF("tiny_int after POW:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("tiny_int after POW:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(input[0]);
......@@ -3024,7 +3040,7 @@ TEST(ScalarFunctionTest, powFunction_column) {
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];
colDataAppend(pInput[i].columnData, j, (const char*) &val_float[i][j], false);
}
PRINTF("float before POW:%f,%f,%f\n", *((float *)pInput[i].data + 0),
*((float *)pInput[i].data + 1),
......@@ -3035,8 +3051,8 @@ TEST(ScalarFunctionTest, powFunction_column) {
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]);
PRINTF("float after POW:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("float after POW:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(input[0]);
scltDestroyDataBlock(input[1]);
......@@ -3048,12 +3064,13 @@ TEST(ScalarFunctionTest, powFunction_column) {
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];
colDataAppend(pInput[0].columnData, i, (const char*) &param0[i], false);
}
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];
colDataAppend(pInput[1].columnData, i, (const char*) &param1[i], false);
}
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),
......@@ -3063,8 +3080,8 @@ TEST(ScalarFunctionTest, powFunction_column) {
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]);
PRINTF("tiny_int,float after POW:%f\n", *((double *)pOutput->data + i));
ASSERT_EQ(*((double *)colDataGetData(pOutput->columnData, i)), result[i]);
PRINTF("tiny_int,float after POW:%f\n", *((double *)colDataGetData(pOutput->columnData, i)));
}
scltDestroyDataBlock(input[0]);
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或