TD-100

src/util/src/tutil.c

@@ -630,6 +630,7 @@ void * taosbsearch(const void *key, const void *base, size_t nmemb, size_t size,
   if (flags == TD_EQ) {
     return bsearch(key, base, nmemb, size, compar);
   } else if (flags == TD_GE) {
+    if (nmemb == 0) return NULL;
     if ((*compar)(key, elePtrAt(base, size, 0)) <= 0) return elePtrAt(base, size, 0);
     if ((*compar)(key, elePtrAt(base, size, nmemb - 1)) > 0) return NULL;
 
@@ -655,6 +656,7 @@ void * taosbsearch(const void *key, const void *base, size_t nmemb, size_t size,
       }
     }
   } else if (flags == TD_LE) {
+    if (nmemb == 0) return NULL;
     if ((*compar)(key, elePtrAt(base, size, nmemb - 1)) >= 0) return elePtrAt(base, size, nmemb - 1);
     if ((*compar)(key, elePtrAt(base, size, 0)) < 0) return NULL;
 

src/util/tests/taosbsearchTest.cpp

@@ -0,0 +1,414 @@
+#include <gtest/gtest.h>
+
+#include "tutil.h"
+
+static int compareFunc(const void *arg1, const void *arg2) { return (*(int *)arg1) - (*(int *)arg2); }
+
+TEST(testCase, taosbsearch_equal) {
+    // For equal test
+    int   key = 3;
+    void *pRet = NULL;
+
+    pRet = taosbsearch((void *)&key, NULL, 0, sizeof(int), compareFunc, TD_EQ);
+    ASSERT_EQ(pRet, nullptr);
+
+    // 1 element
+    int array1[1] = {5};
+
+    key = 1;
+    pRet = taosbsearch((void *)&key, (void *)array1, 1, sizeof(int), compareFunc, TD_EQ);
+    ASSERT_EQ(pRet, nullptr);
+
+    key = 6;
+    pRet = taosbsearch((void *)&key, (void *)array1, 1, sizeof(int), compareFunc, TD_EQ);
+    ASSERT_EQ(pRet, nullptr);
+
+    key = 5;
+    pRet = taosbsearch((void *)&key, (void *)array1, 1, sizeof(int), compareFunc, TD_EQ);
+    ASSERT_NE(pRet, nullptr);
+    ASSERT_EQ(*(int *)pRet, key);
+
+    // 2 element
+    int array2[2] = {3, 6};
+
+    key = 1;
+    pRet = taosbsearch((void *)&key, (void *)array2, 2, sizeof(int), compareFunc, TD_EQ);
+    ASSERT_EQ(pRet, nullptr);
+
+    key = 3;
+    pRet = taosbsearch((void *)&key, (void *)array2, 2, sizeof(int), compareFunc, TD_EQ);
+    ASSERT_EQ(*(int *)pRet, key);
+
+    key = 4;
+    pRet = taosbsearch((void *)&key, (void *)array2, 2, sizeof(int), compareFunc, TD_EQ);
+    ASSERT_EQ(pRet, nullptr);
+
+    key = 6;
+    pRet = taosbsearch((void *)&key, (void *)array2, 2, sizeof(int), compareFunc, TD_EQ);
+    ASSERT_EQ(*(int *)pRet, 6);
+
+    key = 7;
+    pRet = taosbsearch((void *)&key, (void *)array2, 2, sizeof(int), compareFunc, TD_EQ);
+    ASSERT_EQ(pRet, nullptr);
+
+    // 3 element
+    int array3[3] = {3, 6, 8};
+
+    key = 1;
+    pRet = taosbsearch((void *)&key, (void *)array3, 3, sizeof(int), compareFunc, TD_EQ);
+    ASSERT_EQ(pRet, nullptr);
+
+    key = 3;
+    pRet = taosbsearch((void *)&key, (void *)array3, 3, sizeof(int), compareFunc, TD_EQ);
+    ASSERT_EQ(*(int *)pRet, 3);
+
+    key = 4;
+    pRet = taosbsearch((void *)&key, (void *)array3, 3, sizeof(int), compareFunc, TD_EQ);
+    ASSERT_EQ(pRet, nullptr);
+
+    key = 6;
+    pRet = taosbsearch((void *)&key, (void *)array3, 3, sizeof(int), compareFunc, TD_EQ);
+    ASSERT_EQ(*(int *)pRet, 6);
+
+    key = 7;
+    pRet = taosbsearch((void *)&key, (void *)array3, 3, sizeof(int), compareFunc, TD_EQ);
+    ASSERT_EQ(pRet, nullptr);
+
+    key = 8;
+    pRet = taosbsearch((void *)&key, (void *)array3, 3, sizeof(int), compareFunc, TD_EQ);
+    ASSERT_EQ(*(int *)pRet, 8);
+
+    key = 9;
+    pRet = taosbsearch((void *)&key, (void *)array3, 3, sizeof(int), compareFunc, TD_EQ);
+    ASSERT_EQ(pRet, nullptr);
+}
+
+TEST(testCase, taosbsearch_greater_or_equal) {
+    // For equal test
+    int   key = 3;
+    void *pRet = NULL;
+
+    pRet = taosbsearch((void *)&key, NULL, 0, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(pRet, nullptr);
+
+    // 1 element
+    int array1[1] = {5};
+
+    key = 1;
+    pRet = taosbsearch((void *)&key, (void *)array1, 1, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 5);
+
+    key = 6;
+    pRet = taosbsearch((void *)&key, (void *)array1, 1, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(pRet, nullptr);
+
+    key = 5;
+    pRet = taosbsearch((void *)&key, (void *)array1, 1, sizeof(int), compareFunc, TD_GE);
+    ASSERT_NE(pRet, nullptr);
+    ASSERT_EQ(*(int *)pRet, 5);
+
+    // 2 element
+    int array2[2] = {3, 6};
+
+    key = 1;
+    pRet = taosbsearch((void *)&key, (void *)array2, 2, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 3);
+
+    key = 3;
+    pRet = taosbsearch((void *)&key, (void *)array2, 2, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 3);
+
+    key = 4;
+    pRet = taosbsearch((void *)&key, (void *)array2, 2, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 6);
+
+    key = 6;
+    pRet = taosbsearch((void *)&key, (void *)array2, 2, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 6);
+
+    key = 7;
+    pRet = taosbsearch((void *)&key, (void *)array2, 2, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(pRet, nullptr);
+
+    // 3 element
+    int array3[3] = {3, 6, 8};
+
+    key = 1;
+    pRet = taosbsearch((void *)&key, (void *)array3, 3, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 3);
+
+    key = 3;
+    pRet = taosbsearch((void *)&key, (void *)array3, 3, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 3);
+
+    key = 4;
+    pRet = taosbsearch((void *)&key, (void *)array3, 3, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 6);
+
+    key = 6;
+    pRet = taosbsearch((void *)&key, (void *)array3, 3, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 6);
+
+    key = 7;
+    pRet = taosbsearch((void *)&key, (void *)array3, 3, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 8);
+
+    key = 8;
+    pRet = taosbsearch((void *)&key, (void *)array3, 3, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 8);
+
+    key = 9;
+    pRet = taosbsearch((void *)&key, (void *)array3, 3, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(pRet, nullptr);
+
+    // 4 element
+    int array4[4] = {3, 6, 8, 11};
+
+    key = 1;
+    pRet = taosbsearch((void *)&key, (void *)array4, 4, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 3);
+
+    key = 3;
+    pRet = taosbsearch((void *)&key, (void *)array4, 4, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 3);
+
+    key = 4;
+    pRet = taosbsearch((void *)&key, (void *)array4, 4, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 6);
+
+    key = 6;
+    pRet = taosbsearch((void *)&key, (void *)array4, 4, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 6);
+
+    key = 7;
+    pRet = taosbsearch((void *)&key, (void *)array4, 4, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 8);
+
+    key = 8;
+    pRet = taosbsearch((void *)&key, (void *)array4, 4, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 8);
+
+    key = 9;
+    pRet = taosbsearch((void *)&key, (void *)array4, 4, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 11);
+
+    key = 11;
+    pRet = taosbsearch((void *)&key, (void *)array4, 4, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 11);
+
+    key = 13;
+    pRet = taosbsearch((void *)&key, (void *)array4, 4, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(pRet, nullptr);
+
+    // 5 element
+    int array5[5] = {3, 6, 8, 11, 15};
+
+    key = 1;
+    pRet = taosbsearch((void *)&key, (void *)array5, 5, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 3);
+
+    key = 3;
+    pRet = taosbsearch((void *)&key, (void *)array5, 5, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 3);
+
+    key = 4;
+    pRet = taosbsearch((void *)&key, (void *)array5, 5, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 6);
+
+    key = 6;
+    pRet = taosbsearch((void *)&key, (void *)array5, 5, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 6);
+
+    key = 7;
+    pRet = taosbsearch((void *)&key, (void *)array5, 5, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 8);
+
+    key = 8;
+    pRet = taosbsearch((void *)&key, (void *)array5, 5, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 8);
+
+    key = 9;
+    pRet = taosbsearch((void *)&key, (void *)array5, 5, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 11);
+
+    key = 11;
+    pRet = taosbsearch((void *)&key, (void *)array5, 5, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 11);
+
+    key = 13;
+    pRet = taosbsearch((void *)&key, (void *)array5, 5, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 15);
+
+    key = 15;
+    pRet = taosbsearch((void *)&key, (void *)array5, 5, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(*(int *)pRet, 15);
+
+    key = 17;
+    pRet = taosbsearch((void *)&key, (void *)array5, 5, sizeof(int), compareFunc, TD_GE);
+    ASSERT_EQ(pRet, nullptr);
+}
+
+TEST(testCase, taosbsearch_less_or_equal) {
+    // For equal test
+    int   key = 3;
+    void *pRet = NULL;
+
+    pRet = taosbsearch((void *)&key, NULL, 0, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(pRet, nullptr);
+
+    // 1 element
+    int array1[1] = {5};
+
+    key = 1;
+    pRet = taosbsearch((void *)&key, (void *)array1, 1, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(pRet, nullptr);
+
+    key = 6;
+    pRet = taosbsearch((void *)&key, (void *)array1, 1, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 5);
+
+    key = 5;
+    pRet = taosbsearch((void *)&key, (void *)array1, 1, sizeof(int), compareFunc, TD_LE);
+    ASSERT_NE(pRet, nullptr);
+    ASSERT_EQ(*(int *)pRet, 5);
+
+    // 2 element
+    int array2[2] = {3, 6};
+
+    key = 1;
+    pRet = taosbsearch((void *)&key, (void *)array2, 2, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(pRet, nullptr);
+
+    key = 3;
+    pRet = taosbsearch((void *)&key, (void *)array2, 2, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 3);
+
+    key = 4;
+    pRet = taosbsearch((void *)&key, (void *)array2, 2, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 3);
+
+    key = 6;
+    pRet = taosbsearch((void *)&key, (void *)array2, 2, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 6);
+
+    key = 7;
+    pRet = taosbsearch((void *)&key, (void *)array2, 2, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 6);
+
+    // 3 element
+    int array3[3] = {3, 6, 8};
+
+    key = 1;
+    pRet = taosbsearch((void *)&key, (void *)array3, 3, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(pRet, nullptr);
+
+    key = 3;
+    pRet = taosbsearch((void *)&key, (void *)array3, 3, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 3);
+
+    key = 4;
+    pRet = taosbsearch((void *)&key, (void *)array3, 3, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 3);
+
+    key = 6;
+    pRet = taosbsearch((void *)&key, (void *)array3, 3, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 6);
+
+    key = 7;
+    pRet = taosbsearch((void *)&key, (void *)array3, 3, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 6);
+
+    key = 8;
+    pRet = taosbsearch((void *)&key, (void *)array3, 3, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 8);
+
+    key = 9;
+    pRet = taosbsearch((void *)&key, (void *)array3, 3, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 8);
+
+    // 4 element
+    int array4[4] = {3, 6, 8, 11};
+
+    key = 1;
+    pRet = taosbsearch((void *)&key, (void *)array4, 4, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(pRet, nullptr);
+
+    key = 3;
+    pRet = taosbsearch((void *)&key, (void *)array4, 4, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 3);
+
+    key = 4;
+    pRet = taosbsearch((void *)&key, (void *)array4, 4, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 3);
+
+    key = 6;
+    pRet = taosbsearch((void *)&key, (void *)array4, 4, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 6);
+
+    key = 7;
+    pRet = taosbsearch((void *)&key, (void *)array4, 4, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 6);
+
+    key = 8;
+    pRet = taosbsearch((void *)&key, (void *)array4, 4, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 8);
+
+    key = 9;
+    pRet = taosbsearch((void *)&key, (void *)array4, 4, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 8);
+
+    key = 11;
+    pRet = taosbsearch((void *)&key, (void *)array4, 4, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 11);
+
+    key = 13;
+    pRet = taosbsearch((void *)&key, (void *)array4, 4, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 11);
+
+    // 5 element
+    int array5[5] = {3, 6, 8, 11, 15};
+
+    key = 1;
+    pRet = taosbsearch((void *)&key, (void *)array5, 5, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(pRet, nullptr);
+
+    key = 3;
+    pRet = taosbsearch((void *)&key, (void *)array5, 5, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 3);
+
+    key = 4;
+    pRet = taosbsearch((void *)&key, (void *)array5, 5, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 3);
+
+    key = 6;
+    pRet = taosbsearch((void *)&key, (void *)array5, 5, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 6);
+
+    key = 7;
+    pRet = taosbsearch((void *)&key, (void *)array5, 5, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 6);
+
+    key = 8;
+    pRet = taosbsearch((void *)&key, (void *)array5, 5, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 8);
+
+    key = 9;
+    pRet = taosbsearch((void *)&key, (void *)array5, 5, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 8);
+
+    key = 11;
+    pRet = taosbsearch((void *)&key, (void *)array5, 5, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 11);
+
+    key = 13;
+    pRet = taosbsearch((void *)&key, (void *)array5, 5, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 11);
+
+    key = 15;
+    pRet = taosbsearch((void *)&key, (void *)array5, 5, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 15);
+
+    key = 17;
+    pRet = taosbsearch((void *)&key, (void *)array5, 5, sizeof(int), compareFunc, TD_LE);
+    ASSERT_EQ(*(int *)pRet, 15);
+}

src/vnode/tsdb/src/tsdbRWHelper.c

@@ -27,7 +27,7 @@
 static int  tsdbCheckHelperCfg(SHelperCfg *pCfg);
 static void tsdbInitHelperFile(SHelperFile *pHFile);
 static int  tsdbInitHelperRead(SRWHelper *pHelper);
-static int  tsdbInitHelperWrite(SRWHelper *pHelper);
+// static int  tsdbInitHelperWrite(SRWHelper *pHelper);
 static void tsdbClearHelperFile(SHelperFile *pHFile);
 static void tsdbDestroyHelperRead(SRWHelper *pHelper);
 static void tsdbDestroyHelperWrite(SRWHelper *pHelper);
@@ -40,6 +40,7 @@ static int compareKeyBlock(const void *arg1, const void *arg2);
 static int tsdbMergeDataWithBlock(SRWHelper *pHelper, int blkIdx, SDataCols *pDataCols);
 static int nRowsLEThan(SDataCols *pDataCols, int maxKey);
 static int tsdbGetRowsCanBeMergedWithBlock(SRWHelper *pHelper, int blkIdx, SDataCols *pDataCols);
+static int tsdbInsertSuperBlock(SRWHelper *pHelper, SCompBlock *pCompBlock, int blkIdx);
 
 int tsdbInitHelper(SRWHelper *pHelper, SHelperCfg *pCfg) {
   if (pHelper == NULL || pCfg == NULL || tsdbCheckHelperCfg(pCfg) < 0) return -1;
@@ -52,7 +53,10 @@ int tsdbInitHelper(SRWHelper *pHelper, SHelperCfg *pCfg) {
 
   if (tsdbInitHelperRead(pHelper) < 0) goto _err;
 
-  if ((TSDB_HELPER_TYPE(pHelper) == TSDB_WRITE_HELPER) && tsdbInitHelperWrite(pHelper) < 0) goto _err;
+  pHelper->pDataCols[0] = tdNewDataCols(pCfg->maxRowSize, pCfg->maxCols, pCfg->maxRows);
+  pHelper->pDataCols[1] = tdNewDataCols(pCfg->maxRowSize, pCfg->maxCols, pCfg->maxRows);
+  
+  if ((pHelper->pDataCols[0] == NULL) || (pHelper->pDataCols[1] == NULL)) goto _err;
 
   pHelper->state = TSDB_HELPER_CLEAR_STATE;
 
@@ -182,6 +186,7 @@ void tsdbSetHelperTable(SRWHelper *pHelper, SHelperTable *pHelperTable, STSchema
  */
 int tsdbWriteDataBlock(SRWHelper *pHelper, SDataCols *pDataCols) {
   ASSERT(TSDB_HELPER_TYPE(pHelper) == TSDB_WRITE_HELPER);
+  ASSERT(pDataCols->numOfPoints > 0);
 
   SCompBlock compBlock;
   int        rowsToWrite = 0;
@@ -193,8 +198,7 @@ int tsdbWriteDataBlock(SRWHelper *pHelper, SDataCols *pDataCols) {
 
   // Load the SCompInfo part if neccessary
   ASSERT(helperHasState(pHelper, TSDB_HELPER_TABLE_SET));
-  if ((!helperHasState(pHelper, TSDB_HELPER_INFO_LOAD)) &&
+  if (!helperHasState(pHelper, TSDB_HELPER_INFO_LOAD) && (pIdx->offset > 0)) {
-      ((pIdx->offset > 0) && (pIdx->hasLast || keyFirst <= pIdx->maxKey))) {
     if (tsdbLoadCompInfo(pHelper, NULL) < 0) goto _err;
   }
 
@@ -212,14 +216,7 @@ int tsdbWriteDataBlock(SRWHelper *pHelper, SDataCols *pDataCols) {
 
     if (tsdbWriteBlockToFile(pHelper, pWFile, pDataCols, rowsToWrite, &compBlock, isLast, true) < 0) goto _err;
 
-    // TODO: may need to reallocate the memory
+    if (tsdbInsertSuperBlock(pHelper, &compBlock, pIdx->numOfSuperBlocks) < 0) goto _err;
-    pHelper->pCompInfo->blocks[pHelper->blockIter++] = compBlock;
-
-    pIdx->hasLast = compBlock.last;
-    pIdx->numOfSuperBlocks++;
-    pIdx->maxKey = compBlock.keyLast;
-    ASSERT(compBlock.keyLast == dataColsKeyLast(pDataCols));
-    pIdx->len += sizeof(SCompBlock);
   } else {  // (Has old data) AND ((has last block) OR (key overlap)), need to merge the block
     SCompBlock *pCompBlock = taosbsearch((void *)(&keyFirst), (void *)(pHelper->pCompInfo->blocks),
                                          pIdx->numOfSuperBlocks, sizeof(SCompBlock), compareKeyBlock, TD_GE);
@@ -405,14 +402,14 @@ static void tsdbDestroyHelperRead(SRWHelper *pHelper) {
   tdFreeDataCols(pHelper->pDataCols[1]);
 }
 
-static int tsdbInitHelperWrite(SRWHelper *pHelper) {
+// static int tsdbInitHelperWrite(SRWHelper *pHelper) {
-  SHelperCfg *pCfg = &(pHelper->config);
+//   SHelperCfg *pCfg = &(pHelper->config);
 
-  // pHelper->wCompIdxSize = pCfg->maxTables * sizeof(SCompIdx);
+//   // pHelper->wCompIdxSize = pCfg->maxTables * sizeof(SCompIdx);
-  // if ((pHelper->pWCompIdx = (SCompIdx *)malloc(pHelper->wCompIdxSize)) == NULL) return -1;
+//   // if ((pHelper->pWCompIdx = (SCompIdx *)malloc(pHelper->wCompIdxSize)) == NULL) return -1;
 
-  return 0;
+//   return 0;
-}
+// }
 
 static void tsdbDestroyHelperWrite(SRWHelper *pHelper) {
   // tfree(pHelper->pWCompIdx);
@@ -644,7 +641,7 @@ static int tsdbGetRowsCanBeMergedWithBlock(SRWHelper *pHelper, int blkIdx, SData
 
   } else {
     int32_t colId[1] = {0};
-    if (tsdbLoadBlockDataCols(pHelper, NULL, &colId, 1) < 0) goto _err;
+    if (tsdbLoadBlockDataCols(pHelper, NULL, colId, 1) < 0) goto _err;
 
     int iter1 = 0;  // For pDataCols
     int iter2 = 0;  // For loaded data cols
@@ -675,3 +672,53 @@ static int tsdbGetRowsCanBeMergedWithBlock(SRWHelper *pHelper, int blkIdx, SData
 _err:
   return -1;
 }
+
+static int tsdbInsertSuperBlock(SRWHelper *pHelper, SCompBlock *pCompBlock, int blkIdx) {
+  SCompIdx *pIdx = pHelper->pCompIdx + pHelper->tableInfo.tid;
+
+  ASSERT(blkIdx >=0 && blkIdx <= pIdx->numOfSuperBlocks);
+  ASSERT(pCompBlock->numOfSubBlocks == 1);
+
+  // Adjust memory if no more room
+  size_t spaceNeed = sizeof(SCompBlock);
+  size_t spaceLeft = pHelper->compInfoSize - pIdx->len;
+  ASSERT(spaceLeft >= 0);
+  if (spaceLeft < spaceNeed) {
+    size_t tsize = pHelper->compInfoSize + sizeof(SCompBlock) * 16;
+    if (pHelper->compInfoSize == 0) tsize += sizeof(SCompInfo);
+
+    pHelper->pCompInfo = (SCompInfo *)realloc((void *)(pHelper->pCompInfo), tsize);
+    if (pHelper->pCompInfo == NULL) goto _err;
+  }
+
+  // Insert the block
+  if (blkIdx < pIdx->numOfSuperBlocks) {
+    SCompBlock *pTCompBlock = pHelper->pCompInfo->blocks + blkIdx;
+    memmove((void *)(pTCompBlock + 1), (void *)pTCompBlock, pIdx->len - sizeof(SCompInfo) - sizeof(SCompBlock) *blkIdx);
+    pTCompBlock++;
+    for (int i = 0; i < pIdx->numOfSuperBlocks - blkIdx; i++) {
+      pTCompBlock->offset++;
+    }
+  }
+  pHelper->pCompInfo->blocks[blkIdx] = *pCompBlock;
+
+  pIdx->numOfSuperBlocks++;
+  pIdx->len++;
+  pIdx->maxKey = pHelper->pCompInfo->blocks[pIdx->numOfSuperBlocks - 1].keyLast;
+  pIdx->hasLast = pHelper->pCompInfo->blocks[pIdx->numOfSuperBlocks - 1].last;
+
+  return 0;
+
+  _err:
+  return -1;
+}
+
+static int tsdbAddSubBlock(SRWHelper *pHelper, SCompBlock *pCompBlock) {
+  // TODO
+  return 0;
+}
+
+static int tsdbUpdateSuperBlock(SRWHelper *pHelper, SCompBlock *pCompBlock, int blkIdx) {
+  // TODO
+  return 0;
+}

src/vnode/tsdb/src/tsdbRead.c

@@ -740,14 +740,14 @@ static bool getQualifiedDataBlock(STsdbQueryHandle *pQueryHandle, STableCheckInf
     pFile->fd = open(pFile->fname, O_RDONLY);
   }
   
-  if (tsdbLoadDataBlock(pFile, pBlock, 1, pCheckInfo->pDataCols, data) == 0) {
+  // if (tsdbLoadDataBlock(pFile, pBlock, 1, pCheckInfo->pDataCols, data) == 0) {
-    SDataBlockLoadInfo* pBlockLoadInfo = &pQueryHandle->dataBlockLoadInfo;
+  //   SDataBlockLoadInfo* pBlockLoadInfo = &pQueryHandle->dataBlockLoadInfo;
-    pBlockLoadInfo->fileGroup = pCheckInfo->pFileGroup;
+  //   pBlockLoadInfo->fileGroup = pCheckInfo->pFileGroup;
-    pBlockLoadInfo->slot = pQueryHandle->cur.slot;
+  //   pBlockLoadInfo->slot = pQueryHandle->cur.slot;
-    pBlockLoadInfo->sid = pCheckInfo->pTableObj->tableId.tid;
+  //   pBlockLoadInfo->sid = pCheckInfo->pTableObj->tableId.tid;
     
-    blockLoaded = true;
+  //   blockLoaded = true;
-  }
+  // }
     
     //    dError("QInfo:%p fileId:%d total numOfBlks:%d blockId:%d load into memory failed due to error in disk files",
     //           GET_QINFO_ADDR(pQuery), pQuery->fileId, pQuery->numOfBlocks, blkIdx);

src/vnode/tsdb/tests/tsdbTests.cpp

@@ -79,8 +79,8 @@ TEST(TsdbTest, createRepo) {
   tsdbCreateTable(pRepo, &tCfg);
 
   // // 3. Loop to write some simple data
-  int nRows = 1;
+  int nRows = 10000000;
-  int rowsPerSubmit = 1;
+  int rowsPerSubmit = 10;
   int64_t start_time = 1584081000000;
 
   SSubmitMsg *pMsg = (SSubmitMsg *)malloc(sizeof(SSubmitMsg) + sizeof(SSubmitBlk) + tdMaxRowBytesFromSchema(schema) * rowsPerSubmit);