implement tqOpen and tqPersist

2021-11-05 15:42:28 +08:00 · 2021-11-05 15:42:28 +08:00 · 7c2048e7df
parent f599285189
commit 7c2048e7df
4 changed files with 247 additions and 111 deletions
--- a/include/server/vnode/tq/tq.h
+++ b/include/server/vnode/tq/tq.h
@ -19,9 +19,6 @@
 #include "os.h"
 #include "tutil.h"

-#define TQ_ACTION_INSERT 0x7f7f7f7fULL
-#define TQ_ACTION_DELETE 0x80808080ULL
-
 #ifdef __cplusplus
 extern "C" {
 #endif
--- a/source/dnode/vnode/tq/inc/tqMetaStore.h
+++ b/source/dnode/vnode/tq/inc/tqMetaStore.h
@ -37,6 +37,24 @@ inline static int TqEmptyTail() { //16
  return TQ_PAGE_SIZE - TqMaxEntryOnePage();
 }

+#define TQ_ACTION_CONST      0
+#define TQ_ACTION_INUSE      1
+#define TQ_ACTION_INUSE_CONT 2
+#define TQ_ACTION_INTXN      3
+
+#define TQ_SVER              0
+
+static const int8_t TQ_CONST_DELETE = TQ_ACTION_CONST;
+#define TQ_DELETE_TOKEN  (void*)&TQ_CONST_DELETE
+
+typedef struct TqSerializedHead {
+  int16_t ver;
+  int16_t action;
+  int32_t checksum;
+  int64_t ssize;
+  char    content[];
+} TqSerializedHead;
+
 typedef struct TqMetaHandle {
  int64_t key;
  int64_t offset;
@ -61,14 +79,14 @@ typedef struct TqMetaStore {
  int fileFd; //TODO:temporaral use, to be replaced by unified tfile
  int idxFd;  //TODO:temporaral use, to be replaced by unified tfile
  char* dirPath;
-  int (*serializer)(const void* pObj, void** ppBytes);
-  const void* (*deserializer)(const void* pBytes, void** ppObj);
+  int (*serializer)(const void* pObj, TqSerializedHead** ppHead);
+  const void* (*deserializer)(const TqSerializedHead* pHead, void** ppObj);
  void  (*deleter)(void*);
 } TqMetaStore;

 TqMetaStore*  tqStoreOpen(const char* path,
-    int serializer(const void* pObj, void** ppBytes),
-    const void* deserializer(const void* pBytes, void** ppObj),
+    int serializer(const void* pObj, TqSerializedHead** ppHead),
+    const void* deserializer(const TqSerializedHead* pHead, void** ppObj),
    void deleter(void* pObj));
 int32_t       tqStoreClose(TqMetaStore*);
 //int32_t       tqStoreDelete(TqMetaStore*);
@ -82,7 +100,8 @@ int32_t tqHandleCopyPut(TqMetaStore*, int64_t key, void* value, size_t vsize);
 int32_t tqHandleCommit(TqMetaStore*, int64_t key);
 //delete uncommitted
 int32_t tqHandleAbort(TqMetaStore*, int64_t key);
-//delete committed
+//delete committed kv pair
+//notice that a delete action still needs to be committed
 int32_t tqHandleDel(TqMetaStore*, int64_t key);
 //delete both committed and uncommitted
 int32_t tqHandleClear(TqMetaStore*, int64_t key);
--- a/source/dnode/vnode/tq/src/tqMetaStore.c
+++ b/source/dnode/vnode/tq/src/tqMetaStore.c
@ -26,14 +26,24 @@
 static int32_t tqHandlePutCommitted(TqMetaStore*, int64_t key, void* value);
 static void*   tqHandleGetUncommitted(TqMetaStore*, int64_t key);

+static inline void tqLinkUnpersist(TqMetaStore *pMeta, TqMetaList* pNode) {
+    if(pNode->unpersistNext == NULL) {
+      pNode->unpersistNext = pMeta->unpersistHead->unpersistNext;
+      pNode->unpersistPrev = pMeta->unpersistHead;
+      pMeta->unpersistHead->unpersistNext->unpersistPrev = pNode;
+      pMeta->unpersistHead->unpersistNext = pNode;
+    }
+}
+
+
 typedef struct TqMetaPageBuf {
  int16_t offset;
  char buffer[TQ_PAGE_SIZE];
 } TqMetaPageBuf;

 TqMetaStore* tqStoreOpen(const char* path,
-    int serializer(const void* pObj, void** ppBytes),
-    const void* deserializer(const void* pBytes, void** ppObj),
+    int serializer(const void* pObj, TqSerializedHead** ppHead),
+    const void* deserializer(const TqSerializedHead* pHead, void** ppObj),
    void deleter(void* pObj)) {
  TqMetaStore* pMeta = malloc(sizeof(TqMetaStore)); 
  if(pMeta == NULL) {
@ -94,12 +104,12 @@ TqMetaStore* tqStoreOpen(const char* path,

  //read idx file and load into memory
  char idxBuf[TQ_PAGE_SIZE];
-  char* dataBuf = malloc(TQ_PAGE_SIZE);
-  if(dataBuf == NULL) {
+  TqSerializedHead* serializedObj = malloc(TQ_PAGE_SIZE);
+  if(serializedObj == NULL) {
    //TODO:memory insufficient
  }
-  int dataBufSize = TQ_PAGE_SIZE;
-  int idxRead, dataReadSize;
+  int idxRead;
+  int allocated = TQ_PAGE_SIZE;
  while((idxRead = read(idxFd, idxBuf, TQ_PAGE_SIZE))) {
    if(idxRead == -1) {
      //TODO: handle error
@ -114,26 +124,82 @@ TqMetaStore* tqStoreOpen(const char* path,
      memset(pNode, 0, sizeof(TqMetaList));
      memcpy(&pNode->handle, &idxBuf[i], TQ_IDX_ENTRY_SIZE);
      lseek(fileFd, pNode->handle.offset, SEEK_CUR);
-      if(dataBufSize < pNode->handle.serializedSize) {
-        void *ptr = realloc(dataBuf, pNode->handle.serializedSize);
+      if(allocated < pNode->handle.serializedSize) {
+        void *ptr = realloc(serializedObj, pNode->handle.serializedSize);
        if(ptr == NULL) {
          //TODO: memory insufficient
        }
-        dataBuf = ptr;
-        dataBufSize = pNode->handle.serializedSize;
+        serializedObj = ptr;
+        allocated = pNode->handle.serializedSize;
      }
-      if(read(fileFd, dataBuf, pNode->handle.serializedSize) != pNode->handle.serializedSize) {
+      serializedObj->ssize = pNode->handle.serializedSize;
+      if(read(fileFd, serializedObj, pNode->handle.serializedSize) != pNode->handle.serializedSize) {
        //TODO: read error
      }
-      pMeta->deserializer(dataBuf, &pNode->handle.valueInUse);
+      if(serializedObj->action == TQ_ACTION_INUSE) {
+        if(serializedObj->ssize != sizeof(TqSerializedHead)) {
+          pMeta->deserializer(serializedObj, &pNode->handle.valueInUse);
+        } else {
+          pNode->handle.valueInUse = TQ_DELETE_TOKEN;
+        }
+      } else if(serializedObj->action == TQ_ACTION_INTXN) {
+        if(serializedObj->ssize != sizeof(TqSerializedHead)) {
+          pMeta->deserializer(serializedObj, &pNode->handle.valueInTxn);
+        } else {
+          pNode->handle.valueInTxn = TQ_DELETE_TOKEN;
+        }
+      } else if(serializedObj->action == TQ_ACTION_INUSE_CONT) {
+        if(serializedObj->ssize != sizeof(TqSerializedHead)) {
+          pMeta->deserializer(serializedObj, &pNode->handle.valueInUse);
+        } else {
+          pNode->handle.valueInUse = TQ_DELETE_TOKEN;
+        }
+        serializedObj = POINTER_SHIFT(serializedObj, serializedObj->ssize);
+        if(serializedObj->ssize != sizeof(TqSerializedHead)) {
+          pMeta->deserializer(serializedObj, &pNode->handle.valueInTxn);
+        } else {
+          pNode->handle.valueInTxn = TQ_DELETE_TOKEN;
+        }
+      } else {
+        ASSERT(0);
+      }

      //put into list
      int bucketKey = pNode->handle.key & TQ_BUCKET_SIZE;
-      pNode->next = pMeta->bucket[bucketKey];
-      pMeta->bucket[bucketKey] = pNode;
+      TqMetaList* pBucketNode = pMeta->bucket[bucketKey];
+      if(pBucketNode == NULL) {
+        pMeta->bucket[bucketKey] = pNode;
+      } else if(pBucketNode->handle.key == pNode->handle.key) {
+        pNode->next = pBucketNode->next;
+        pMeta->bucket[bucketKey] = pNode;
+      } else {
+        while(pBucketNode->next &&
+            pBucketNode->next->handle.key == pNode->handle.key) {
+          pBucketNode = pBucketNode->next; 
+        }
+        if(pBucketNode->next) {
+          ASSERT(pBucketNode->next->handle.key == pNode->handle.key);
+          TqMetaList *pNodeTmp = pBucketNode->next;
+          pBucketNode->next = pNodeTmp->next;
+          pBucketNode = pNodeTmp;
+        } else {
+          pBucketNode = NULL;
+        }
+      }
+      if(pBucketNode) {
+        if(pBucketNode->handle.valueInUse
+            && pBucketNode->handle.valueInUse != TQ_DELETE_TOKEN) {
+          pMeta->deleter(pBucketNode->handle.valueInUse);
+        }
+        if(pBucketNode->handle.valueInTxn
+            && pBucketNode->handle.valueInTxn != TQ_DELETE_TOKEN) {
+          pMeta->deleter(pBucketNode->handle.valueInTxn);
+        }
+        free(pBucketNode);
+      }
    }
  }
-  free(dataBuf);
+  free(serializedObj);
  return pMeta;
 }

@ -146,14 +212,15 @@ int32_t tqStoreClose(TqMetaStore* pMeta) {
  //free memory
  for(int i = 0; i < TQ_BUCKET_SIZE; i++) {
    TqMetaList* pNode = pMeta->bucket[i];
-    pMeta->bucket[i] = NULL;
    while(pNode) {
      ASSERT(pNode->unpersistNext == NULL);
      ASSERT(pNode->unpersistPrev == NULL);
-      if(pNode->handle.valueInTxn) {
+      if(pNode->handle.valueInTxn
+          && pNode->handle.valueInTxn != TQ_DELETE_TOKEN) {
        pMeta->deleter(pNode->handle.valueInTxn);
      }
-      if(pNode->handle.valueInUse) {
+      if(pNode->handle.valueInUse
+          && pNode->handle.valueInUse != TQ_DELETE_TOKEN) {
        pMeta->deleter(pNode->handle.valueInUse);
      }
      TqMetaList* next = pNode->next;
@ -175,10 +242,12 @@ int32_t tqStoreDelete(TqMetaStore* pMeta) {
    TqMetaList* pNode = pMeta->bucket[i];
    pMeta->bucket[i] = NULL;
    while(pNode) {
-      if(pNode->handle.valueInTxn) {
+      if(pNode->handle.valueInTxn
+          && pNode->handle.valueInTxn != TQ_DELETE_TOKEN) {
        pMeta->deleter(pNode->handle.valueInTxn);
      }
-      if(pNode->handle.valueInUse) {
+      if(pNode->handle.valueInUse
+          && pNode->handle.valueInUse != TQ_DELETE_TOKEN) {
        pMeta->deleter(pNode->handle.valueInUse);
      }
      TqMetaList* next = pNode->next;
@ -199,73 +268,89 @@ int32_t tqStorePersist(TqMetaStore* pMeta) {
  int64_t* bufPtr = (int64_t*)writeBuf;
  TqMetaList *pHead = pMeta->unpersistHead;
  TqMetaList *pNode = pHead->unpersistNext;
+  TqSerializedHead *pSHead = malloc(sizeof(TqSerializedHead));
+  if(pSHead == NULL) {
+    //TODO: memory error
+    return -1;
+  }
+  pSHead->ver = TQ_SVER;
+  pSHead->checksum = 0;
+  pSHead->ssize = sizeof(TqSerializedHead);
+  int allocatedSize = sizeof(TqSerializedHead);
+  int offset = lseek(pMeta->fileFd, 0, SEEK_CUR);
  while(pHead != pNode) {
-    if(pNode->handle.valueInUse == NULL) {
-      //put delete token in data file
-      uint32_t delete = TQ_ACTION_DELETE;
-      int nBytes = write(pMeta->fileFd, &delete, sizeof(uint32_t));
-      ASSERT(nBytes == sizeof(uint32_t));
+    int nBytes = 0;

-      //remove from list
+    if(pNode->handle.valueInUse) {
+      if(pNode->handle.valueInTxn) {
+        pSHead->action = TQ_ACTION_INUSE_CONT;
+      } else {
+        pSHead->action = TQ_ACTION_INUSE;
+      }
+
+      if(pNode->handle.valueInUse == TQ_DELETE_TOKEN) {
+        pSHead->ssize = sizeof(TqSerializedHead);
+      } else {
+        pMeta->serializer(pNode->handle.valueInUse, &pSHead);
+      }
+      nBytes = write(pMeta->fileFd, pSHead, pSHead->ssize);
+      ASSERT(nBytes == pSHead->ssize);
+    }
+
+    if(pNode->handle.valueInTxn) {
+      pSHead->action = TQ_ACTION_INTXN;
+      if(pNode->handle.valueInTxn == TQ_DELETE_TOKEN) {
+        pSHead->ssize = sizeof(TqSerializedHead);
+      } else {
+        pMeta->serializer(pNode->handle.valueInTxn, &pSHead);
+      }
+      int nBytesTxn = write(pMeta->fileFd, pSHead, pSHead->ssize);
+      ASSERT(nBytesTxn == pSHead->ssize);
+      nBytes += nBytesTxn;
+    }
+
+    //write idx file
+    //TODO: endian check and convert
+    *(bufPtr++) = pNode->handle.key;
+    *(bufPtr++) = pNode->handle.offset;
+    *(bufPtr++) = (int64_t)nBytes;
+    if((char*)(bufPtr + 3) > writeBuf + TQ_PAGE_SIZE) {
+      nBytes = write(pMeta->idxFd, writeBuf, sizeof(writeBuf));
+      //TODO: handle error with tfile
+      ASSERT(nBytes == sizeof(writeBuf));
+      memset(writeBuf, 0, TQ_PAGE_SIZE);
+      bufPtr = (int64_t*)writeBuf;
+    }
+    //remove from unpersist list
+    pHead->unpersistNext = pNode->unpersistNext;
+    pHead->unpersistNext->unpersistPrev = pHead;
+    pNode->unpersistPrev = pNode->unpersistNext = NULL;
+    pNode = pHead->unpersistNext;
+
+    //remove from bucket
+    if(pNode->handle.valueInUse == TQ_DELETE_TOKEN &&
+        pNode->handle.valueInTxn == NULL
+        ) {
      int bucketKey = pNode->handle.key & TQ_BUCKET_SIZE;
      TqMetaList* pBucketHead = pMeta->bucket[bucketKey];
      if(pBucketHead == pNode) {
-        pMeta->bucket[bucketKey] = pBucketHead->next;
+        pMeta->bucket[bucketKey] = pNode->next;
      } else {
        TqMetaList* pBucketNode = pBucketHead;
        while(pBucketNode->next != NULL
            && pBucketNode->next != pNode) {
          pBucketNode = pBucketNode->next; 
        }
-        if(pBucketNode->next != NULL) {
-          ASSERT(pBucketNode->next == pNode);
-          pBucketNode->next = pNode->next;
-          if(pNode->handle.valueInUse) {
-            pMeta->deleter(pNode->handle.valueInUse);
-            pNode->handle.valueInUse = NULL;
-          }
-          free(pNode);
-        }
-      }
-    } else {
-      //TODO: do not allocate each time
-      //serialize
-      void* pBytes = NULL;
-      int sz = pMeta->serializer(pNode->handle.valueInUse, &pBytes);
-      ASSERT(pBytes != NULL);
-      //get current offset
-      //append data
-      int64_t offset = lseek(pMeta->fileFd, 0, SEEK_CUR);
-      int nBytes = write(pMeta->fileFd, pBytes, sz);
-      free(pBytes);
-      //TODO: handle error in tfile
-      ASSERT(nBytes == sz);
-
-      pNode->handle.offset = offset;
-      pNode->handle.serializedSize = sz;
-
-      //write idx
-      //TODO: endian check and convert
-      *(bufPtr++) = pNode->handle.key;
-      *(bufPtr++) = pNode->handle.offset;
-      *(bufPtr++) = (int64_t)sz;
-      if((char*)(bufPtr + 3) > writeBuf + TQ_PAGE_SIZE) {
-        nBytes = write(pMeta->idxFd, writeBuf, sizeof(writeBuf));
-        //TODO: handle error in tfile
-        ASSERT(nBytes == sizeof(writeBuf));
-        memset(writeBuf, 0, TQ_PAGE_SIZE);
-        bufPtr = (int64_t*)writeBuf;
+        //impossible for pBucket->next == NULL
+        ASSERT(pBucketNode->next == pNode);
+        pBucketNode->next = pNode->next;
      }
+      free(pNode);
    }
-
-    //remove from unpersist list
-    pHead->unpersistNext = pNode->unpersistNext;
-    pHead->unpersistNext->unpersistPrev = pHead;
-
-    pNode->unpersistPrev = pNode->unpersistNext = NULL;
-    pNode = pHead->unpersistNext;
  }
+
  //write left bytes
+  free(pSHead);
  if((char*)bufPtr != writeBuf) {
    int used = (char*)bufPtr - writeBuf;
    int nBytes = write(pMeta->idxFd, writeBuf, used);
@ -284,7 +369,8 @@ static int32_t tqHandlePutCommitted(TqMetaStore* pMeta, int64_t key, void* value
  while(pNode) {
    if(pNode->handle.key == key) {
      //TODO: think about thread safety
-      if(pNode->handle.valueInUse) {
+      if(pNode->handle.valueInUse
+          && pNode->handle.valueInUse != TQ_DELETE_TOKEN) {
        pMeta->deleter(pNode->handle.valueInUse);
      }
      //change pointer ownership
@ -333,11 +419,13 @@ int32_t tqHandleMovePut(TqMetaStore* pMeta, int64_t key, void* value) {
  while(pNode) {
    if(pNode->handle.key == key) {
      //TODO: think about thread safety
-      if(pNode->handle.valueInTxn) {
+      if(pNode->handle.valueInTxn
+          && pNode->handle.valueInTxn != TQ_DELETE_TOKEN) {
        pMeta->deleter(pNode->handle.valueInTxn);
      }
      //change pointer ownership
      pNode->handle.valueInTxn = value;
+      tqLinkUnpersist(pMeta, pNode);
      return 0;
    } else {
      pNode = pNode->next;
@ -353,6 +441,7 @@ int32_t tqHandleMovePut(TqMetaStore* pMeta, int64_t key, void* value) {
  pNewNode->handle.valueInTxn = value;
  pNewNode->next = pMeta->bucket[bucketKey];
  pMeta->bucket[bucketKey] = pNewNode;
+  tqLinkUnpersist(pMeta, pNewNode);
  return 0;
 }

@ -368,11 +457,13 @@ int32_t tqHandleCopyPut(TqMetaStore* pMeta, int64_t key, void* value, size_t vsi
  while(pNode) {
    if(pNode->handle.key == key) {
      //TODO: think about thread safety
-      if(pNode->handle.valueInTxn) {
+      if(pNode->handle.valueInTxn
+          && pNode->handle.valueInTxn != TQ_DELETE_TOKEN) {
        pMeta->deleter(pNode->handle.valueInTxn);
      }
      //change pointer ownership
      pNode->handle.valueInTxn = vmem;
+      tqLinkUnpersist(pMeta, pNode);
      return 0;
    } else {
      pNode = pNode->next;
@ -388,6 +479,7 @@ int32_t tqHandleCopyPut(TqMetaStore* pMeta, int64_t key, void* value, size_t vsi
  pNewNode->handle.valueInTxn = vmem;
  pNewNode->next = pMeta->bucket[bucketKey];
  pMeta->bucket[bucketKey] = pNewNode;
+  tqLinkUnpersist(pMeta, pNewNode);
  return 0;
 }

@ -396,7 +488,8 @@ static void* tqHandleGetUncommitted(TqMetaStore* pMeta, int64_t key) {
  TqMetaList* pNode = pMeta->bucket[bucketKey];
  while(pNode) {
    if(pNode->handle.key == key) {
-      if(pNode->handle.valueInTxn != NULL) {
+      if(pNode->handle.valueInTxn != NULL
+          && pNode->handle.valueInTxn != TQ_DELETE_TOKEN) {
        return pNode->handle.valueInTxn;
      } else {
        return NULL;
@ -413,17 +506,13 @@ int32_t tqHandleCommit(TqMetaStore* pMeta, int64_t key) {
  TqMetaList* pNode = pMeta->bucket[bucketKey];
  while(pNode) {
    if(pNode->handle.key == key) {
-      if(pNode->handle.valueInUse) {
+      if(pNode->handle.valueInUse
+          && pNode->handle.valueInUse != TQ_DELETE_TOKEN) {
        pMeta->deleter(pNode->handle.valueInUse);
      }
      pNode->handle.valueInUse = pNode->handle.valueInTxn;
      pNode->handle.valueInTxn = NULL;
-      if(pNode->unpersistNext == NULL) {
-        pNode->unpersistNext = pMeta->unpersistHead->unpersistNext;
-        pNode->unpersistPrev = pMeta->unpersistHead;
-        pMeta->unpersistHead->unpersistNext->unpersistPrev = pNode;
-        pMeta->unpersistHead->unpersistNext = pNode;
-      }
+      tqLinkUnpersist(pMeta, pNode);
      return 0;
    } else {
      pNode = pNode->next;
@ -437,9 +526,12 @@ int32_t tqHandleAbort(TqMetaStore* pMeta, int64_t key) {
  TqMetaList* pNode = pMeta->bucket[bucketKey];
  while(pNode) {
    if(pNode->handle.key == key) {
-      if(pNode->handle.valueInTxn != NULL) {
-        pMeta->deleter(pNode->handle.valueInTxn);
+      if(pNode->handle.valueInTxn) {
+        if(pNode->handle.valueInTxn != TQ_DELETE_TOKEN) {
+          pMeta->deleter(pNode->handle.valueInTxn);
+        }
        pNode->handle.valueInTxn = NULL;
+        tqLinkUnpersist(pMeta, pNode);
        return 0;
      }
      return -1;
@ -454,9 +546,11 @@ int32_t tqHandleDel(TqMetaStore* pMeta, int64_t key) {
  int64_t bucketKey = key & TQ_BUCKET_SIZE;
  TqMetaList* pNode = pMeta->bucket[bucketKey];
  while(pNode) {
-    if(pNode->handle.key == key) {
+      if(pNode->handle.valueInTxn
+          && pNode->handle.valueInTxn != TQ_DELETE_TOKEN) {
      pMeta->deleter(pNode->handle.valueInTxn);
-      pNode->handle.valueInTxn = NULL;
+      pNode->handle.valueInTxn = TQ_DELETE_TOKEN;
+      tqLinkUnpersist(pMeta, pNode);
      return 0;
    } else {
      pNode = pNode->next;
@ -474,21 +568,20 @@ int32_t tqHandleClear(TqMetaStore* pMeta, int64_t key) {
    if(pNode->handle.key == key) {
      if(pNode->handle.valueInUse != NULL) {
        exist = true;
-        pMeta->deleter(pNode->handle.valueInUse);
-        pNode->handle.valueInUse = NULL;
+        if(pNode->handle.valueInUse != TQ_DELETE_TOKEN) {
+          pMeta->deleter(pNode->handle.valueInUse);
+        }
+        pNode->handle.valueInUse = TQ_DELETE_TOKEN;
      }
      if(pNode->handle.valueInTxn != NULL) {
        exist = true;
-        pMeta->deleter(pNode->handle.valueInTxn);
-        pNode->handle.valueInTxn = NULL;
+        if(pNode->handle.valueInTxn != TQ_DELETE_TOKEN) {
+          pMeta->deleter(pNode->handle.valueInTxn);
+        }
+        pNode->handle.valueInTxn = TQ_DELETE_TOKEN;
      }
      if(exist) {
-        if(pNode->unpersistNext == NULL) {
-          pNode->unpersistNext = pMeta->unpersistHead->unpersistNext;
-          pNode->unpersistPrev = pMeta->unpersistHead;
-          pMeta->unpersistHead->unpersistNext->unpersistPrev = pNode;
-          pMeta->unpersistHead->unpersistNext = pNode;
-        }
+        tqLinkUnpersist(pMeta, pNode);
        return 0;
      }
      return -1;
--- a/source/dnode/vnode/tq/test/tqMetaTest.cpp
+++ b/source/dnode/vnode/tq/test/tqMetaTest.cpp
@ -9,19 +9,22 @@ struct Foo {
  int32_t a;
 };

-int FooSerializer(const void* pObj, void** ppBytes) {
+int FooSerializer(const void* pObj, TqSerializedHead** ppHead) {
  Foo* foo = (Foo*) pObj;
-  *ppBytes = realloc(*ppBytes, sizeof(int32_t));
-  **(int32_t**)ppBytes = foo->a;
-  return sizeof(int32_t);
+  if((*ppHead) == NULL || (*ppHead)->ssize < sizeof(TqSerializedHead) + sizeof(int32_t)) {
+    *ppHead = (TqSerializedHead*)realloc(*ppHead, sizeof(TqSerializedHead) + sizeof(int32_t));
+    (*ppHead)->ssize = sizeof(TqSerializedHead) + sizeof(int32_t);
+  }
+  *(int32_t*)(*ppHead)->content = foo->a;
+  return (*ppHead)->ssize;
 }

-const void* FooDeserializer(const void* pBytes, void** ppObj) {
+const void* FooDeserializer(const TqSerializedHead* pHead, void** ppObj) {
  if(*ppObj == NULL) {
    *ppObj = realloc(*ppObj, sizeof(int32_t));
  }
  Foo* pFoo = *(Foo**)ppObj;
-  pFoo->a = *(int32_t*)pBytes; 
+  pFoo->a = *(int32_t*)pHead->content; 
  return NULL;
 }

@ -104,3 +107,27 @@ TEST_F(TqMetaTest, abortTest) {
  pFoo = (Foo*) tqHandleGet(pMeta, 1);
  EXPECT_EQ(pFoo == NULL, true);
 }
+
+TEST_F(TqMetaTest, deleteTest) {
+  Foo* pFoo = (Foo*)malloc(sizeof(Foo));
+  pFoo->a = 3;
+  tqHandleMovePut(pMeta, 1, pFoo);
+
+  pFoo = (Foo*) tqHandleGet(pMeta, 1);
+  EXPECT_EQ(pFoo == NULL, true);
+
+  tqHandleCommit(pMeta, 1);
+
+  pFoo = (Foo*) tqHandleGet(pMeta, 1);
+  ASSERT_EQ(pFoo != NULL, true);
+  EXPECT_EQ(pFoo->a, 3);
+
+  tqHandleDel(pMeta, 1);
+  pFoo = (Foo*) tqHandleGet(pMeta, 1);
+  ASSERT_EQ(pFoo != NULL, true);
+  EXPECT_EQ(pFoo->a, 3);
+
+  tqHandleCommit(pMeta, 1);
+  pFoo = (Foo*) tqHandleGet(pMeta, 1);
+  EXPECT_EQ(pFoo == NULL, true);
+}