From 7c2048e7df47e16ac3430a6ff90d1dae2815aafd Mon Sep 17 00:00:00 2001 From: Liu Jicong Date: Fri, 5 Nov 2021 15:42:28 +0800 Subject: [PATCH] implement tqOpen and tqPersist --- include/server/vnode/tq/tq.h | 3 - source/dnode/vnode/tq/inc/tqMetaStore.h | 29 ++- source/dnode/vnode/tq/src/tqMetaStore.c | 287 ++++++++++++++-------- source/dnode/vnode/tq/test/tqMetaTest.cpp | 39 ++- 4 files changed, 247 insertions(+), 111 deletions(-) diff --git a/include/server/vnode/tq/tq.h b/include/server/vnode/tq/tq.h index 4a93491056..3aeaf9acb6 100644 --- 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 diff --git a/source/dnode/vnode/tq/inc/tqMetaStore.h b/source/dnode/vnode/tq/inc/tqMetaStore.h index f8700e065f..52cc767409 100644 --- 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); diff --git a/source/dnode/vnode/tq/src/tqMetaStore.c b/source/dnode/vnode/tq/src/tqMetaStore.c index 5dac02ff67..a4c2b90491 100644 --- 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; diff --git a/source/dnode/vnode/tq/test/tqMetaTest.cpp b/source/dnode/vnode/tq/test/tqMetaTest.cpp index 8afb10e824..20a0368c4c 100644 --- 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); +}