Merge branch 'refact/submit_req' of github.com:taosdata/TDengine into refact/submit_req

source/common/src/tdataformat.c

@@ -63,9 +63,9 @@ static int32_t tGetTagVal(uint8_t *p, STagVal *pTagVal, int8_t isJson);
 #define KV_FLG_MID ((uint8_t)0x20)
 #define KV_FLG_BIG ((uint8_t)0x30)
 
-#define ROW_BIT_NONE  ((uint8_t)0x0)
-#define ROW_BIT_NULL  ((uint8_t)0x1)
-#define ROW_BIT_VALUE ((uint8_t)0x2)
+#define BIT_FLG_NONE  ((uint8_t)0x0)
+#define BIT_FLG_NULL  ((uint8_t)0x1)
+#define BIT_FLG_VALUE ((uint8_t)0x2)
 
 #pragma pack(push, 1)
 typedef struct {
@@ -314,7 +314,7 @@ int32_t tRowBuild(SArray *aColVal, STSchema *pTSchema, SRow **ppRow) {
       if (pColVal) {
         if (pColVal->cid == pTColumn->colId) {
           if (COL_VAL_IS_VALUE(pColVal)) {  // VALUE
-            ROW_SET_BITMAP(pb, flag, iTColumn - 1, ROW_BIT_VALUE);
+            ROW_SET_BITMAP(pb, flag, iTColumn - 1, BIT_FLG_VALUE);
 
             if (IS_VAR_DATA_TYPE(pTColumn->type)) {
               *(int32_t *)(pf + pTColumn->offset) = nv;
@@ -327,24 +327,24 @@ int32_t tRowBuild(SArray *aColVal, STSchema *pTSchema, SRow **ppRow) {
               memcpy(pf + pTColumn->offset, &pColVal->value.val, TYPE_BYTES[pTColumn->type]);
             }
           } else if (COL_VAL_IS_NONE(pColVal)) {  // NONE
-            ROW_SET_BITMAP(pb, flag, iTColumn - 1, ROW_BIT_NONE);
+            ROW_SET_BITMAP(pb, flag, iTColumn - 1, BIT_FLG_NONE);
             if (pf) memset(pf + pTColumn->offset, 0, TYPE_BYTES[pTColumn->type]);
           } else {  // NULL
-            ROW_SET_BITMAP(pb, flag, iTColumn - 1, ROW_BIT_NULL);
+            ROW_SET_BITMAP(pb, flag, iTColumn - 1, BIT_FLG_NULL);
             if (pf) memset(pf + pTColumn->offset, 0, TYPE_BYTES[pTColumn->type]);
           }
 
           pTColumn = (++iTColumn < pTSchema->numOfCols) ? pTSchema->columns + iTColumn : NULL;
           pColVal = (++iColVal < nColVal) ? &colVals[iColVal] : NULL;
         } else if (pColVal->cid > pTColumn->colId) {  // NONE
-          ROW_SET_BITMAP(pb, flag, iTColumn - 1, ROW_BIT_NONE);
+          ROW_SET_BITMAP(pb, flag, iTColumn - 1, BIT_FLG_NONE);
           if (pf) memset(pf + pTColumn->offset, 0, TYPE_BYTES[pTColumn->type]);
           pTColumn = (++iTColumn < pTSchema->numOfCols) ? pTSchema->columns + iTColumn : NULL;
         } else {
           pColVal = (++iColVal < nColVal) ? &colVals[iColVal] : NULL;
         }
       } else {  // NONE
-        ROW_SET_BITMAP(pb, flag, iTColumn - 1, ROW_BIT_NONE);
+        ROW_SET_BITMAP(pb, flag, iTColumn - 1, BIT_FLG_NONE);
         if (pf) memset(pf + pTColumn->offset, 0, TYPE_BYTES[pTColumn->type]);
         pTColumn = (++iTColumn < pTSchema->numOfCols) ? pTSchema->columns + iTColumn : NULL;
       }
@@ -459,7 +459,7 @@ void tRowGet(SRow *pRow, STSchema *pTSchema, int32_t iCol, SColVal *pColVal) {
     } else {
       uint8_t *pf;
       uint8_t *pv;
-      uint8_t  bv = ROW_BIT_VALUE;
+      uint8_t  bv = BIT_FLG_VALUE;
 
       switch (pRow->flag) {
         case (HAS_NULL | HAS_NONE):
@@ -487,10 +487,10 @@ void tRowGet(SRow *pRow, STSchema *pTSchema, int32_t iCol, SColVal *pColVal) {
           break;
       }
 
-      if (bv == ROW_BIT_NONE) {
+      if (bv == BIT_FLG_NONE) {
         *pColVal = COL_VAL_NONE(pTColumn->colId, pTColumn->type);
         return;
-      } else if (bv == ROW_BIT_NULL) {
+      } else if (bv == BIT_FLG_NULL) {
         *pColVal = COL_VAL_NULL(pTColumn->colId, pTColumn->type);
         return;
       }
@@ -615,6 +615,7 @@ int32_t tRowMerge(SArray *aRowP, STSchema *pTSchema, int8_t flag) {
 
     if (iEnd - iStart > 1) {
       code = tRowMergeImpl(aRowP, pTSchema, iStart, iEnd, flag);
+      if (code) return code;
     }
 
     // the array is also changing, so the iStart just ++ instead of iEnd
@@ -789,7 +790,7 @@ SColVal *tRowIterNext(SRowIter *pIter) {
       goto _exit;
     }
   } else {  // Tuple
-    uint8_t bv = ROW_BIT_VALUE;
+    uint8_t bv = BIT_FLG_VALUE;
     if (pIter->pb) {
       switch (pIter->pRow->flag) {
         case (HAS_NULL | HAS_NONE):
@@ -810,10 +811,10 @@ SColVal *tRowIterNext(SRowIter *pIter) {
           break;
       }
 
-      if (bv == ROW_BIT_NONE) {
+      if (bv == BIT_FLG_NONE) {
         pIter->cv = COL_VAL_NONE(pTColumn->colId, pTColumn->type);
         goto _exit;
-      } else if (bv == ROW_BIT_NULL) {
+      } else if (bv == BIT_FLG_NULL) {
         pIter->cv = COL_VAL_NULL(pTColumn->colId, pTColumn->type);
         goto _exit;
       }
@@ -947,11 +948,11 @@ static int32_t tRowAppendTupleToColData(SRow *pRow, STSchema *pTSchema, SColData
               break;
           }
 
-          if (bv == ROW_BIT_NONE) {
+          if (bv == BIT_FLG_NONE) {
             code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NONE](pColData, NULL, 0);
             if (code) goto _exit;
             goto _continue;
-          } else if (bv == ROW_BIT_NULL) {
+          } else if (bv == BIT_FLG_NULL) {
             code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NULL](pColData, NULL, 0);
             if (code) goto _exit;
             goto _continue;
@@ -2133,6 +2134,88 @@ _exit:
   return code;
 }
 
+static void tColDataSort(SColData *aColData, int32_t nColData) {
+  if (aColData[0].nVal == 0) return;
+  // TODO
+}
+static void tColDataMergeImpl(SColData *pColData, int32_t iStart, int32_t iEnd /* not included */) {
+  switch (pColData->flag) {
+    case HAS_NONE:
+    case HAS_NULL: {
+      pColData->nVal = pColData->nVal - (iEnd - iStart);
+    } break;
+    case HAS_NULL | HAS_NONE: {
+      if (GET_BIT1(pColData->pBitMap, iStart) == BIT_FLG_NONE) {
+        for (int32_t i = iStart + 1; i < iEnd; ++i) {
+          if (GET_BIT1(pColData->pBitMap, i) == BIT_FLG_NULL) {
+            SET_BIT1(pColData->pBitMap, iStart, BIT_FLG_NULL);
+            break;
+          }
+        }
+      }
+      for (int32_t i = iEnd, j = iStart + 1; i < pColData->nVal; ++i, ++j) {
+        SET_BIT1(pColData->pBitMap, j, GET_BIT1(pColData->pBitMap, i));
+      }
+
+      pColData->nVal = pColData->nVal - (iEnd - iStart);
+
+      uint8_t flag = 0;
+      for (int32_t i = 0; i < pColData->nVal; ++i) {
+        uint8_t bv = GET_BIT1(pColData->pBitMap, i);
+        if (bv == BIT_FLG_NONE) {
+          flag |= HAS_NONE;
+        } else if (bv == BIT_FLG_NULL) {
+          flag |= HAS_NULL;
+        } else {
+          ASSERT(0);
+        }
+
+        if (flag == pColData->flag) break;
+      }
+      pColData->flag = flag;
+    } break;
+    case HAS_VALUE: {
+      // TODO
+      pColData->nVal = pColData->nVal - (iEnd - iStart);
+    } break;
+    case HAS_VALUE | HAS_NONE: {
+      // TODO
+      pColData->nVal = pColData->nVal - (iEnd - iStart);
+    } break;
+    case HAS_VALUE | HAS_NULL: {
+      // TODO
+      pColData->nVal = pColData->nVal - (iEnd - iStart);
+    } break;
+    case HAS_VALUE | HAS_NULL | HAS_NONE: {
+      // TODO
+      pColData->nVal = pColData->nVal - (iEnd - iStart);
+    } break;
+    default:
+      ASSERT(0);
+      break;
+  }
+}
+static void tColDataMerge(SColData *aColData, int32_t nColData) {
+  int32_t iStart = 0;
+  for (;;) {
+    if (iStart >= aColData[0].nVal) break;
+
+    int32_t iEnd = iStart + 1;
+    while (iEnd < aColData[0].nVal) {
+      if (((TSKEY *)aColData[0].pData)[iEnd] != ((TSKEY *)aColData[0].pData)[iStart]) break;
+
+      iEnd++;
+    }
+
+    if (iEnd - iStart > 1) {
+      for (int32_t i = 0; i < nColData; i++) {
+        tColDataMergeImpl(&aColData[i], iStart, iEnd);
+      }
+    }
+
+    iStart++;
+  }
+}
 void tColDataSortMerge(SArray *colDataArr) {
   int32_t   nColData = TARRAY_SIZE(colDataArr);
   SColData *aColData = (SColData *)TARRAY_DATA(colDataArr);
@@ -2160,14 +2243,12 @@ void tColDataSortMerge(SArray *colDataArr) {
 
   // sort -------
   if (doSort) {
-    ASSERT(0);
-    // todo
+    tColDataSort(aColData, nColData);
   }
 
   // merge -------
   if (doMerge) {
-    ASSERT(0);
-    // todo
+    tColDataMerge(aColData, nColData);
   }
 
 _exit: