refact more code

source/common/src/tdataformat.c

@@ -1135,124 +1135,138 @@ static FORCE_INLINE int32_t tColDataPutValue(SColData *pColData, SColVal *pColVa
 _exit:
   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;
-
-  if (COL_VAL_IS_NONE(pColVal)) {
-    pColData->flag = HAS_NONE;
-  } else if (COL_VAL_IS_NULL(pColVal)) {
-    pColData->flag = HAS_NULL;
-  } else {
   pColData->flag = HAS_VALUE;
   code = tColDataPutValue(pColData, pColVal);
-    if (code) goto _exit;
-  }
+  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++;
-
-_exit:
   return code;
 }
-static FORCE_INLINE int32_t tColDataAppendValue1(SColData *pColData, SColVal *pColVal) {  // HAS_NONE
+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;
 
-  if (!COL_VAL_IS_NONE(pColVal)) {
   int32_t nBit = BIT1_SIZE(pColData->nVal + 1);
-
   code = tRealloc(&pColData->pBitMap, nBit);
-    if (code) goto _exit;
+  if (code) return code;
 
   memset(pColData->pBitMap, 0, nBit);
   SET_BIT1(pColData->pBitMap, pColData->nVal, 1);
 
-    if (COL_VAL_IS_NULL(pColVal)) {
-      pColData->flag |= HAS_NULL;
-    } else {
   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) goto _exit;
+      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) goto _exit;
+      if (code) return code;
       memset(pColData->pData, 0, pColData->nData);
     }
   }
 
   code = tColDataPutValue(pColData, pColVal);
-      if (code) goto _exit;
-    }
-  }
+  if (code) return code;
   pColData->nVal++;
 
-_exit:
   return code;
 }
-static FORCE_INLINE int32_t tColDataAppendValue2(SColData *pColData, SColVal *pColVal) {  // HAS_NULL
+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;
 
-  if (!COL_VAL_IS_NULL(pColVal)) {
   int32_t nBit = BIT1_SIZE(pColData->nVal + 1);
   code = tRealloc(&pColData->pBitMap, nBit);
-    if (code) goto _exit;
+  if (code) return code;
 
-    if (COL_VAL_IS_NONE(pColVal)) {
-      pColData->flag |= HAS_NONE;
+  memset(pColData->pBitMap, 0, nBit);
+  SET_BIT1(pColData->pBitMap, pColData->nVal, 1);
 
-      memset(pColData->pBitMap, 255, nBit);
-      SET_BIT1(pColData->pBitMap, pColData->nVal, 0);
-    } else {
-      pColData->flag |= HAS_VALUE;
+  pColData->flag |= HAS_NULL;
+  pColData->nVal++;
+
+  return code;
+}
+static FORCE_INLINE int32_t tColDataAppendValue20(SColData *pColData, SColVal *pColVal) {
+  int32_t code = 0;
+
+  int32_t nBit = BIT1_SIZE(pColData->nVal + 1);
+  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) goto _exit;
+      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) goto _exit;
+      if (code) return code;
       memset(pColData->pData, 0, pColData->nData);
     }
   }
 
   code = tColDataPutValue(pColData, pColVal);
-      if (code) goto _exit;
-    }
-  }
+  if (code) return code;
   pColData->nVal++;
 
-_exit:
   return code;
 }
-static FORCE_INLINE int32_t tColDataAppendValue3(SColData *pColData, SColVal *pColVal) {  // HAS_NULL|HAS_NONE
+static FORCE_INLINE int32_t tColDataAppendValue21(SColData *pColData, SColVal *pColVal) {
   int32_t code = 0;
 
-  if (COL_VAL_IS_NONE(pColVal)) {
-    code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1));
-    if (code) goto _exit;
+  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);
-  } else if (COL_VAL_IS_NULL(pColVal)) {
-    code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1));
-    if (code) goto _exit;
 
-    SET_BIT1(pColData->pBitMap, pColData->nVal, 1);
-  } else {
+  pColData->flag |= HAS_NONE;
+  pColData->nVal++;
+
+  return code;
+}
+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;
+
   pColData->flag |= HAS_VALUE;
 
   uint8_t *pBitMap = NULL;
   code = tRealloc(&pBitMap, BIT2_SIZE(pColData->nVal + 1));
-    if (code) goto _exit;
+  if (code) return code;
 
   for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
     SET_BIT2(pBitMap, iVal, GET_BIT1(pColData->pBitMap, iVal));
@@ -1266,61 +1280,129 @@ static FORCE_INLINE int32_t tColDataAppendValue3(SColData *pColData, SColVal *pC
     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;
+      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) goto _exit;
+      if (code) return code;
       memset(pColData->pData, 0, pColData->nData);
     }
   }
 
   code = tColDataPutValue(pColData, pColVal);
-    if (code) goto _exit;
-  }
+  if (code) return code;
   pColData->nVal++;
 
-_exit:
   return code;
 }
-static FORCE_INLINE int32_t tColDataAppendValue4(SColData *pColData, SColVal *pColVal) {  // HAS_VALUE
+static FORCE_INLINE int32_t tColDataAppendValue31(SColData *pColData, SColVal *pColVal) {
+  int32_t code = 0;
+
+  code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1));
+  if (code) return code;
+
+  SET_BIT1(pColData->pBitMap, pColData->nVal, 0);
+  pColData->nVal++;
+
+  return code;
+}
+static FORCE_INLINE int32_t tColDataAppendValue32(SColData *pColData, SColVal *pColVal) {
+  int32_t code = 0;
+
+  code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1));
+  if (code) return code;
+
+  SET_BIT1(pColData->pBitMap, pColData->nVal, 1);
+  pColData->nVal++;
+
+  return code;
+}
+static FORCE_INLINE int32_t tColDataAppendValue40(SColData *pColData, SColVal *pColVal) {
+  int32_t code = 0;
+
+  code = tColDataPutValue(pColData, pColVal);
+  if (code) return code;
+  pColData->nVal++;
+
+  return code;
+}
+static FORCE_INLINE int32_t tColDataAppendValue41(SColData *pColData, SColVal *pColVal) {
   int32_t code = 0;
 
-  if (!COL_VAL_IS_VALUE(pColVal)) {
-    if (COL_VAL_IS_NONE(pColVal)) {
   pColData->flag |= HAS_NONE;
-    } else {
+
+  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;
+
+  pColData->nVal++;
+
+  return code;
+}
+static FORCE_INLINE int32_t tColDataAppendValue42(SColData *pColData, SColVal *pColVal) {
+  int32_t code = 0;
+
   pColData->flag |= HAS_NULL;
-    }
 
   int32_t nBit = BIT1_SIZE(pColData->nVal + 1);
   code = tRealloc(&pColData->pBitMap, nBit);
-    if (code) goto _exit;
+  if (code) return code;
 
   memset(pColData->pBitMap, 255, nBit);
   SET_BIT1(pColData->pBitMap, pColData->nVal, 0);
 
   code = tColDataPutValue(pColData, pColVal);
-    if (code) goto _exit;
-  } else {
+  if (code) return code;
+
+  pColData->nVal++;
+
+  return code;
+}
+static FORCE_INLINE int32_t tColDataAppendValue50(SColData *pColData, SColVal *pColVal) {
+  int32_t code = 0;
+
+  code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1));
+  if (code) return code;
+
+  SET_BIT1(pColData->pBitMap, pColData->nVal, 1);
+
   code = tColDataPutValue(pColData, pColVal);
-    if (code) goto _exit;
-  }
+  if (code) return code;
+
+  pColData->nVal++;
+
+  return code;
+}
+static FORCE_INLINE int32_t tColDataAppendValue51(SColData *pColData, SColVal *pColVal) {
+  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++;
 
-_exit:
   return code;
 }
-static FORCE_INLINE int32_t tColDataAppendValue5(SColData *pColData, SColVal *pColVal) {  // HAS_VALUE|HAS_NONE
+static FORCE_INLINE int32_t tColDataAppendValue52(SColData *pColData, SColVal *pColVal) {
   int32_t code = 0;
 
-  if (COL_VAL_IS_NULL(pColVal)) {
   pColData->flag |= HAS_NULL;
 
   uint8_t *pBitMap = NULL;
   code = tRealloc(&pBitMap, BIT2_SIZE(pColData->nVal + 1));
-    if (code) goto _exit;
+  if (code) return code;
 
   for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
     SET_BIT2(pBitMap, iVal, GET_BIT1(pColData->pBitMap, iVal) ? 2 : 0);
@@ -1329,33 +1411,36 @@ static FORCE_INLINE int32_t tColDataAppendValue5(SColData *pColData, SColVal *pC
 
   tFree(pColData->pBitMap);
   pColData->pBitMap = pBitMap;
-  } else {
-    code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1));
-    if (code) goto _exit;
 
-    if (COL_VAL_IS_NONE(pColVal)) {
-      SET_BIT1(pColData->pBitMap, pColData->nVal, 0);
-    } else {
+  code = tColDataPutValue(pColData, pColVal);
+  if (code) return code;
+
+  pColData->nVal++;
+
+  return code;
+}
+static FORCE_INLINE int32_t tColDataAppendValue60(SColData *pColData, SColVal *pColVal) {
+  int32_t code = 0;
+
+  code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1));
+  if (code) return code;
   SET_BIT1(pColData->pBitMap, pColData->nVal, 1);
-    }
-  }
+
   code = tColDataPutValue(pColData, pColVal);
-  if (code) goto _exit;
+  if (code) return code;
 
   pColData->nVal++;
 
-_exit:
   return code;
 }
-static FORCE_INLINE int32_t tColDataAppendValue6(SColData *pColData, SColVal *pColVal) {  // HAS_VALUE|HAS_NULL
+static FORCE_INLINE int32_t tColDataAppendValue61(SColData *pColData, SColVal *pColVal) {
   int32_t code = 0;
 
-  if (COL_VAL_IS_NONE(pColVal)) {
   pColData->flag |= HAS_NONE;
 
   uint8_t *pBitMap = NULL;
   code = tRealloc(&pBitMap, BIT2_SIZE(pColData->nVal + 1));
-    if (code) goto _exit;
+  if (code) return code;
 
   for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
     SET_BIT2(pBitMap, iVal, GET_BIT1(pColData->pBitMap, iVal) ? 2 : 1);
@@ -1364,59 +1449,83 @@ static FORCE_INLINE int32_t tColDataAppendValue6(SColData *pColData, SColVal *pC
 
   tFree(pColData->pBitMap);
   pColData->pBitMap = pBitMap;
-  } else {
-    code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1));
-    if (code) goto _exit;
 
-    if (COL_VAL_IS_NULL(pColVal)) {
+  code = tColDataPutValue(pColData, pColVal);
+  if (code) return code;
+
+  pColData->nVal++;
+
+  return code;
+}
+static FORCE_INLINE int32_t tColDataAppendValue62(SColData *pColData, SColVal *pColVal) {
+  int32_t code = 0;
+
+  code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1));
+  if (code) return code;
   SET_BIT1(pColData->pBitMap, pColData->nVal, 0);
-    } else {
-      SET_BIT1(pColData->pBitMap, pColData->nVal, 1);
-    }
-  }
+
   code = tColDataPutValue(pColData, pColVal);
-  if (code) goto _exit;
+  if (code) return code;
 
   pColData->nVal++;
 
-_exit:
   return code;
 }
-static FORCE_INLINE int32_t tColDataAppendValue7(SColData *pColData,
-                                                 SColVal  *pColVal) {  // HAS_VALUE|HAS_NULL|HAS_NONE
+static FORCE_INLINE int32_t tColDataAppendValue70(SColData *pColData, SColVal *pColVal) {
   int32_t code = 0;
 
   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)) {
+  code = tColDataPutValue(pColData, pColVal);
+  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);
-  } else if (COL_VAL_IS_NULL(pColVal)) {
+
+  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);
-  } else {
-    SET_BIT2(pColData->pBitMap, pColData->nVal, 2);
-  }
+
   code = tColDataPutValue(pColData, pColVal);
-  if (code) goto _exit;
+  if (code) return code;
 
   pColData->nVal++;
 
-_exit:
   return code;
 }
-static int32_t (*tColDataAppendValueImpl[])(SColData *pColData, SColVal *pColVal) = {
-    tColDataAppendValue0,  // 0
-    tColDataAppendValue1,  // HAS_NONE
-    tColDataAppendValue2,  // HAS_NULL
-    tColDataAppendValue3,  // HAS_NULL|HAS_NONE
-    tColDataAppendValue4,  // HAS_VALUE
-    tColDataAppendValue5,  // HAS_VALUE|HAS_NONE
-    tColDataAppendValue6,  // HAS_VALUE|HAS_NULL
-    tColDataAppendValue7   // HAS_VALUE|HAS_NULL|HAS_NONE
+static int32_t (*tColDataAppendValueImpl[8][3])(SColData *pColData, SColVal *pColVal) = {
+    {tColDataAppendValue00, tColDataAppendValue01, tColDataAppendValue02},  // 0
+    {tColDataAppendValue10, tColDataAppendValue11, tColDataAppendValue12},  // HAS_NONE
+    {tColDataAppendValue20, tColDataAppendValue21, tColDataAppendValue22},  // HAS_NULL
+    {tColDataAppendValue30, tColDataAppendValue31, tColDataAppendValue32},  // HAS_NULL|HAS_NONE
+    {tColDataAppendValue40, tColDataAppendValue41, tColDataAppendValue42},  // HAS_VALUE
+    {tColDataAppendValue50, tColDataAppendValue51, tColDataAppendValue52},  // HAS_VALUE|HAS_NONE
+    {tColDataAppendValue60, tColDataAppendValue61, tColDataAppendValue62},  // HAS_VALUE|HAS_NULL
+    {tColDataAppendValue70, tColDataAppendValue71, tColDataAppendValue72},  // HAS_VALUE|HAS_NULL|HAS_NONE
 };
 int32_t tColDataAppendValue(SColData *pColData, SColVal *pColVal) {
   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