Skip to content

TDengine
TDengine

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

通知 1192
Star 22018
Fork 4786
TDengine
TDengine
未验证 提交 87bf0e2b 编写于 作者: wafwerar's avatar wafwerar 提交者： GitHub
浏览文件
操作

[TD-5772]<fix>: arm64 compilation problem. (#7357) 

* [TD-5772]<fix>: arm64 compilation problem.

* [TD-5772]<fix>: arm64 compilation problem.

* [TD-5772]<fix>: arm64 compilation problem.

* [TD-5772]<fix>: arm64 compilation problem.

* [TD-5772]<fix>: arm64 compilation problem.

* [TD-5772]<fix>: arm64 compilation problem.

* [TD-5772]<fix>: arm64 compilation problem.
上级 d02d71c1
隐藏空白更改
内联 并排
Showing with 325 addition and 2557 deletion
src/common/src/tarithoperator.c
浏览文件 @ 87bf0e2b
...@@ -21,187 +21,6 @@ ...@@ -21,187 +21,6 @@
#include "tcompare.h" #include "tcompare.h"
//GET_TYPED_DATA(v, double, _right_type, (char *)&((right)[i])); //GET_TYPED_DATA(v, double, _right_type, (char *)&((right)[i]));
#define ARRAY_LIST_OP_DIV(left, right, _left_type, _right_type, len1, len2, out, op, _res_type, _ord) \
{ \
int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : MAX(len1, len2) - 1; \
int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1; \
\
if ((len1) == (len2)) { \
for (; i < (len2) && i >= 0; i += step, (out) += 1) { \
if (isNull((char *)&((left)[i]), _left_type) || isNull((char *)&((right)[i]), _right_type)) { \
SET_DOUBLE_NULL(out); \
continue; \
} \
double v, z = 0.0; \
GET_TYPED_DATA(v, double, _right_type, (char *)&((right)[i])); \
if (getComparFunc(TSDB_DATA_TYPE_DOUBLE, 0)(&v, &z) == 0) { \
SET_DOUBLE_NULL(out); \
continue; \
} \
*(out) = (double)(left)[i] op(right)[i]; \
} \
} else if ((len1) == 1) { \
for (; i >= 0 && i < (len2); i += step, (out) += 1) { \
if (isNull((char *)(left), _left_type) || isNull((char *)&(right)[i], _right_type)) { \
SET_DOUBLE_NULL(out); \
continue; \
} \
double v, z = 0.0; \
GET_TYPED_DATA(v, double, _right_type, (char *)&((right)[i])); \
if (getComparFunc(TSDB_DATA_TYPE_DOUBLE, 0)(&v, &z) == 0) { \
SET_DOUBLE_NULL(out); \
continue; \
} \
*(out) = (double)(left)[0] op(right)[i]; \
} \
} else if ((len2) == 1) { \
for (; i >= 0 && i < (len1); i += step, (out) += 1) { \
if (isNull((char *)&(left)[i], _left_type) || isNull((char *)(right), _right_type)) { \
SET_DOUBLE_NULL(out); \
continue; \
} \
double v, z = 0.0; \
GET_TYPED_DATA(v, double, _right_type, (char *)&((right)[0])); \
if (getComparFunc(TSDB_DATA_TYPE_DOUBLE, 0)(&v, &z) == 0) { \
SET_DOUBLE_NULL(out); \
continue; \
} \
*(out) = (double)(left)[i] op(right)[0]; \
} \
} \
}
#define ARRAY_LIST_OP(left, right, _left_type, _right_type, len1, len2, out, op, _res_type, _ord) \
{ \
int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : MAX(len1, len2) - 1; \
int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1; \
\
if ((len1) == (len2)) { \
for (; i < (len2) && i >= 0; i += step, (out) += 1) { \
if (isNull((char *)&((left)[i]), _left_type) || isNull((char *)&((right)[i]), _right_type)) { \
SET_DOUBLE_NULL(out); \
continue; \
} \
*(out) = (double)(left)[i] op(right)[i]; \
} \
} else if ((len1) == 1) { \
for (; i >= 0 && i < (len2); i += step, (out) += 1) { \
if (isNull((char *)(left), _left_type) || isNull((char *)&(right)[i], _right_type)) { \
SET_DOUBLE_NULL(out); \
continue; \
} \
*(out) = (double)(left)[0] op(right)[i]; \
} \
} else if ((len2) == 1) { \
for (; i >= 0 && i < (len1); i += step, (out) += 1) { \
if (isNull((char *)&(left)[i], _left_type) || isNull((char *)(right), _right_type)) { \
SET_DOUBLE_NULL(out); \
continue; \
} \
*(out) = (double)(left)[i] op(right)[0]; \
} \
} \
}
#define ARRAY_LIST_OP_REM(left, right, _left_type, _right_type, len1, len2, out, op, _res_type, _ord) \
{ \
int32_t i = (_ord == TSDB_ORDER_ASC) ? 0 : MAX(len1, len2) - 1; \
int32_t step = (_ord == TSDB_ORDER_ASC) ? 1 : -1; \
\
if (len1 == (len2)) { \
for (; i >= 0 && i < (len2); i += step, (out) += 1) { \
if (isNull((char *)&(left[i]), _left_type) || isNull((char *)&(right[i]), _right_type)) { \
SET_DOUBLE_NULL(out); \
continue; \
} \
double v, z = 0.0; \
GET_TYPED_DATA(v, double, _right_type, (char *)&((right)[i])); \
if (getComparFunc(TSDB_DATA_TYPE_DOUBLE, 0)(&v, &z) == 0) { \
SET_DOUBLE_NULL(out); \
continue; \
} \
*(out) = (double)(left)[i] - ((int64_t)(((double)(left)[i]) / (right)[i])) * (right)[i]; \
} \
} else if (len1 == 1) { \
for (; i >= 0 && i < (len2); i += step, (out) += 1) { \
if (isNull((char *)(left), _left_type) || isNull((char *)&((right)[i]), _right_type)) { \
SET_DOUBLE_NULL(out); \
continue; \
} \
double v, z = 0.0; \
GET_TYPED_DATA(v, double, _right_type, (char *)&((right)[i])); \
if (getComparFunc(TSDB_DATA_TYPE_DOUBLE, 0)(&v, &z) == 0) { \
SET_DOUBLE_NULL(out); \
continue; \
} \
*(out) = (double)(left)[0] - ((int64_t)(((double)(left)[0]) / (right)[i])) * (right)[i]; \
} \
} else if ((len2) == 1) { \
for (; i >= 0 && i < len1; i += step, (out) += 1) { \
if (isNull((char *)&((left)[i]), _left_type) || isNull((char *)(right), _right_type)) { \
SET_DOUBLE_NULL(out); \
continue; \
} \
double v, z = 0.0; \
GET_TYPED_DATA(v, double, _right_type, (char *)&((right)[0])); \
if (getComparFunc(TSDB_DATA_TYPE_DOUBLE, 0)(&v, &z) == 0) { \
SET_DOUBLE_NULL(out); \
continue; \
} \
*(out) = (double)(left)[i] - ((int64_t)(((double)(left)[i]) / (right)[0])) * (right)[0]; \
} \
} \
}
#define ARRAY_LIST_ADD(left, right, _left_type, _right_type, len1, len2, out, _ord) \
ARRAY_LIST_OP(left, right, _left_type, _right_type, len1, len2, out, +, TSDB_DATA_TYPE_DOUBLE, _ord)
#define ARRAY_LIST_SUB(left, right, _left_type, _right_type, len1, len2, out, _ord) \
ARRAY_LIST_OP(left, right, _left_type, _right_type, len1, len2, out, -, TSDB_DATA_TYPE_DOUBLE, _ord)
#define ARRAY_LIST_MULTI(left, right, _left_type, _right_type, len1, len2, out, _ord) \
ARRAY_LIST_OP(left, right, _left_type, _right_type, len1, len2, out, *, TSDB_DATA_TYPE_DOUBLE, _ord)
#define ARRAY_LIST_DIV(left, right, _left_type, _right_type, len1, len2, out, _ord) \
ARRAY_LIST_OP_DIV(left, right, _left_type, _right_type, len1, len2, out, /, TSDB_DATA_TYPE_DOUBLE, _ord)
#define ARRAY_LIST_REM(left, right, _left_type, _right_type, len1, len2, out, _ord) \
ARRAY_LIST_OP_REM(left, right, _left_type, _right_type, len1, len2, out, %, TSDB_DATA_TYPE_DOUBLE, _ord)
#define TYPE_CONVERT_DOUBLE_RES(left, right, out, _type_left, _type_right, _type_res) \
_type_left * pLeft = (_type_left *)(left); \
_type_right *pRight = (_type_right *)(right); \
_type_res * pOutput = (_type_res *)(out);
#define DO_VECTOR_ADD(left, numLeft, leftType, leftOriginType, right, numRight, rightType, rightOriginType, _output, \
_order) \
do { \
TYPE_CONVERT_DOUBLE_RES(left, right, _output, leftOriginType, rightOriginType, double); \
ARRAY_LIST_ADD(pLeft, pRight, leftType, rightType, numLeft, numRight, pOutput, _order); \
} while (0)
#define DO_VECTOR_SUB(left, numLeft, leftType, leftOriginType, right, numRight, rightType, rightOriginType, _output, \
_order) \
do { \
TYPE_CONVERT_DOUBLE_RES(left, right, _output, leftOriginType, rightOriginType, double); \
ARRAY_LIST_SUB(pLeft, pRight, leftType, rightType, numLeft, numRight, pOutput, _order); \
} while (0)
#define DO_VECTOR_MULTIPLY(left, numLeft, leftType, leftOriginType, right, numRight, rightType, rightOriginType, \
_output, _order) \
do { \
TYPE_CONVERT_DOUBLE_RES(left, right, _output, leftOriginType, rightOriginType, double); \
ARRAY_LIST_MULTI(pLeft, pRight, leftType, rightType, numLeft, numRight, pOutput, _order); \
} while (0)
#define DO_VECTOR_DIVIDE(left, numLeft, leftType, leftOriginType, right, numRight, rightType, rightOriginType, \
_output, _order) \
do { \
TYPE_CONVERT_DOUBLE_RES(left, right, _output, leftOriginType, rightOriginType, double); \
ARRAY_LIST_DIV(pLeft, pRight, leftType, rightType, numLeft, numRight, pOutput, _order); \
} while (0)
#define DO_VECTOR_REMAINDER(left, numLeft, leftType, leftOriginType, right, numRight, rightType, rightOriginType, \
_output, _order) \
do { \
TYPE_CONVERT_DOUBLE_RES(left, right, _output, leftOriginType, rightOriginType, double); \
ARRAY_LIST_REM(pLeft, pRight, leftType, rightType, numLeft, numRight, pOutput, _order); \
} while (0)
void calc_i32_i32_add(void *left, void *right, int32_t numLeft, int32_t numRight, void *output, int32_t order) { void calc_i32_i32_add(void *left, void *right, int32_t numLeft, int32_t numRight, void *output, int32_t order) {
int32_t *pLeft = (int32_t *)left; int32_t *pLeft = (int32_t *)left;
...@@ -240,2389 +59,338 @@ void calc_i32_i32_add(void *left, void *right, int32_t numLeft, int32_t numRight ...@@ -240,2389 +59,338 @@ void calc_i32_i32_add(void *left, void *right, int32_t numLeft, int32_t numRight
} }
} }
void vectorAdd(void *left, int32_t numLeft, int32_t leftType, void *right, int32_t numRight, int32_t rightType, typedef double (*_arithmetic_getVectorDoubleValue_fn_t)(void *src, int32_t index);
void *output, int32_t order) {
switch(leftType) {
case TSDB_DATA_TYPE_TINYINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int8_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int8_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int8_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int8_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_ADD(left, numLeft, leftType, int8_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int8_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int8_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int8_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_ADD(left, numLeft, leftType, int8_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_ADD(left, numLeft, leftType, int8_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint8_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint8_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint8_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint8_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint8_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint8_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint8_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint8_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint8_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_ADD(left, numLeft, leftType, uint8_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int16_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int16_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int16_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int16_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_ADD(left, numLeft, leftType, int16_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int16_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int16_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int16_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_ADD(left, numLeft, leftType, int16_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_ADD(left, numLeft, leftType, int16_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint16_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint16_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint16_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint16_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint16_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint16_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint16_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint16_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint16_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_ADD(left, numLeft, leftType, uint16_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_INT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int32_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int32_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int32_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int32_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_ADD(left, numLeft, leftType, int32_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int32_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int32_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int32_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_ADD(left, numLeft, leftType, int32_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_ADD(left, numLeft, leftType, int32_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_UINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint32_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint32_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint32_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint32_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint32_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint32_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint32_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint32_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint32_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_ADD(left, numLeft, leftType, uint32_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_BIGINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int64_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int64_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int64_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int64_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_ADD(left, numLeft, leftType, int64_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int64_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int64_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_ADD(left, numLeft, leftType, int64_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_ADD(left, numLeft, leftType, int64_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_ADD(left, numLeft, leftType, int64_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint64_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint64_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint64_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint64_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint64_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint64_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint64_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint64_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_ADD(left, numLeft, leftType, uint64_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_ADD(left, numLeft, leftType, uint64_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_FLOAT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_ADD(left, numLeft, leftType, float, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_ADD(left, numLeft, leftType, float, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_ADD(left, numLeft, leftType, float, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_ADD(left, numLeft, leftType, float, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_ADD(left, numLeft, leftType, float, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_ADD(left, numLeft, leftType, float, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_ADD(left, numLeft, leftType, float, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_ADD(left, numLeft, leftType, float, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_ADD(left, numLeft, leftType, float, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_ADD(left, numLeft, leftType, float, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_ADD(left, numLeft, leftType, double, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_ADD(left, numLeft, leftType, double, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_ADD(left, numLeft, leftType, double, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_ADD(left, numLeft, leftType, double, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_ADD(left, numLeft, leftType, double, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_ADD(left, numLeft, leftType, double, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_ADD(left, numLeft, leftType, double, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_ADD(left, numLeft, leftType, double, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_ADD(left, numLeft, leftType, double, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_ADD(left, numLeft, leftType, double, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
default:;
}
}
void vectorSub(void *left, int32_t numLeft, int32_t leftType, void *right, int32_t numRight, int32_t rightType, double getVectorDoubleValue_TINYINT(void *src, int32_t index) {
void *output, int32_t order) { return (double)*((int8_t *)src + index);
switch(leftType) { }
case TSDB_DATA_TYPE_TINYINT: { double getVectorDoubleValue_UTINYINT(void *src, int32_t index) {
switch (rightType) { return (double)*((uint8_t *)src + index);
case TSDB_DATA_TYPE_TINYINT: { }
DO_VECTOR_SUB(left, numLeft, leftType, int8_t, right, numRight, rightType, int8_t, output, order); double getVectorDoubleValue_SMALLINT(void *src, int32_t index) {
break; return (double)*((int16_t *)src + index);
} }
case TSDB_DATA_TYPE_UTINYINT: { double getVectorDoubleValue_USMALLINT(void *src, int32_t index) {
DO_VECTOR_SUB(left, numLeft, leftType, int8_t, right, numRight, rightType, uint8_t, output, order); return (double)*((uint16_t *)src + index);
break; }
} double getVectorDoubleValue_INT(void *src, int32_t index) {
case TSDB_DATA_TYPE_SMALLINT: { return (double)*((int32_t *)src + index);
DO_VECTOR_SUB(left, numLeft, leftType, int8_t, right, numRight, rightType, int16_t, output, order); }
break; double getVectorDoubleValue_UINT(void *src, int32_t index) {
} return (double)*((uint32_t *)src + index);
case TSDB_DATA_TYPE_USMALLINT: { }
DO_VECTOR_SUB(left, numLeft, leftType, int8_t, right, numRight, rightType, uint16_t, output, order); double getVectorDoubleValue_BIGINT(void *src, int32_t index) {
break; return (double)*((int64_t *)src + index);
} }
case TSDB_DATA_TYPE_INT: { double getVectorDoubleValue_UBIGINT(void *src, int32_t index) {
DO_VECTOR_SUB(left, numLeft, leftType, int8_t, right, numRight, rightType, int32_t, output, order); return (double)*((uint64_t *)src + index);
break; }
} double getVectorDoubleValue_FLOAT(void *src, int32_t index) {
case TSDB_DATA_TYPE_UINT: { return (double)*((float *)src + index);
DO_VECTOR_SUB(left, numLeft, leftType, int8_t, right, numRight, rightType, uint32_t, output, order); }
break; double getVectorDoubleValue_DOUBLE(void *src, int32_t index) {
} return (double)*((double *)src + index);
case TSDB_DATA_TYPE_BIGINT: { }
DO_VECTOR_SUB(left, numLeft, leftType, int8_t, right, numRight, rightType, int64_t, output, order); _arithmetic_getVectorDoubleValue_fn_t getVectorDoubleValueFn(int32_t srcType) {
break; _arithmetic_getVectorDoubleValue_fn_t p = NULL;
} if(srcType==TSDB_DATA_TYPE_TINYINT) {
case TSDB_DATA_TYPE_UBIGINT: { p = getVectorDoubleValue_TINYINT;
DO_VECTOR_SUB(left, numLeft, leftType, int8_t, right, numRight, rightType, uint64_t, output, order); }else if(srcType==TSDB_DATA_TYPE_UTINYINT) {
break; p = getVectorDoubleValue_UTINYINT;
} }else if(srcType==TSDB_DATA_TYPE_SMALLINT) {
case TSDB_DATA_TYPE_FLOAT: { p = getVectorDoubleValue_SMALLINT;
DO_VECTOR_SUB(left, numLeft, leftType, int8_t, right, numRight, rightType, float, output, order); }else if(srcType==TSDB_DATA_TYPE_USMALLINT) {
break; p = getVectorDoubleValue_USMALLINT;
} }else if(srcType==TSDB_DATA_TYPE_INT) {
case TSDB_DATA_TYPE_DOUBLE: { p = getVectorDoubleValue_INT;
DO_VECTOR_SUB(left, numLeft, leftType, int8_t, right, numRight, rightType, double, output, order); }else if(srcType==TSDB_DATA_TYPE_UINT) {
break; p = getVectorDoubleValue_UINT;
} }else if(srcType==TSDB_DATA_TYPE_BIGINT) {
default: p = getVectorDoubleValue_BIGINT;
assert(0); }else if(srcType==TSDB_DATA_TYPE_UBIGINT) {
} p = getVectorDoubleValue_UBIGINT;
break; }else if(srcType==TSDB_DATA_TYPE_FLOAT) {
} p = getVectorDoubleValue_FLOAT;
case TSDB_DATA_TYPE_UTINYINT: { }else if(srcType==TSDB_DATA_TYPE_DOUBLE) {
switch (rightType) { p = getVectorDoubleValue_DOUBLE;
case TSDB_DATA_TYPE_TINYINT: { }else {
DO_VECTOR_SUB(left, numLeft, leftType, uint8_t, right, numRight, rightType, int8_t, output, order); assert(0);
break; }
} return p;
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint8_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint8_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint8_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint8_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint8_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint8_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint8_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint8_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_SUB(left, numLeft, leftType, uint8_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_SUB(left, numLeft, leftType, int16_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_SUB(left, numLeft, leftType, int16_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_SUB(left, numLeft, leftType, int16_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_SUB(left, numLeft, leftType, int16_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_SUB(left, numLeft, leftType, int16_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_SUB(left, numLeft, leftType, int16_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_SUB(left, numLeft, leftType, int16_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_SUB(left, numLeft, leftType, int16_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_SUB(left, numLeft, leftType, int16_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_SUB(left, numLeft, leftType, int16_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint16_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint16_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint16_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint16_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint16_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint16_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint16_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint16_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint16_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_SUB(left, numLeft, leftType, uint16_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_INT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_SUB(left, numLeft, leftType, int32_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_SUB(left, numLeft, leftType, int32_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_SUB(left, numLeft, leftType, int32_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_SUB(left, numLeft, leftType, int32_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_SUB(left, numLeft, leftType, int32_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_SUB(left, numLeft, leftType, int32_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_SUB(left, numLeft, leftType, int32_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_SUB(left, numLeft, leftType, int32_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_SUB(left, numLeft, leftType, int32_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_SUB(left, numLeft, leftType, int32_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_UINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint32_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint32_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint32_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint32_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint32_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint32_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint32_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint32_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint32_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_SUB(left, numLeft, leftType, uint32_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_BIGINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_SUB(left, numLeft, leftType, int64_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_SUB(left, numLeft, leftType, int64_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_SUB(left, numLeft, leftType, int64_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_SUB(left, numLeft, leftType, int64_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_SUB(left, numLeft, leftType, int64_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_SUB(left, numLeft, leftType, int64_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_SUB(left, numLeft, leftType, int64_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_SUB(left, numLeft, leftType, int64_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_SUB(left, numLeft, leftType, int64_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_SUB(left, numLeft, leftType, int64_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint64_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint64_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint64_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint64_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint64_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint64_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint64_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint64_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_SUB(left, numLeft, leftType, uint64_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_SUB(left, numLeft, leftType, uint64_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_FLOAT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_SUB(left, numLeft, leftType, float, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_SUB(left, numLeft, leftType, float, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_SUB(left, numLeft, leftType, float, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_SUB(left, numLeft, leftType, float, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_SUB(left, numLeft, leftType, float, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_SUB(left, numLeft, leftType, float, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_SUB(left, numLeft, leftType, float, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_SUB(left, numLeft, leftType, float, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_SUB(left, numLeft, leftType, float, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_SUB(left, numLeft, leftType, float, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_SUB(left, numLeft, leftType, double, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_SUB(left, numLeft, leftType, double, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_SUB(left, numLeft, leftType, double, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_SUB(left, numLeft, leftType, double, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_SUB(left, numLeft, leftType, double, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_SUB(left, numLeft, leftType, double, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_SUB(left, numLeft, leftType, double, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_SUB(left, numLeft, leftType, double, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_SUB(left, numLeft, leftType, double, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_SUB(left, numLeft, leftType, double, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
default:;
}
} }
void vectorMultiply(void *left, int32_t numLeft, int32_t leftType, void *right, int32_t numRight, int32_t rightType,
void *output, int32_t order) { typedef void* (*_arithmetic_getVectorValueAddr_fn_t)(void *src, int32_t index);
switch(leftType) {
case TSDB_DATA_TYPE_TINYINT: { void* getVectorValueAddr_TINYINT(void *src, int32_t index) {
switch (rightType) { return (void*)((int8_t *)src + index);
case TSDB_DATA_TYPE_TINYINT: { }
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int8_t, right, numRight, rightType, int8_t, output, order); void* getVectorValueAddr_UTINYINT(void *src, int32_t index) {
break; return (void*)((uint8_t *)src + index);
} }
case TSDB_DATA_TYPE_UTINYINT: { void* getVectorValueAddr_SMALLINT(void *src, int32_t index) {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int8_t, right, numRight, rightType, uint8_t, output, order); return (void*)((int16_t *)src + index);
break; }
} void* getVectorValueAddr_USMALLINT(void *src, int32_t index) {
case TSDB_DATA_TYPE_SMALLINT: { return (void*)((uint16_t *)src + index);
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int8_t, right, numRight, rightType, int16_t, output, order); }
break; void* getVectorValueAddr_INT(void *src, int32_t index) {
} return (void*)((int32_t *)src + index);
case TSDB_DATA_TYPE_USMALLINT: { }
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int8_t, right, numRight, rightType, uint16_t, output, order); void* getVectorValueAddr_UINT(void *src, int32_t index) {
break; return (void*)((uint32_t *)src + index);
} }
case TSDB_DATA_TYPE_INT: { void* getVectorValueAddr_BIGINT(void *src, int32_t index) {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int8_t, right, numRight, rightType, int32_t, output, order); return (void*)((int64_t *)src + index);
break; }
} void* getVectorValueAddr_UBIGINT(void *src, int32_t index) {
case TSDB_DATA_TYPE_UINT: { return (void*)((uint64_t *)src + index);
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int8_t, right, numRight, rightType, uint32_t, output, order); }
break; void* getVectorValueAddr_FLOAT(void *src, int32_t index) {
} return (void*)((float *)src + index);
case TSDB_DATA_TYPE_BIGINT: { }
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int8_t, right, numRight, rightType, int64_t, output, order); void* getVectorValueAddr_DOUBLE(void *src, int32_t index) {
break; return (void*)((double *)src + index);
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int8_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int8_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int8_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint8_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint8_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint8_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint8_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint8_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint8_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint8_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint8_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint8_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint8_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int16_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int16_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int16_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int16_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int16_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int16_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int16_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int16_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int16_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int16_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint16_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint16_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint16_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint16_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint16_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint16_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint16_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint16_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint16_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint16_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_INT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int32_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int32_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int32_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int32_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int32_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int32_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int32_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int32_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int32_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int32_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_UINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint32_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint32_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint32_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint32_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint32_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint32_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint32_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint32_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint32_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint32_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_BIGINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int64_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int64_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int64_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int64_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int64_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int64_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int64_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int64_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int64_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, int64_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint64_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint64_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint64_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint64_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint64_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint64_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint64_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint64_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint64_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, uint64_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_FLOAT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, float, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, float, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, float, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, float, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, float, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, float, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, float, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, float, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, float, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, float, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, double, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, double, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, double, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, double, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, double, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, double, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, double, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, double, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, double, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_MULTIPLY(left, numLeft, leftType, double, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
default:;
}
} }
void vectorDivide(void *left, int32_t numLeft, int32_t leftType, void *right, int32_t numRight, int32_t rightType, _arithmetic_getVectorValueAddr_fn_t getVectorValueAddrFn(int32_t srcType) {
void *output, int32_t order) { _arithmetic_getVectorValueAddr_fn_t p = NULL;
switch(leftType) { if(srcType==TSDB_DATA_TYPE_TINYINT) {
case TSDB_DATA_TYPE_TINYINT: { p = getVectorValueAddr_TINYINT;
switch (rightType) { }else if(srcType==TSDB_DATA_TYPE_UTINYINT) {
case TSDB_DATA_TYPE_TINYINT: { p = getVectorValueAddr_UTINYINT;
DO_VECTOR_DIVIDE(left, numLeft, leftType, int8_t, right, numRight, rightType, int8_t, output, order); }else if(srcType==TSDB_DATA_TYPE_SMALLINT) {
break; p = getVectorValueAddr_SMALLINT;
} }else if(srcType==TSDB_DATA_TYPE_USMALLINT) {
case TSDB_DATA_TYPE_UTINYINT: { p = getVectorValueAddr_USMALLINT;
DO_VECTOR_DIVIDE(left, numLeft, leftType, int8_t, right, numRight, rightType, uint8_t, output, order); }else if(srcType==TSDB_DATA_TYPE_INT) {
break; p = getVectorValueAddr_INT;
} }else if(srcType==TSDB_DATA_TYPE_UINT) {
case TSDB_DATA_TYPE_SMALLINT: { p = getVectorValueAddr_UINT;
DO_VECTOR_DIVIDE(left, numLeft, leftType, int8_t, right, numRight, rightType, int16_t, output, order); }else if(srcType==TSDB_DATA_TYPE_BIGINT) {
break; p = getVectorValueAddr_BIGINT;
} }else if(srcType==TSDB_DATA_TYPE_UBIGINT) {
case TSDB_DATA_TYPE_USMALLINT: { p = getVectorValueAddr_UBIGINT;
DO_VECTOR_DIVIDE(left, numLeft, leftType, int8_t, right, numRight, rightType, uint16_t, output, order); }else if(srcType==TSDB_DATA_TYPE_FLOAT) {
break; p = getVectorValueAddr_FLOAT;
} }else if(srcType==TSDB_DATA_TYPE_DOUBLE) {
case TSDB_DATA_TYPE_INT: { p = getVectorValueAddr_DOUBLE;
DO_VECTOR_DIVIDE(left, numLeft, leftType, int8_t, right, numRight, rightType, int32_t, output, order); }else {
break; assert(0);
} }
case TSDB_DATA_TYPE_UINT: { return p;
DO_VECTOR_DIVIDE(left, numLeft, leftType, int8_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int8_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int8_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int8_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int8_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint8_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint8_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint8_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint8_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint8_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint8_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint8_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint8_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint8_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint8_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int16_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int16_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int16_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int16_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int16_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int16_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int16_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int16_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int16_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int16_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint16_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint16_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint16_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint16_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint16_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint16_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint16_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint16_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint16_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint16_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_INT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int32_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int32_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int32_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int32_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int32_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int32_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int32_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int32_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int32_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int32_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_UINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint32_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint32_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint32_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint32_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint32_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint32_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint32_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint32_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint32_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint32_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_BIGINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int64_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int64_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int64_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int64_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int64_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int64_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int64_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int64_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int64_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, int64_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint64_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint64_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint64_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint64_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint64_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint64_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint64_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint64_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint64_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, uint64_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_FLOAT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, float, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, float, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, float, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, float, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, float, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, float, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, float, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, float, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, float, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, float, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, double, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, double, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, double, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, double, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, double, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, double, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, double, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, double, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, double, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_DIVIDE(left, numLeft, leftType, double, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
default:;
}
} }
void vectorRemainder(void *left, int32_t numLeft, int32_t leftType, void *right, int32_t numRight, int32_t rightType, void vectorAdd(void *left, int32_t len1, int32_t _left_type, void *right, int32_t len2, int32_t _right_type, void *out, int32_t _ord) {
void *output, int32_t order) { int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : MAX(len1, len2) - 1;
switch(leftType) { int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1;
case TSDB_DATA_TYPE_TINYINT: { double *output=(double*)out;
switch (rightType) { _arithmetic_getVectorValueAddr_fn_t getVectorValueAddrFnLeft = getVectorValueAddrFn(_left_type);
case TSDB_DATA_TYPE_TINYINT: { _arithmetic_getVectorValueAddr_fn_t getVectorValueAddrFnRight = getVectorValueAddrFn(_right_type);
DO_VECTOR_REMAINDER(left, numLeft, leftType, int8_t, right, numRight, rightType, int8_t, output, order); _arithmetic_getVectorDoubleValue_fn_t getVectorDoubleValueFnLeft = getVectorDoubleValueFn(_left_type);
break; _arithmetic_getVectorDoubleValue_fn_t getVectorDoubleValueFnRight = getVectorDoubleValueFn(_right_type);
}
case TSDB_DATA_TYPE_UTINYINT: { if ((len1) == (len2)) {
DO_VECTOR_REMAINDER(left, numLeft, leftType, int8_t, right, numRight, rightType, uint8_t, output, order); for (; i < (len2) && i >= 0; i += step, output += 1) {
break; if (isNull(getVectorValueAddrFnLeft(left,i), _left_type) || isNull(getVectorValueAddrFnRight(right,i), _right_type)) {
} SET_DOUBLE_NULL(output);
case TSDB_DATA_TYPE_SMALLINT: { continue;
DO_VECTOR_REMAINDER(left, numLeft, leftType, int8_t, right, numRight, rightType, int16_t, output, order); }
break; SET_DOUBLE_VAL(output,getVectorDoubleValueFnLeft(left,i) + getVectorDoubleValueFnRight(right,i));
} }
case TSDB_DATA_TYPE_USMALLINT: { } else if ((len1) == 1) {
DO_VECTOR_REMAINDER(left, numLeft, leftType, int8_t, right, numRight, rightType, uint16_t, output, order); for (; i >= 0 && i < (len2); i += step, output += 1) {
break; if (isNull(getVectorValueAddrFnLeft(left,0), _left_type) || isNull(getVectorValueAddrFnRight(right,i), _right_type)) {
} SET_DOUBLE_NULL(output);
case TSDB_DATA_TYPE_INT: { continue;
DO_VECTOR_REMAINDER(left, numLeft, leftType, int8_t, right, numRight, rightType, int32_t, output, order); }
break; SET_DOUBLE_VAL(output,getVectorDoubleValueFnLeft(left,0) + getVectorDoubleValueFnRight(right,i));
} }
case TSDB_DATA_TYPE_UINT: { } else if ((len2) == 1) {
DO_VECTOR_REMAINDER(left, numLeft, leftType, int8_t, right, numRight, rightType, uint32_t, output, order); for (; i >= 0 && i < (len1); i += step, output += 1) {
break; if (isNull(getVectorValueAddrFnLeft(left,i), _left_type) || isNull(getVectorValueAddrFnRight(right,0), _right_type)) {
} SET_DOUBLE_NULL(output);
case TSDB_DATA_TYPE_BIGINT: { continue;
DO_VECTOR_REMAINDER(left, numLeft, leftType, int8_t, right, numRight, rightType, int64_t, output, order); }
break; SET_DOUBLE_VAL(output,getVectorDoubleValueFnLeft(left,i) + getVectorDoubleValueFnRight(right,0));
} }
case TSDB_DATA_TYPE_UBIGINT: { }
DO_VECTOR_REMAINDER(left, numLeft, leftType, int8_t, right, numRight, rightType, uint64_t, output, order); }
break; void vectorSub(void *left, int32_t len1, int32_t _left_type, void *right, int32_t len2, int32_t _right_type, void *out, int32_t _ord) {
} int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : MAX(len1, len2) - 1;
case TSDB_DATA_TYPE_FLOAT: { int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1;
DO_VECTOR_REMAINDER(left, numLeft, leftType, int8_t, right, numRight, rightType, float, output, order); double *output=(double*)out;
break; _arithmetic_getVectorValueAddr_fn_t getVectorValueAddrFnLeft = getVectorValueAddrFn(_left_type);
} _arithmetic_getVectorValueAddr_fn_t getVectorValueAddrFnRight = getVectorValueAddrFn(_right_type);
case TSDB_DATA_TYPE_DOUBLE: { _arithmetic_getVectorDoubleValue_fn_t getVectorDoubleValueFnLeft = getVectorDoubleValueFn(_left_type);
DO_VECTOR_REMAINDER(left, numLeft, leftType, int8_t, right, numRight, rightType, double, output, order); _arithmetic_getVectorDoubleValue_fn_t getVectorDoubleValueFnRight = getVectorDoubleValueFn(_right_type);
break;
} if ((len1) == (len2)) {
default: for (; i < (len2) && i >= 0; i += step, output += 1) {
assert(0); if (isNull(getVectorValueAddrFnLeft(left,i), _left_type) || isNull(getVectorValueAddrFnRight(right,i), _right_type)) {
} SET_DOUBLE_NULL(output);
break; continue;
} }
case TSDB_DATA_TYPE_UTINYINT: { SET_DOUBLE_VAL(output,getVectorDoubleValueFnLeft(left,i) - getVectorDoubleValueFnRight(right,i));
switch (rightType) { }
case TSDB_DATA_TYPE_TINYINT: { } else if ((len1) == 1) {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint8_t, right, numRight, rightType, int8_t, output, order); for (; i >= 0 && i < (len2); i += step, output += 1) {
break; if (isNull(getVectorValueAddrFnLeft(left,0), _left_type) || isNull(getVectorValueAddrFnRight(right,i), _right_type)) {
} SET_DOUBLE_NULL(output);
case TSDB_DATA_TYPE_UTINYINT: { continue;
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint8_t, right, numRight, rightType, uint8_t, output, order); }
break; SET_DOUBLE_VAL(output,getVectorDoubleValueFnLeft(left,0) - getVectorDoubleValueFnRight(right,i));
} }
case TSDB_DATA_TYPE_SMALLINT: { } else if ((len2) == 1) {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint8_t, right, numRight, rightType, int16_t, output, order); for (; i >= 0 && i < (len1); i += step, output += 1) {
break; if (isNull(getVectorValueAddrFnLeft(left,i), _left_type) || isNull(getVectorValueAddrFnRight(right,0), _right_type)) {
} SET_DOUBLE_NULL(output);
case TSDB_DATA_TYPE_USMALLINT: { continue;
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint8_t, right, numRight, rightType, uint16_t, output, order); }
break; SET_DOUBLE_VAL(output,getVectorDoubleValueFnLeft(left,i) - getVectorDoubleValueFnRight(right,0));
} }
case TSDB_DATA_TYPE_INT: { }
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint8_t, right, numRight, rightType, int32_t, output, order); }
break; void vectorMultiply(void *left, int32_t len1, int32_t _left_type, void *right, int32_t len2, int32_t _right_type, void *out, int32_t _ord) {
} int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : MAX(len1, len2) - 1;
case TSDB_DATA_TYPE_UINT: { int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1;
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint8_t, right, numRight, rightType, uint32_t, output, order); double *output=(double*)out;
break; _arithmetic_getVectorValueAddr_fn_t getVectorValueAddrFnLeft = getVectorValueAddrFn(_left_type);
} _arithmetic_getVectorValueAddr_fn_t getVectorValueAddrFnRight = getVectorValueAddrFn(_right_type);
case TSDB_DATA_TYPE_BIGINT: { _arithmetic_getVectorDoubleValue_fn_t getVectorDoubleValueFnLeft = getVectorDoubleValueFn(_left_type);
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint8_t, right, numRight, rightType, int64_t, output, order); _arithmetic_getVectorDoubleValue_fn_t getVectorDoubleValueFnRight = getVectorDoubleValueFn(_right_type);
break;
} if ((len1) == (len2)) {
case TSDB_DATA_TYPE_UBIGINT: { for (; i < (len2) && i >= 0; i += step, output += 1) {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint8_t, right, numRight, rightType, uint64_t, output, order); if (isNull(getVectorValueAddrFnLeft(left,i), _left_type) || isNull(getVectorValueAddrFnRight(right,i), _right_type)) {
break; SET_DOUBLE_NULL(output);
} continue;
case TSDB_DATA_TYPE_FLOAT: { }
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint8_t, right, numRight, rightType, float, output, order); SET_DOUBLE_VAL(output,getVectorDoubleValueFnLeft(left,i) * getVectorDoubleValueFnRight(right,i));
break; }
} } else if ((len1) == 1) {
case TSDB_DATA_TYPE_DOUBLE: { for (; i >= 0 && i < (len2); i += step, output += 1) {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint8_t, right, numRight, rightType, double, output, order); if (isNull(getVectorValueAddrFnLeft(left,0), _left_type) || isNull(getVectorValueAddrFnRight(right,i), _right_type)) {
break; SET_DOUBLE_NULL(output);
} continue;
default: }
assert(0); SET_DOUBLE_VAL(output,getVectorDoubleValueFnLeft(left,0) * getVectorDoubleValueFnRight(right,i));
} }
break; } else if ((len2) == 1) {
} for (; i >= 0 && i < (len1); i += step, output += 1) {
case TSDB_DATA_TYPE_SMALLINT: { if (isNull(getVectorValueAddrFnLeft(left,i), _left_type) || isNull(getVectorValueAddrFnRight(right,0), _right_type)) {
switch (rightType) { SET_DOUBLE_NULL(output);
case TSDB_DATA_TYPE_TINYINT: { continue;
DO_VECTOR_REMAINDER(left, numLeft, leftType, int16_t, right, numRight, rightType, int8_t, output, order); }
break; SET_DOUBLE_VAL(output,getVectorDoubleValueFnLeft(left,i) * getVectorDoubleValueFnRight(right,0));
} }
case TSDB_DATA_TYPE_UTINYINT: { }
DO_VECTOR_REMAINDER(left, numLeft, leftType, int16_t, right, numRight, rightType, uint8_t, output, order); }
break; void vectorDivide(void *left, int32_t len1, int32_t _left_type, void *right, int32_t len2, int32_t _right_type, void *out, int32_t _ord) {
} int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : MAX(len1, len2) - 1;
case TSDB_DATA_TYPE_SMALLINT: { int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1;
DO_VECTOR_REMAINDER(left, numLeft, leftType, int16_t, right, numRight, rightType, int16_t, output, order); double *output=(double*)out;
break; _arithmetic_getVectorValueAddr_fn_t getVectorValueAddrFnLeft = getVectorValueAddrFn(_left_type);
} _arithmetic_getVectorValueAddr_fn_t getVectorValueAddrFnRight = getVectorValueAddrFn(_right_type);
case TSDB_DATA_TYPE_USMALLINT: { _arithmetic_getVectorDoubleValue_fn_t getVectorDoubleValueFnLeft = getVectorDoubleValueFn(_left_type);
DO_VECTOR_REMAINDER(left, numLeft, leftType, int16_t, right, numRight, rightType, uint16_t, output, order); _arithmetic_getVectorDoubleValue_fn_t getVectorDoubleValueFnRight = getVectorDoubleValueFn(_right_type);
break;
} if ((len1) == (len2)) {
case TSDB_DATA_TYPE_INT: { for (; i < (len2) && i >= 0; i += step, output += 1) {
DO_VECTOR_REMAINDER(left, numLeft, leftType, int16_t, right, numRight, rightType, int32_t, output, order); if (isNull(getVectorValueAddrFnLeft(left,i), _left_type) || isNull(getVectorValueAddrFnRight(right,i), _right_type)) {
break; SET_DOUBLE_NULL(output);
} continue;
case TSDB_DATA_TYPE_UINT: { }
DO_VECTOR_REMAINDER(left, numLeft, leftType, int16_t, right, numRight, rightType, uint32_t, output, order); double v, u = 0.0;
break; GET_TYPED_DATA(v, double, _right_type, getVectorValueAddrFnRight(right,i));
} if (getComparFunc(TSDB_DATA_TYPE_DOUBLE, 0)(&v, &u) == 0) {
case TSDB_DATA_TYPE_BIGINT: { SET_DOUBLE_NULL(output);
DO_VECTOR_REMAINDER(left, numLeft, leftType, int16_t, right, numRight, rightType, int64_t, output, order); continue;
break; }
} SET_DOUBLE_VAL(output,getVectorDoubleValueFnLeft(left,i) /getVectorDoubleValueFnRight(right,i));
case TSDB_DATA_TYPE_UBIGINT: { }
DO_VECTOR_REMAINDER(left, numLeft, leftType, int16_t, right, numRight, rightType, uint64_t, output, order); } else if ((len1) == 1) {
break; for (; i >= 0 && i < (len2); i += step, output += 1) {
} if (isNull(getVectorValueAddrFnLeft(left,0), _left_type) || isNull(getVectorValueAddrFnRight(right,i), _right_type)) {
case TSDB_DATA_TYPE_FLOAT: { SET_DOUBLE_NULL(output);
DO_VECTOR_REMAINDER(left, numLeft, leftType, int16_t, right, numRight, rightType, float, output, order); continue;
break; }
} double v, u = 0.0;
case TSDB_DATA_TYPE_DOUBLE: { GET_TYPED_DATA(v, double, _right_type, getVectorValueAddrFnRight(right,i));
DO_VECTOR_REMAINDER(left, numLeft, leftType, int16_t, right, numRight, rightType, double, output, order); if (getComparFunc(TSDB_DATA_TYPE_DOUBLE, 0)(&v, &u) == 0) {
break; SET_DOUBLE_NULL(output);
} continue;
default: }
assert(0); SET_DOUBLE_VAL(output,getVectorDoubleValueFnLeft(left,0) /getVectorDoubleValueFnRight(right,i));
} }
break; } else if ((len2) == 1) {
} for (; i >= 0 && i < (len1); i += step, output += 1) {
case TSDB_DATA_TYPE_USMALLINT: { if (isNull(getVectorValueAddrFnLeft(left,i), _left_type) || isNull(getVectorValueAddrFnRight(right,0), _right_type)) {
switch (rightType) { SET_DOUBLE_NULL(output);
case TSDB_DATA_TYPE_TINYINT: { continue;
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint16_t, right, numRight, rightType, int8_t, output, order); }
break; double v, u = 0.0;
} GET_TYPED_DATA(v, double, _right_type, getVectorValueAddrFnRight(right,0));
case TSDB_DATA_TYPE_UTINYINT: { if (getComparFunc(TSDB_DATA_TYPE_DOUBLE, 0)(&v, &u) == 0) {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint16_t, right, numRight, rightType, uint8_t, output, order); SET_DOUBLE_NULL(output);
break; continue;
} }
case TSDB_DATA_TYPE_SMALLINT: { SET_DOUBLE_VAL(output,getVectorDoubleValueFnLeft(left,i) /getVectorDoubleValueFnRight(right,0));
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint16_t, right, numRight, rightType, int16_t, output, order); }
break; }
} }
case TSDB_DATA_TYPE_USMALLINT: { void vectorRemainder(void *left, int32_t len1, int32_t _left_type, void *right, int32_t len2, int32_t _right_type, void *out, int32_t _ord) {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint16_t, right, numRight, rightType, uint16_t, output, order); int32_t i = (_ord == TSDB_ORDER_ASC) ? 0 : MAX(len1, len2) - 1;
break; int32_t step = (_ord == TSDB_ORDER_ASC) ? 1 : -1;
} double *output=(double*)out;
case TSDB_DATA_TYPE_INT: { _arithmetic_getVectorValueAddr_fn_t getVectorValueAddrFnLeft = getVectorValueAddrFn(_left_type);
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint16_t, right, numRight, rightType, int32_t, output, order); _arithmetic_getVectorValueAddr_fn_t getVectorValueAddrFnRight = getVectorValueAddrFn(_right_type);
break; _arithmetic_getVectorDoubleValue_fn_t getVectorDoubleValueFnLeft = getVectorDoubleValueFn(_left_type);
} _arithmetic_getVectorDoubleValue_fn_t getVectorDoubleValueFnRight = getVectorDoubleValueFn(_right_type);
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint16_t, right, numRight, rightType, uint32_t, output, order); if (len1 == (len2)) {
break; for (; i >= 0 && i < (len2); i += step, output += 1) {
} if (isNull(getVectorValueAddrFnLeft(left,i), _left_type) || isNull(getVectorValueAddrFnRight(right,i), _right_type)) {
case TSDB_DATA_TYPE_BIGINT: { SET_DOUBLE_NULL(output);
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint16_t, right, numRight, rightType, int64_t, output, order); continue;
break; }
} double v, u = 0.0;
case TSDB_DATA_TYPE_UBIGINT: { GET_TYPED_DATA(v, double, _right_type, getVectorValueAddrFnRight(right,i));
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint16_t, right, numRight, rightType, uint64_t, output, order); if (getComparFunc(TSDB_DATA_TYPE_DOUBLE, 0)(&v, &u) == 0) {
break; SET_DOUBLE_NULL(output);
} continue;
case TSDB_DATA_TYPE_FLOAT: { }
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint16_t, right, numRight, rightType, float, output, order); SET_DOUBLE_VAL(output,getVectorDoubleValueFnLeft(left,i) - ((int64_t)(getVectorDoubleValueFnLeft(left,i) / getVectorDoubleValueFnRight(right,i))) * getVectorDoubleValueFnRight(right,i));
break; }
} } else if (len1 == 1) {
case TSDB_DATA_TYPE_DOUBLE: { for (; i >= 0 && i < (len2); i += step, output += 1) {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint16_t, right, numRight, rightType, double, output, order); if (isNull(getVectorValueAddrFnLeft(left,0), _left_type) || isNull(getVectorValueAddrFnRight(right,i), _right_type)) {
break; SET_DOUBLE_NULL(output);
} continue;
default: }
assert(0); double v, u = 0.0;
} GET_TYPED_DATA(v, double, _right_type, getVectorValueAddrFnRight(right,i));
break; if (getComparFunc(TSDB_DATA_TYPE_DOUBLE, 0)(&v, &u) == 0) {
} SET_DOUBLE_NULL(output);
case TSDB_DATA_TYPE_INT: { continue;
switch (rightType) { }
case TSDB_DATA_TYPE_TINYINT: { SET_DOUBLE_VAL(output,getVectorDoubleValueFnLeft(left,0) - ((int64_t)(getVectorDoubleValueFnLeft(left,0) / getVectorDoubleValueFnRight(right,i))) * getVectorDoubleValueFnRight(right,i));
DO_VECTOR_REMAINDER(left, numLeft, leftType, int32_t, right, numRight, rightType, int8_t, output, order); }
break; } else if ((len2) == 1) {
} for (; i >= 0 && i < len1; i += step, output += 1) {
case TSDB_DATA_TYPE_UTINYINT: { if (isNull(getVectorValueAddrFnLeft(left,i), _left_type) || isNull(getVectorValueAddrFnRight(right,0), _right_type)) {
DO_VECTOR_REMAINDER(left, numLeft, leftType, int32_t, right, numRight, rightType, uint8_t, output, order); SET_DOUBLE_NULL(output);
break; continue;
} }
case TSDB_DATA_TYPE_SMALLINT: { double v, u = 0.0;
DO_VECTOR_REMAINDER(left, numLeft, leftType, int32_t, right, numRight, rightType, int16_t, output, order); GET_TYPED_DATA(v, double, _right_type, getVectorValueAddrFnRight(right,0));
break; if (getComparFunc(TSDB_DATA_TYPE_DOUBLE, 0)(&v, &u) == 0) {
} SET_DOUBLE_NULL(output);
case TSDB_DATA_TYPE_USMALLINT: { continue;
DO_VECTOR_REMAINDER(left, numLeft, leftType, int32_t, right, numRight, rightType, uint16_t, output, order); }
break; SET_DOUBLE_VAL(output,getVectorDoubleValueFnLeft(left,i) - ((int64_t)(getVectorDoubleValueFnLeft(left,i) / getVectorDoubleValueFnRight(right,0))) * getVectorDoubleValueFnRight(right,0));
} }
case TSDB_DATA_TYPE_INT: { }
DO_VECTOR_REMAINDER(left, numLeft, leftType, int32_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, int32_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, int32_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, int32_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, int32_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, int32_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_UINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint32_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint32_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint32_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint32_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint32_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint32_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint32_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint32_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint32_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint32_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_BIGINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, int64_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, int64_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, int64_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, int64_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, int64_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, int64_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, int64_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, int64_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, int64_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, int64_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint64_t, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint64_t, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint64_t, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint64_t, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint64_t, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint64_t, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint64_t, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint64_t, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint64_t, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, uint64_t, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_FLOAT: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, float, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, float, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, float, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, float, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, float, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, float, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, float, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, float, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, float, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, float, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
switch (rightType) {
case TSDB_DATA_TYPE_TINYINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, double, right, numRight, rightType, int8_t, output, order);
break;
}
case TSDB_DATA_TYPE_UTINYINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, double, right, numRight, rightType, uint8_t, output, order);
break;
}
case TSDB_DATA_TYPE_SMALLINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, double, right, numRight, rightType, int16_t, output, order);
break;
}
case TSDB_DATA_TYPE_USMALLINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, double, right, numRight, rightType, uint16_t, output, order);
break;
}
case TSDB_DATA_TYPE_INT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, double, right, numRight, rightType, int32_t, output, order);
break;
}
case TSDB_DATA_TYPE_UINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, double, right, numRight, rightType, uint32_t, output, order);
break;
}
case TSDB_DATA_TYPE_BIGINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, double, right, numRight, rightType, int64_t, output, order);
break;
}
case TSDB_DATA_TYPE_UBIGINT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, double, right, numRight, rightType, uint64_t, output, order);
break;
}
case TSDB_DATA_TYPE_FLOAT: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, double, right, numRight, rightType, float, output, order);
break;
}
case TSDB_DATA_TYPE_DOUBLE: {
DO_VECTOR_REMAINDER(left, numLeft, leftType, double, right, numRight, rightType, double, output, order);
break;
}
default:
assert(0);
}
break;
}
default:;
}
} }
_arithmetic_operator_fn_t getArithmeticOperatorFn(int32_t arithmeticOptr) { _arithmetic_operator_fn_t getArithmeticOperatorFn(int32_t arithmeticOptr) {
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或