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

[td-13039] fix compiler error.

This commit is contained in:
Haojun Liao 2022-03-27 15:47:03 +08:00
parent b9c33dade2
commit 6cd2d69d14
2 changed files with 132 additions and 274 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

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

2
source/libs/scalar/src/sclvector.c
View File

@ -279,7 +279,7 @@ static FORCE_INLINE void varToBool(char *buf, SScalarParam* pOut, int32_t rowInd
int32_t vectorConvertFromVarData(SScalarParam* pIn, SScalarParam* pOut, int32_t inType, int32_t outType) { int32_t vectorConvertFromVarData(SScalarParam* pIn, SScalarParam* pOut, int32_t inType, int32_t outType) {
int32_t bufSize = pIn->columnData->info.bytes; int32_t bufSize = pIn->columnData->info.bytes;
char *tmp = malloc(bufSize); char *tmp = taosMemoryMalloc(bufSize);
_bufConverteFunc func = NULL; _bufConverteFunc func = NULL;
if (TSDB_DATA_TYPE_BOOL == outType) { if (TSDB_DATA_TYPE_BOOL == outType) {