more refact

include/common/tmsg.h

@@ -1562,8 +1562,8 @@ typedef struct SVCreateTbReq {
   int8_t      type;
   union {
     struct {
-      tb_uid_t    suid;
-      const void* pTag;
+      tb_uid_t       suid;
+      const uint8_t* pTag;
     } ctb;
     struct {
       SSchemaWrapper schema;
@@ -2593,12 +2593,12 @@ static FORCE_INLINE void tDeleteSMqAskEpRsp(SMqAskEpRsp* pRsp) {
 
 #define TD_AUTO_CREATE_TABLE 0x1
 typedef struct {
-  int64_t       suid;
-  int64_t       uid;
-  int32_t       sver;
-  uint64_t      nData;
-  const void*   pData;
-  SVCreateTbReq cTbReq;
+  int64_t        suid;
+  int64_t        uid;
+  int32_t        sver;
+  uint64_t       nData;
+  const uint8_t* pData;
+  SVCreateTbReq  cTbReq;
 } SVSubmitBlk;
 
 typedef struct {

include/util/tencode.h

@@ -138,7 +138,7 @@ static int32_t tEncodeU64v(SCoder* pEncoder, uint64_t val);
 static int32_t tEncodeI64v(SCoder* pEncoder, int64_t val);
 static int32_t tEncodeFloat(SCoder* pEncoder, float val);
 static int32_t tEncodeDouble(SCoder* pEncoder, double val);
-static int32_t tEncodeBinary(SCoder* pEncoder, const void* val, uint64_t len);
+static int32_t tEncodeBinary(SCoder* pEncoder, const uint8_t* val, uint64_t len);
 static int32_t tEncodeCStrWithLen(SCoder* pEncoder, const char* val, uint64_t len);
 static int32_t tEncodeCStr(SCoder* pEncoder, const char* val);
 
@@ -162,7 +162,7 @@ static int32_t tDecodeU64v(SCoder* pDecoder, uint64_t* val);
 static int32_t tDecodeI64v(SCoder* pDecoder, int64_t* val);
 static int32_t tDecodeFloat(SCoder* pDecoder, float* val);
 static int32_t tDecodeDouble(SCoder* pDecoder, double* val);
-static int32_t tDecodeBinary(SCoder* pDecoder, const void** val, uint64_t* len);
+static int32_t tDecodeBinary(SCoder* pDecoder, const uint8_t** val, uint64_t* len);
 static int32_t tDecodeCStrAndLen(SCoder* pDecoder, const char** val, uint64_t* len);
 static int32_t tDecodeCStr(SCoder* pDecoder, const char** val);
 static int32_t tDecodeCStrTo(SCoder* pDecoder, char* val);
@@ -292,7 +292,7 @@ static FORCE_INLINE int32_t tEncodeDouble(SCoder* pEncoder, double val) {
   return tEncodeU64(pEncoder, v.ui);
 }
 
-static FORCE_INLINE int32_t tEncodeBinary(SCoder* pEncoder, const void* val, uint64_t len) {
+static FORCE_INLINE int32_t tEncodeBinary(SCoder* pEncoder, const uint8_t* val, uint64_t len) {
   if (tEncodeU64v(pEncoder, len) < 0) return -1;
   if (pEncoder->data) {
     if (TD_CODER_CHECK_CAPACITY_FAILED(pEncoder, len)) return -1;
@@ -413,7 +413,7 @@ static FORCE_INLINE int32_t tDecodeDouble(SCoder* pDecoder, double* val) {
   return 0;
 }
 
-static FORCE_INLINE int32_t tDecodeBinary(SCoder* pDecoder, const void** val, uint64_t* len) {
+static FORCE_INLINE int32_t tDecodeBinary(SCoder* pDecoder, const uint8_t** val, uint64_t* len) {
   if (tDecodeU64v(pDecoder, len) < 0) return -1;
 
   if (TD_CODER_CHECK_CAPACITY_FAILED(pDecoder, *len)) return -1;
@@ -426,7 +426,7 @@ static FORCE_INLINE int32_t tDecodeBinary(SCoder* pDecoder, const void** val, ui
 }
 
 static FORCE_INLINE int32_t tDecodeCStrAndLen(SCoder* pDecoder, const char** val, uint64_t* len) {
-  if (tDecodeBinary(pDecoder, (const void**)val, len) < 0) return -1;
+  if (tDecodeBinary(pDecoder, (const uint8_t**)val, len) < 0) return -1;
   (*len) -= 1;
   return 0;
 }

source/dnode/vnode/inc/vnode.h

@@ -90,7 +90,7 @@ int         metaTbCursorNext(SMTbCursor *pTbCur);
 
 // tsdb
 // typedef struct STsdb STsdb;
-typedef void        *tsdbReaderT;
+typedef void *tsdbReaderT;
 
 #define BLOCK_LOAD_OFFSET_SEQ_ORDER 1
 #define BLOCK_LOAD_TABLE_SEQ_ORDER  2
@@ -108,12 +108,12 @@ int32_t      tsdbQuerySTableByTagCond(void *pMeta, uint64_t uid, TSKEY skey, con
 int64_t      tsdbGetNumOfRowsInMemTable(tsdbReaderT *pHandle);
 bool         tsdbNextDataBlock(tsdbReaderT pTsdbReadHandle);
 void         tsdbRetrieveDataBlockInfo(tsdbReaderT *pTsdbReadHandle, SDataBlockInfo *pBlockInfo);
-int32_t      tsdbRetrieveDataBlockStatisInfo(tsdbReaderT *pTsdbReadHandle, SColumnDataAgg ***pBlockStatis, bool* allHave);
-SArray      *tsdbRetrieveDataBlock(tsdbReaderT *pTsdbReadHandle, SArray *pColumnIdList);
-void         tsdbResetReadHandle(tsdbReaderT queryHandle, SQueryTableDataCond *pCond);
-void         tsdbDestroyTableGroup(STableGroupInfo *pGroupList);
-int32_t      tsdbGetOneTableGroup(void *pMeta, uint64_t uid, TSKEY startKey, STableGroupInfo *pGroupInfo);
-int32_t      tsdbGetTableGroupFromIdList(SVnode *pVnode, SArray *pTableIdList, STableGroupInfo *pGroupInfo);
+int32_t tsdbRetrieveDataBlockStatisInfo(tsdbReaderT *pTsdbReadHandle, SColumnDataAgg ***pBlockStatis, bool *allHave);
+SArray *tsdbRetrieveDataBlock(tsdbReaderT *pTsdbReadHandle, SArray *pColumnIdList);
+void    tsdbResetReadHandle(tsdbReaderT queryHandle, SQueryTableDataCond *pCond);
+void    tsdbDestroyTableGroup(STableGroupInfo *pGroupList);
+int32_t tsdbGetOneTableGroup(void *pMeta, uint64_t uid, TSKEY startKey, STableGroupInfo *pGroupInfo);
+int32_t tsdbGetTableGroupFromIdList(SVnode *pVnode, SArray *pTableIdList, STableGroupInfo *pGroupInfo);
 
 // tq
 
@@ -126,8 +126,8 @@ int     tqReadHandleSetTbUidList(STqReadHandle *pHandle, const SArray *tbUidList
 int     tqReadHandleAddTbUidList(STqReadHandle *pHandle, const SArray *tbUidList);
 int32_t tqReadHandleSetMsg(STqReadHandle *pHandle, SSubmitReq *pMsg, int64_t ver);
 bool    tqNextDataBlock(STqReadHandle *pHandle);
-int32_t tqRetrieveDataBlock(SArray **ppCols, STqReadHandle *pHandle, uint64_t *pGroupId, uint64_t* pUid, int32_t *pNumOfRows,
-                            int16_t *pNumOfCols);
+int32_t tqRetrieveDataBlock(SArray **ppCols, STqReadHandle *pHandle, uint64_t *pGroupId, uint64_t *pUid,
+                            int32_t *pNumOfRows, int16_t *pNumOfCols);
 
 // need to reposition
 
@@ -189,10 +189,10 @@ struct SMetaEntry {
       SSchemaWrapper schemaTag;
     } stbEntry;
     struct {
-      int64_t     ctime;
-      int32_t     ttlDays;
-      tb_uid_t    suid;
-      const void *pTags;
+      int64_t        ctime;
+      int32_t        ttlDays;
+      tb_uid_t       suid;
+      const uint8_t *pTags;
     } ctbEntry;
     struct {
       int64_t        ctime;

source/dnode/vnode/src/tsdb/tsdbMemTable2.c

@@ -63,14 +63,18 @@ struct SMemSkipListCurosr {
   SMemSkipListNode *pNodeC;
 };
 
+#define HASH_BUCKET(SUID, UID, NBUCKET) (TABS((SUID) + (UID)) % (NBUCKET))
+
 #define SL_NODE_SIZE(l)        (sizeof(SMemSkipListNode) + sizeof(SMemSkipListNode *) * (l)*2)
 #define SL_NODE_HALF_SIZE(l)   (sizeof(SMemSkipListNode) + sizeof(SMemSkipListNode *) * (l))
 #define SL_NODE_FORWARD(n, l)  ((n)->forwards[l])
 #define SL_NODE_BACKWARD(n, l) ((n)->forwards[(n)->level + (l)])
 #define SL_NODE_DATA(n)        (&SL_NODE_BACKWARD(n, (n)->level))
 
-#define SL_HEAD_NODE(sl) ((sl)->pHead)
-#define SL_TAIL_NODE(sl) ((SMemSkipListNode *)&SL_NODE_FORWARD(SL_HEAD_NODE(sl), (sl)->maxLevel))
+#define SL_HEAD_NODE(sl)            ((sl)->pHead)
+#define SL_TAIL_NODE(sl)            ((SMemSkipListNode *)&SL_NODE_FORWARD(SL_HEAD_NODE(sl), (sl)->maxLevel))
+#define SL_HEAD_NODE_FORWARD(n, l)  SL_NODE_FORWARD(n, l)
+#define SL_TAIL_NODE_BACKWARD(n, l) SL_NODE_FORWARD(n, l)
 
 // SMemTable
 int32_t tsdbMemTableCreate2(STsdb *pTsdb, SMemTable **ppMemTb) {
@@ -111,23 +115,18 @@ int32_t tsdbMemTableDestroy2(STsdb *pTsdb, SMemTable *pMemTb) {
 }
 
 int32_t tsdbInsertData2(SMemTable *pMemTb, int64_t version, const SVSubmitBlk *pSubmitBlk) {
-  SMemData          *pMemData;
-  STsdb             *pTsdb = pMemTb->pTsdb;
-  SVnode            *pVnode = pTsdb->pVnode;
-  SVBufPool         *pPool = pVnode->inUse;
-  int32_t            hash;
-  int32_t            tlen;
-  uint8_t            buf[16];
-  int32_t            rlen;
-  const uint8_t     *p;
-  SMemSkipListNode  *pSlNode;
-  const STSRow      *pTSRow;
-  SMemSkipListCurosr slc = {0};
-
-  // search hash
-  hash = (pSubmitBlk->suid + pSubmitBlk->uid) % pMemTb->nBucket;
-  for (pMemData = pMemTb->pBuckets[hash]; pMemData; pMemData = pMemData->pHashNext) {
-    if (pMemData->suid == pSubmitBlk->suid && pMemData->uid == pSubmitBlk->uid) break;
+  SMemData  *pMemData;
+  STsdb     *pTsdb = pMemTb->pTsdb;
+  SVnode    *pVnode = pTsdb->pVnode;
+  SVBufPool *pPool = pVnode->inUse;
+  tb_uid_t   suid = pSubmitBlk->suid;
+  tb_uid_t   uid = pSubmitBlk->uid;
+  int32_t    iBucket;
+
+  // search SMemData by hash
+  iBucket = HASH_BUCKET(suid, uid, pMemTb->nBucket);
+  for (pMemData = pMemTb->pBuckets[iBucket]; pMemData; pMemData = pMemData->pHashNext) {
+    if (pMemData->suid == suid && pMemData->uid == uid) break;
   }
 
   // create pMemData if need
@@ -143,8 +142,8 @@ int32_t tsdbInsertData2(SMemTable *pMemTb, int64_t version, const SVSubmitBlk *p
     }
 
     pMemData->pHashNext = NULL;
-    pMemData->suid = pSubmitBlk->suid;
-    pMemData->uid = pSubmitBlk->uid;
+    pMemData->suid = suid;
+    pMemData->uid = uid;
     pMemData->minKey = TSKEY_MAX;
     pMemData->maxKey = TSKEY_MIN;
     pMemData->minVer = -1;
@@ -159,55 +158,61 @@ int32_t tsdbInsertData2(SMemTable *pMemTb, int64_t version, const SVSubmitBlk *p
     pHead->level = maxLevel;
     pTail->level = maxLevel;
     for (int iLevel = 0; iLevel < maxLevel; iLevel++) {
-      SL_NODE_FORWARD(pHead, iLevel) = pTail;
-      SL_NODE_FORWARD(pTail, iLevel) = pHead;
+      SL_HEAD_NODE_FORWARD(pHead, iLevel) = pTail;
+      SL_TAIL_NODE_BACKWARD(pTail, iLevel) = pHead;
     }
 
-    // add to MemTable
-    hash = (pMemData->suid + pMemData->uid) % pMemTb->nBucket;
-    pMemData->pHashNext = pMemTb->pBuckets[hash];
-    pMemTb->pBuckets[hash] = pMemData;
+    // add to hash
+    if (pMemTb->nHash >= pMemTb->nBucket) {
+      // rehash (todo)
+    }
+    iBucket = HASH_BUCKET(suid, uid, pMemTb->nBucket);
+    pMemData->pHashNext = pMemTb->pBuckets[iBucket];
+    pMemTb->pBuckets[iBucket] = pMemData;
     pMemTb->nHash++;
+
+    // sort organize (todo)
   }
 
-// loop to insert data to skiplist
-#if 0
-  tsdbMemSkipListCursorOpen(&slc, &pMemData->sl);
-  p = pSubmitBlk->pData;
-  for (;;) {
-    if (p - (uint8_t *)pSubmitBlk->pData >= pSubmitBlk->nData) break;
+  // do insert data to SMemData
+  SMemSkipListCurosr slc = {0};
+  const uint8_t     *p = pSubmitBlk->pData;
+
+  // tsdbMemSkipListCursorOpen(&slc, &pMemData->sl);
+  for (; p - pSubmitBlk->pData < pSubmitBlk->nData;) {
+    //   if (p - (uint8_t *)pSubmitBlk->pData >= pSubmitBlk->nData) break;
 
-    const uint8_t *pt = p;
-    p = tGetBinary(p, &pTSRow, &rlen);
+    //   const uint8_t *pt = p;
+    //   p = tGetBinary(p, &pTSRow, &rlen);
 
-    // check the row (todo)
+    //   // check the row (todo)
 
-    // move the cursor to position to write (todo)
-    int32_t c;
-    tsdbMemSkipListCursorMoveTo(&slc, pTSRow, version, &c);
-    ASSERT(c);
+    //   // move the cursor to position to write (todo)
+    //   int32_t c;
+    //   tsdbMemSkipListCursorMoveTo(&slc, pTSRow, version, &c);
+    //   ASSERT(c);
 
-    // encode row
-    int8_t  level = tsdbMemSkipListRandLevel(&pMemData->sl);
-    int32_t tsize = SL_NODE_SIZE(level) + sizeof(version) + (p - pt);
-    pSlNode = vnodeBufPoolMalloc(pPool, tsize);
-    pSlNode->level = level;
+    //   // encode row
+    //   int8_t  level = tsdbMemSkipListRandLevel(&pMemData->sl);
+    //   int32_t tsize = SL_NODE_SIZE(level) + sizeof(version) + (p - pt);
+    //   pSlNode = vnodeBufPoolMalloc(pPool, tsize);
+    //   pSlNode->level = level;
 
-    uint8_t *pData = SL_NODE_DATA(pSlNode);
-    *(int64_t *)pData = version;
-    pData += sizeof(version);
-    memcpy(pData, pt, p - pt);
+    //   uint8_t *pData = SL_NODE_DATA(pSlNode);
+    //   *(int64_t *)pData = version;
+    //   pData += sizeof(version);
+    //   memcpy(pData, pt, p - pt);
 
-    // insert row
-    tsdbMemSkipListCursorPut(&slc, pSlNode);
+    //   // insert row
+    //   tsdbMemSkipListCursorPut(&slc, pSlNode);
 
-    // update status
-    if (pTSRow->ts < pMemData->minKey) pMemData->minKey = pTSRow->ts;
-    if (pTSRow->ts > pMemData->maxKey) pMemData->maxKey = pTSRow->ts;
+    //   // update status
+    //   if (pTSRow->ts < pMemData->minKey) pMemData->minKey = pTSRow->ts;
+    //   if (pTSRow->ts > pMemData->maxKey) pMemData->maxKey = pTSRow->ts;
   }
-  tsdbMemSkipListCursorClose(&slc);
-#endif
+  // tsdbMemSkipListCursorClose(&slc);
 
+  // update status
   if (pMemData->minVer == -1) pMemData->minVer = version;
   if (pMemData->maxVer == -1 || pMemData->maxVer < version) pMemData->maxVer = version;
 
@@ -217,8 +222,4 @@ int32_t tsdbInsertData2(SMemTable *pMemTb, int64_t version, const SVSubmitBlk *p
   if (pMemTb->maxVer == -1 || pMemTb->maxVer < version) pMemTb->maxVer = version;
 
   return 0;
-}
-
-// SMemData
-
-// SMemSkipList
\ No newline at end of file
+}
\ No newline at end of file

source/libs/executor/CMakeLists.txt

@@ -17,6 +17,6 @@ target_include_directories(
         PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
 
-#if(${BUILD_TEST})
+if(${BUILD_TEST})
     ADD_SUBDIRECTORY(test)
-#endif(${BUILD_TEST})
+endif(${BUILD_TEST})

source/libs/sync/src/syncMessage.c

@@ -411,7 +411,7 @@ SyncPing* syncPingDeserialize3(void* buf, int32_t bufLen) {
   }
   uint64_t len;
   char*    data = NULL;
-  if (tDecodeBinary(&decoder, (const void**)(&data), &len) < 0) {
+  if (tDecodeBinary(&decoder, (const uint8_t**)(&data), &len) < 0) {
     return NULL;
   }
   assert(len = pMsg->dataLen);
@@ -670,7 +670,7 @@ SyncPingReply* syncPingReplyDeserialize3(void* buf, int32_t bufLen) {
   }
   uint64_t len;
   char*    data = NULL;
-  if (tDecodeBinary(&decoder, (const void**)(&data), &len) < 0) {
+  if (tDecodeBinary(&decoder, (const uint8_t**)(&data), &len) < 0) {
     return NULL;
   }
   assert(len = pMsg->dataLen);