Skip to content

T
TDengine

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

通知 1192
Star 22018
Fork 4786
T
TDengine
提交 a34cf50a 编写于 作者: H Hongze Cheng
浏览文件
操作

refact more code

上级 36d14814
隐藏空白更改
内联 并排
Showing with 298 addition and 189 deletion
source/common/src/tdataformat.c
浏览文件 @ a34cf50a
...@@ -1135,288 +1135,397 @@ static FORCE_INLINE int32_t tColDataPutValue(SColData *pColData, SColVal *pColVa ...@@ -1135,288 +1135,397 @@ static FORCE_INLINE int32_t tColDataPutValue(SColData *pColData, SColVal *pColVa
_exit: _exit:
return code; return code;
} }
static FORCE_INLINE int32_t tColDataAppendValue0(SColData *pColData, SColVal *pColVal) { // 0 static FORCE_INLINE int32_t tColDataAppendValue00(SColData *pColData, SColVal *pColVal) {
int32_t code = 0;
pColData->flag = HAS_VALUE;
code = tColDataPutValue(pColData, pColVal);
if (code) return code;
pColData->nVal++;
return code;
}
static FORCE_INLINE int32_t tColDataAppendValue01(SColData *pColData, SColVal *pColVal) {
int32_t code = 0;
pColData->flag = HAS_NONE;
pColData->nVal++;
return code;
}
static FORCE_INLINE int32_t tColDataAppendValue02(SColData *pColData, SColVal *pColVal) {
int32_t code = 0;
pColData->flag = HAS_NULL;
pColData->nVal++;
return code;
}
static FORCE_INLINE int32_t tColDataAppendValue10(SColData *pColData, SColVal *pColVal) {
int32_t code = 0; int32_t code = 0;
if (COL_VAL_IS_NONE(pColVal)) { int32_t nBit = BIT1_SIZE(pColData->nVal + 1);
pColData->flag = HAS_NONE; code = tRealloc(&pColData->pBitMap, nBit);
} else if (COL_VAL_IS_NULL(pColVal)) { if (code) return code;
pColData->flag = HAS_NULL;
} else { memset(pColData->pBitMap, 0, nBit);
pColData->flag = HAS_VALUE; SET_BIT1(pColData->pBitMap, pColData->nVal, 1);
code = tColDataPutValue(pColData, pColVal);
if (code) goto _exit; pColData->flag |= HAS_VALUE;
if (pColData->nVal) {
if (IS_VAR_DATA_TYPE(pColData->type)) {
int32_t nOffset = sizeof(int32_t) * pColData->nVal;
code = tRealloc((uint8_t **)(&pColData->aOffset), nOffset);
if (code) return code;
memset(pColData->aOffset, 0, nOffset);
} else {
pColData->nData = tDataTypes[pColData->type].bytes * pColData->nVal;
code = tRealloc(&pColData->pData, pColData->nData);
if (code) return code;
memset(pColData->pData, 0, pColData->nData);
}
} }
code = tColDataPutValue(pColData, pColVal);
if (code) return code;
pColData->nVal++; pColData->nVal++;
_exit:
return code; return code;
} }
static FORCE_INLINE int32_t tColDataAppendValue1(SColData *pColData, SColVal *pColVal) { // HAS_NONE static FORCE_INLINE int32_t tColDataAppendValue11(SColData *pColData, SColVal *pColVal) {
int32_t code = 0;
pColData->nVal++;
return code;
}
static FORCE_INLINE int32_t tColDataAppendValue12(SColData *pColData, SColVal *pColVal) {
int32_t code = 0; int32_t code = 0;
if (!COL_VAL_IS_NONE(pColVal)) { int32_t nBit = BIT1_SIZE(pColData->nVal + 1);
int32_t nBit = BIT1_SIZE(pColData->nVal + 1); code = tRealloc(&pColData->pBitMap, nBit);
if (code) return code;
code = tRealloc(&pColData->pBitMap, nBit); memset(pColData->pBitMap, 0, nBit);
if (code) goto _exit; SET_BIT1(pColData->pBitMap, pColData->nVal, 1);
memset(pColData->pBitMap, 0, nBit); pColData->flag |= HAS_NULL;
SET_BIT1(pColData->pBitMap, pColData->nVal, 1); pColData->nVal++;
if (COL_VAL_IS_NULL(pColVal)) { return code;
pColData->flag |= HAS_NULL; }
} else { static FORCE_INLINE int32_t tColDataAppendValue20(SColData *pColData, SColVal *pColVal) {
pColData->flag |= HAS_VALUE; int32_t code = 0;
if (pColData->nVal) {
if (IS_VAR_DATA_TYPE(pColData->type)) {
int32_t nOffset = sizeof(int32_t) * pColData->nVal;
code = tRealloc((uint8_t **)(&pColData->aOffset), nOffset);
if (code) goto _exit;
memset(pColData->aOffset, 0, nOffset);
} else {
pColData->nData = tDataTypes[pColData->type].bytes * pColData->nVal;
code = tRealloc(&pColData->pData, pColData->nData);
if (code) goto _exit;
memset(pColData->pData, 0, pColData->nData);
}
}
code = tColDataPutValue(pColData, pColVal); int32_t nBit = BIT1_SIZE(pColData->nVal + 1);
if (code) goto _exit; code = tRealloc(&pColData->pBitMap, nBit);
if (code) return code;
memset(pColData->pBitMap, 0, nBit);
SET_BIT1(pColData->pBitMap, pColData->nVal, 1);
pColData->flag |= HAS_VALUE;
if (pColData->nVal) {
if (IS_VAR_DATA_TYPE(pColData->type)) {
int32_t nOffset = sizeof(int32_t) * pColData->nVal;
code = tRealloc((uint8_t **)(&pColData->aOffset), nOffset);
if (code) return code;
memset(pColData->aOffset, 0, nOffset);
} else {
pColData->nData = tDataTypes[pColData->type].bytes * pColData->nVal;
code = tRealloc(&pColData->pData, pColData->nData);
if (code) return code;
memset(pColData->pData, 0, pColData->nData);
} }
} }
code = tColDataPutValue(pColData, pColVal);
if (code) return code;
pColData->nVal++; pColData->nVal++;
_exit:
return code; return code;
} }
static FORCE_INLINE int32_t tColDataAppendValue2(SColData *pColData, SColVal *pColVal) { // HAS_NULL static FORCE_INLINE int32_t tColDataAppendValue21(SColData *pColData, SColVal *pColVal) {
int32_t code = 0; int32_t code = 0;
if (!COL_VAL_IS_NULL(pColVal)) { int32_t nBit = BIT1_SIZE(pColData->nVal + 1);
int32_t nBit = BIT1_SIZE(pColData->nVal + 1); code = tRealloc(&pColData->pBitMap, nBit);
code = tRealloc(&pColData->pBitMap, nBit); if (code) return code;
if (code) goto _exit;
if (COL_VAL_IS_NONE(pColVal)) { memset(pColData->pBitMap, 255, nBit);
pColData->flag |= HAS_NONE; SET_BIT1(pColData->pBitMap, pColData->nVal, 0);
memset(pColData->pBitMap, 255, nBit); pColData->flag |= HAS_NONE;
SET_BIT1(pColData->pBitMap, pColData->nVal, 0); pColData->nVal++;
} else {
pColData->flag |= HAS_VALUE;
memset(pColData->pBitMap, 0, nBit); return code;
SET_BIT1(pColData->pBitMap, pColData->nVal, 1); }
static FORCE_INLINE int32_t tColDataAppendValue22(SColData *pColData, SColVal *pColVal) {
int32_t code = 0;
pColData->nVal++;
return code;
}
static FORCE_INLINE int32_t tColDataAppendValue30(SColData *pColData, SColVal *pColVal) {
int32_t code = 0;
if (pColData->nVal) { pColData->flag |= HAS_VALUE;
if (IS_VAR_DATA_TYPE(pColData->type)) {
int32_t nOffset = sizeof(int32_t) * pColData->nVal;
code = tRealloc((uint8_t **)(&pColData->aOffset), nOffset);
if (code) goto _exit;
memset(pColData->aOffset, 0, nOffset);
} else {
pColData->nData = tDataTypes[pColData->type].bytes * pColData->nVal;
code = tRealloc(&pColData->pData, pColData->nData);
if (code) goto _exit;
memset(pColData->pData, 0, pColData->nData);
}
}
code = tColDataPutValue(pColData, pColVal); uint8_t *pBitMap = NULL;
if (code) goto _exit; code = tRealloc(&pBitMap, BIT2_SIZE(pColData->nVal + 1));
if (code) return code;
for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
SET_BIT2(pBitMap, iVal, GET_BIT1(pColData->pBitMap, iVal));
}
SET_BIT2(pBitMap, pColData->nVal, 2);
tFree(pColData->pBitMap);
pColData->pBitMap = pBitMap;
if (pColData->nVal) {
if (IS_VAR_DATA_TYPE(pColData->type)) {
int32_t nOffset = sizeof(int32_t) * pColData->nVal;
code = tRealloc((uint8_t **)(&pColData->aOffset), nOffset);
if (code) return code;
memset(pColData->aOffset, 0, nOffset);
} else {
pColData->nData = tDataTypes[pColData->type].bytes * pColData->nVal;
code = tRealloc(&pColData->pData, pColData->nData);
if (code) return code;
memset(pColData->pData, 0, pColData->nData);
} }
} }
code = tColDataPutValue(pColData, pColVal);
if (code) return code;
pColData->nVal++; pColData->nVal++;
_exit:
return code; return code;
} }
static FORCE_INLINE int32_t tColDataAppendValue3(SColData *pColData, SColVal *pColVal) { // HAS_NULL|HAS_NONE static FORCE_INLINE int32_t tColDataAppendValue31(SColData *pColData, SColVal *pColVal) {
int32_t code = 0; int32_t code = 0;
if (COL_VAL_IS_NONE(pColVal)) { code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1));
code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1)); if (code) return code;
if (code) goto _exit;
SET_BIT1(pColData->pBitMap, pColData->nVal, 0); SET_BIT1(pColData->pBitMap, pColData->nVal, 0);
} else if (COL_VAL_IS_NULL(pColVal)) { pColData->nVal++;
code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1));
if (code) goto _exit;
SET_BIT1(pColData->pBitMap, pColData->nVal, 1); return code;
} else { }
pColData->flag |= HAS_VALUE; static FORCE_INLINE int32_t tColDataAppendValue32(SColData *pColData, SColVal *pColVal) {
int32_t code = 0;
uint8_t *pBitMap = NULL; code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1));
code = tRealloc(&pBitMap, BIT2_SIZE(pColData->nVal + 1)); if (code) return code;
if (code) goto _exit;
for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) { SET_BIT1(pColData->pBitMap, pColData->nVal, 1);
SET_BIT2(pBitMap, iVal, GET_BIT1(pColData->pBitMap, iVal)); pColData->nVal++;
}
SET_BIT2(pBitMap, pColData->nVal, 2);
tFree(pColData->pBitMap); return code;
pColData->pBitMap = pBitMap; }
static FORCE_INLINE int32_t tColDataAppendValue40(SColData *pColData, SColVal *pColVal) {
int32_t code = 0;
if (pColData->nVal) { code = tColDataPutValue(pColData, pColVal);
if (IS_VAR_DATA_TYPE(pColData->type)) { if (code) return code;
int32_t nOffset = sizeof(int32_t) * pColData->nVal; pColData->nVal++;
code = tRealloc((uint8_t **)(&pColData->aOffset), nOffset);
if (code) goto _exit; return code;
memset(pColData->aOffset, 0, nOffset); }
} else { static FORCE_INLINE int32_t tColDataAppendValue41(SColData *pColData, SColVal *pColVal) {
pColData->nData = tDataTypes[pColData->type].bytes * pColData->nVal; int32_t code = 0;
code = tRealloc(&pColData->pData, pColData->nData);
if (code) goto _exit; pColData->flag |= HAS_NONE;
memset(pColData->pData, 0, pColData->nData);
} int32_t nBit = BIT1_SIZE(pColData->nVal + 1);
} code = tRealloc(&pColData->pBitMap, nBit);
if (code) return code;
memset(pColData->pBitMap, 255, nBit);
SET_BIT1(pColData->pBitMap, pColData->nVal, 0);
code = tColDataPutValue(pColData, pColVal);
if (code) return code;
code = tColDataPutValue(pColData, pColVal);
if (code) goto _exit;
}
pColData->nVal++; pColData->nVal++;
_exit:
return code; return code;
} }
static FORCE_INLINE int32_t tColDataAppendValue4(SColData *pColData, SColVal *pColVal) { // HAS_VALUE static FORCE_INLINE int32_t tColDataAppendValue42(SColData *pColData, SColVal *pColVal) {
int32_t code = 0; int32_t code = 0;
if (!COL_VAL_IS_VALUE(pColVal)) { pColData->flag |= HAS_NULL;
if (COL_VAL_IS_NONE(pColVal)) {
pColData->flag |= HAS_NONE;
} else {
pColData->flag |= HAS_NULL;
}
int32_t nBit = BIT1_SIZE(pColData->nVal + 1); int32_t nBit = BIT1_SIZE(pColData->nVal + 1);
code = tRealloc(&pColData->pBitMap, nBit); code = tRealloc(&pColData->pBitMap, nBit);
if (code) goto _exit; if (code) return code;
memset(pColData->pBitMap, 255, nBit); memset(pColData->pBitMap, 255, nBit);
SET_BIT1(pColData->pBitMap, pColData->nVal, 0); SET_BIT1(pColData->pBitMap, pColData->nVal, 0);
code = tColDataPutValue(pColData, pColVal);
if (code) return code;
code = tColDataPutValue(pColData, pColVal);
if (code) goto _exit;
} else {
code = tColDataPutValue(pColData, pColVal);
if (code) goto _exit;
}
pColData->nVal++; pColData->nVal++;
_exit:
return code; return code;
} }
static FORCE_INLINE int32_t tColDataAppendValue5(SColData *pColData, SColVal *pColVal) { // HAS_VALUE|HAS_NONE static FORCE_INLINE int32_t tColDataAppendValue50(SColData *pColData, SColVal *pColVal) {
int32_t code = 0; int32_t code = 0;
if (COL_VAL_IS_NULL(pColVal)) { code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1));
pColData->flag |= HAS_NULL; if (code) return code;
uint8_t *pBitMap = NULL; SET_BIT1(pColData->pBitMap, pColData->nVal, 1);
code = tRealloc(&pBitMap, BIT2_SIZE(pColData->nVal + 1));
if (code) goto _exit;
for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) { code = tColDataPutValue(pColData, pColVal);
SET_BIT2(pBitMap, iVal, GET_BIT1(pColData->pBitMap, iVal) ? 2 : 0); if (code) return code;
}
SET_BIT2(pBitMap, pColData->nVal, 1);
tFree(pColData->pBitMap); pColData->nVal++;
pColData->pBitMap = pBitMap;
} else {
code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1));
if (code) goto _exit;
if (COL_VAL_IS_NONE(pColVal)) { return code;
SET_BIT1(pColData->pBitMap, pColData->nVal, 0); }
} else { static FORCE_INLINE int32_t tColDataAppendValue51(SColData *pColData, SColVal *pColVal) {
SET_BIT1(pColData->pBitMap, pColData->nVal, 1); int32_t code = 0;
}
code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1));
if (code) return code;
SET_BIT1(pColData->pBitMap, pColData->nVal, 0);
code = tColDataPutValue(pColData, pColVal);
if (code) return code;
pColData->nVal++;
return code;
}
static FORCE_INLINE int32_t tColDataAppendValue52(SColData *pColData, SColVal *pColVal) {
int32_t code = 0;
pColData->flag |= HAS_NULL;
uint8_t *pBitMap = NULL;
code = tRealloc(&pBitMap, BIT2_SIZE(pColData->nVal + 1));
if (code) return code;
for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
SET_BIT2(pBitMap, iVal, GET_BIT1(pColData->pBitMap, iVal) ? 2 : 0);
} }
SET_BIT2(pBitMap, pColData->nVal, 1);
tFree(pColData->pBitMap);
pColData->pBitMap = pBitMap;
code = tColDataPutValue(pColData, pColVal); code = tColDataPutValue(pColData, pColVal);
if (code) goto _exit; if (code) return code;
pColData->nVal++; pColData->nVal++;
_exit:
return code; return code;
} }
static FORCE_INLINE int32_t tColDataAppendValue6(SColData *pColData, SColVal *pColVal) { // HAS_VALUE|HAS_NULL static FORCE_INLINE int32_t tColDataAppendValue60(SColData *pColData, SColVal *pColVal) {
int32_t code = 0; int32_t code = 0;
if (COL_VAL_IS_NONE(pColVal)) { code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1));
pColData->flag |= HAS_NONE; if (code) return code;
SET_BIT1(pColData->pBitMap, pColData->nVal, 1);
uint8_t *pBitMap = NULL; code = tColDataPutValue(pColData, pColVal);
code = tRealloc(&pBitMap, BIT2_SIZE(pColData->nVal + 1)); if (code) return code;
if (code) goto _exit;
for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) { pColData->nVal++;
SET_BIT2(pBitMap, iVal, GET_BIT1(pColData->pBitMap, iVal) ? 2 : 1);
}
SET_BIT2(pBitMap, pColData->nVal, 0);
tFree(pColData->pBitMap); return code;
pColData->pBitMap = pBitMap; }
} else { static FORCE_INLINE int32_t tColDataAppendValue61(SColData *pColData, SColVal *pColVal) {
code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1)); int32_t code = 0;
if (code) goto _exit;
if (COL_VAL_IS_NULL(pColVal)) { pColData->flag |= HAS_NONE;
SET_BIT1(pColData->pBitMap, pColData->nVal, 0);
} else { uint8_t *pBitMap = NULL;
SET_BIT1(pColData->pBitMap, pColData->nVal, 1); code = tRealloc(&pBitMap, BIT2_SIZE(pColData->nVal + 1));
} if (code) return code;
for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
SET_BIT2(pBitMap, iVal, GET_BIT1(pColData->pBitMap, iVal) ? 2 : 1);
} }
SET_BIT2(pBitMap, pColData->nVal, 0);
tFree(pColData->pBitMap);
pColData->pBitMap = pBitMap;
code = tColDataPutValue(pColData, pColVal); code = tColDataPutValue(pColData, pColVal);
if (code) goto _exit; if (code) return code;
pColData->nVal++; pColData->nVal++;
_exit:
return code; return code;
} }
static FORCE_INLINE int32_t tColDataAppendValue7(SColData *pColData, static FORCE_INLINE int32_t tColDataAppendValue62(SColData *pColData, SColVal *pColVal) {
SColVal *pColVal) { // HAS_VALUE|HAS_NULL|HAS_NONE int32_t code = 0;
code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1));
if (code) return code;
SET_BIT1(pColData->pBitMap, pColData->nVal, 0);
code = tColDataPutValue(pColData, pColVal);
if (code) return code;
pColData->nVal++;
return code;
}
static FORCE_INLINE int32_t tColDataAppendValue70(SColData *pColData, SColVal *pColVal) {
int32_t code = 0; int32_t code = 0;
code = tRealloc(&pColData->pBitMap, BIT2_SIZE(pColData->nVal + 1)); code = tRealloc(&pColData->pBitMap, BIT2_SIZE(pColData->nVal + 1));
if (code) goto _exit; if (code) return code;
SET_BIT2(pColData->pBitMap, pColData->nVal, 2);
if (COL_VAL_IS_NONE(pColVal)) {
SET_BIT2(pColData->pBitMap, pColData->nVal, 0);
} else if (COL_VAL_IS_NULL(pColVal)) {
SET_BIT2(pColData->pBitMap, pColData->nVal, 1);
} else {
SET_BIT2(pColData->pBitMap, pColData->nVal, 2);
}
code = tColDataPutValue(pColData, pColVal); code = tColDataPutValue(pColData, pColVal);
if (code) goto _exit; if (code) return code;
pColData->nVal++;
return code;
}
static FORCE_INLINE int32_t tColDataAppendValue71(SColData *pColData, SColVal *pColVal) {
int32_t code = 0;
code = tRealloc(&pColData->pBitMap, BIT2_SIZE(pColData->nVal + 1));
if (code) return code;
SET_BIT2(pColData->pBitMap, pColData->nVal, 0);
code = tColDataPutValue(pColData, pColVal);
if (code) return code;
pColData->nVal++;
return code;
}
static FORCE_INLINE int32_t tColDataAppendValue72(SColData *pColData, SColVal *pColVal) {
int32_t code = 0;
code = tRealloc(&pColData->pBitMap, BIT2_SIZE(pColData->nVal + 1));
if (code) return code;
SET_BIT2(pColData->pBitMap, pColData->nVal, 1);
code = tColDataPutValue(pColData, pColVal);
if (code) return code;
pColData->nVal++; pColData->nVal++;
_exit:
return code; return code;
} }
static int32_t (*tColDataAppendValueImpl[])(SColData *pColData, SColVal *pColVal) = { static int32_t (*tColDataAppendValueImpl[8][3])(SColData *pColData, SColVal *pColVal) = {
tColDataAppendValue0, // 0 {tColDataAppendValue00, tColDataAppendValue01, tColDataAppendValue02}, // 0
tColDataAppendValue1, // HAS_NONE {tColDataAppendValue10, tColDataAppendValue11, tColDataAppendValue12}, // HAS_NONE
tColDataAppendValue2, // HAS_NULL {tColDataAppendValue20, tColDataAppendValue21, tColDataAppendValue22}, // HAS_NULL
tColDataAppendValue3, // HAS_NULL|HAS_NONE {tColDataAppendValue30, tColDataAppendValue31, tColDataAppendValue32}, // HAS_NULL|HAS_NONE
tColDataAppendValue4, // HAS_VALUE {tColDataAppendValue40, tColDataAppendValue41, tColDataAppendValue42}, // HAS_VALUE
tColDataAppendValue5, // HAS_VALUE|HAS_NONE {tColDataAppendValue50, tColDataAppendValue51, tColDataAppendValue52}, // HAS_VALUE|HAS_NONE
tColDataAppendValue6, // HAS_VALUE|HAS_NULL {tColDataAppendValue60, tColDataAppendValue61, tColDataAppendValue62}, // HAS_VALUE|HAS_NULL
tColDataAppendValue7 // HAS_VALUE|HAS_NULL|HAS_NONE {tColDataAppendValue70, tColDataAppendValue71, tColDataAppendValue72}, // HAS_VALUE|HAS_NULL|HAS_NONE
}; };
int32_t tColDataAppendValue(SColData *pColData, SColVal *pColVal) { int32_t tColDataAppendValue(SColData *pColData, SColVal *pColVal) {
ASSERT(pColData->cid == pColVal->cid && pColData->type == pColVal->type); ASSERT(pColData->cid == pColVal->cid && pColData->type == pColVal->type);
return tColDataAppendValueImpl[pColData->flag](pColData, pColVal); return tColDataAppendValueImpl[pColData->flag][pColVal->flag](pColData, pColVal);
} }
static FORCE_INLINE void tColDataGetValue1(SColData *pColData, int32_t iVal, SColVal *pColVal) { // HAS_NONE static FORCE_INLINE void tColDataGetValue1(SColData *pColData, int32_t iVal, SColVal *pColVal) { // HAS_NONE
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或