xxq250
/
homework-jianmu
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

test: add unitest for sdb

This commit is contained in:
Shengliang Guan 2022-04-28 20:17:37 +08:00
parent ef2b59580e
commit a13cb870f3
3 changed files with 492 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

528
source/dnode/mnode/impl/test/sdb/sdbTest.cpp
View File

@ -105,6 +105,48 @@ SSdbRaw *strEncode(SStrObj *pObj) {
return pRaw; return pRaw;
} }
SSdbRaw *i32Encode(SI32Obj *pObj) {
int32_t dataPos = 0;
SSdbRaw *pRaw = sdbAllocRaw(SDB_VGROUP, 2, sizeof(SI32Obj));
sdbSetRawInt32(pRaw, dataPos, pObj->key);
dataPos += sizeof(pObj->key);
sdbSetRawInt8(pRaw, dataPos, pObj->v8);
dataPos += sizeof(pObj->v8);
sdbSetRawInt16(pRaw, dataPos, pObj->v16);
dataPos += sizeof(pObj->v16);
sdbSetRawInt32(pRaw, dataPos, pObj->v32);
dataPos += sizeof(pObj->v32);
sdbSetRawInt64(pRaw, dataPos, pObj->v64);
dataPos += sizeof(pObj->v64);
sdbSetRawBinary(pRaw, dataPos, pObj->vstr, sizeof(pObj->vstr));
dataPos += sizeof(pObj->vstr);
sdbSetRawDataLen(pRaw, dataPos);
return pRaw;
}
SSdbRaw *i64Encode(SI64Obj *pObj) {
int32_t dataPos = 0;
SSdbRaw *pRaw = sdbAllocRaw(SDB_CONSUMER, 3, sizeof(SI64Obj));
sdbSetRawInt64(pRaw, dataPos, pObj->key);
dataPos += sizeof(pObj->key);
sdbSetRawInt8(pRaw, dataPos, pObj->v8);
dataPos += sizeof(pObj->v8);
sdbSetRawInt16(pRaw, dataPos, pObj->v16);
dataPos += sizeof(pObj->v16);
sdbSetRawInt32(pRaw, dataPos, pObj->v32);
dataPos += sizeof(pObj->v32);
sdbSetRawInt64(pRaw, dataPos, pObj->v64);
dataPos += sizeof(pObj->v64);
sdbSetRawBinary(pRaw, dataPos, pObj->vstr, sizeof(pObj->vstr));
dataPos += sizeof(pObj->vstr);
sdbSetRawDataLen(pRaw, dataPos);
return pRaw;
}
SSdbRow *strDecode(SSdbRaw *pRaw) { SSdbRow *strDecode(SSdbRaw *pRaw) {
int8_t sver = 0; int8_t sver = 0;
if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL; if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL;
@ -133,12 +175,80 @@ SSdbRow *strDecode(SSdbRaw *pRaw) {
return pRow; return pRow;
} }
SSdbRow *i32Decode(SSdbRaw *pRaw) {
int8_t sver = 0;
if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL;
if (sver != 2) return NULL;
SSdbRow *pRow = sdbAllocRow(sizeof(SI32Obj));
if (pRow == NULL) return NULL;
SI32Obj *pObj = (SI32Obj *)sdbGetRowObj(pRow);
if (pObj == NULL) return NULL;
int32_t dataPos = 0;
sdbGetRawInt32(pRaw, dataPos, &pObj->key);
dataPos += sizeof(pObj->key);
sdbGetRawInt8(pRaw, dataPos, &pObj->v8);
dataPos += sizeof(pObj->v8);
sdbGetRawInt16(pRaw, dataPos, &pObj->v16);
dataPos += sizeof(pObj->v16);
sdbGetRawInt32(pRaw, dataPos, &pObj->v32);
dataPos += sizeof(pObj->v32);
sdbGetRawInt64(pRaw, dataPos, &pObj->v64);
dataPos += sizeof(pObj->v64);
sdbGetRawBinary(pRaw, dataPos, pObj->vstr, sizeof(pObj->vstr));
dataPos += sizeof(pObj->vstr);
return pRow;
}
SSdbRow *i64Decode(SSdbRaw *pRaw) {
int8_t sver = 0;
if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL;
if (sver != 3) return NULL;
SSdbRow *pRow = sdbAllocRow(sizeof(SI64Obj));
if (pRow == NULL) return NULL;
SI64Obj *pObj = (SI64Obj *)sdbGetRowObj(pRow);
if (pObj == NULL) return NULL;
int32_t dataPos = 0;
sdbGetRawInt64(pRaw, dataPos, &pObj->key);
dataPos += sizeof(pObj->key);
sdbGetRawInt8(pRaw, dataPos, &pObj->v8);
dataPos += sizeof(pObj->v8);
sdbGetRawInt16(pRaw, dataPos, &pObj->v16);
dataPos += sizeof(pObj->v16);
sdbGetRawInt32(pRaw, dataPos, &pObj->v32);
dataPos += sizeof(pObj->v32);
sdbGetRawInt64(pRaw, dataPos, &pObj->v64);
dataPos += sizeof(pObj->v64);
sdbGetRawBinary(pRaw, dataPos, pObj->vstr, sizeof(pObj->vstr));
dataPos += sizeof(pObj->vstr);
return pRow;
}
int32_t strInsert(SSdb *pSdb, SStrObj *pObj) { int32_t strInsert(SSdb *pSdb, SStrObj *pObj) {
SMnode *pMnode = pSdb->pMnode; SMnode *pMnode = pSdb->pMnode;
pMnode->insertTimes++; pMnode->insertTimes++;
return 0; return 0;
} }
int32_t i32Insert(SSdb *pSdb, SI32Obj *pObj) {
SMnode *pMnode = pSdb->pMnode;
pMnode->insertTimes++;
return 0;
}
int32_t i64Insert(SSdb *pSdb, SI64Obj *pObj) {
SMnode *pMnode = pSdb->pMnode;
pMnode->insertTimes++;
return 0;
}
int32_t strDelete(SSdb *pSdb, SStrObj *pObj, bool callFunc) { int32_t strDelete(SSdb *pSdb, SStrObj *pObj, bool callFunc) {
if (callFunc) { if (callFunc) {
SMnode *pMnode = pSdb->pMnode; SMnode *pMnode = pSdb->pMnode;
@ -147,6 +257,22 @@ int32_t strDelete(SSdb *pSdb, SStrObj *pObj, bool callFunc) {
return 0; return 0;
} }
int32_t i32Delete(SSdb *pSdb, SI32Obj *pObj, bool callFunc) {
if (callFunc) {
SMnode *pMnode = pSdb->pMnode;
pMnode->deleteTimes++;
}
return 0;
}
int32_t i64Delete(SSdb *pSdb, SI64Obj *pObj, bool callFunc) {
if (callFunc) {
SMnode *pMnode = pSdb->pMnode;
pMnode->deleteTimes++;
}
return 0;
}
int32_t strUpdate(SSdb *pSdb, SStrObj *pOld, SStrObj *pNew) { int32_t strUpdate(SSdb *pSdb, SStrObj *pOld, SStrObj *pNew) {
pOld->v8 = pNew->v8; pOld->v8 = pNew->v8;
pOld->v16 = pNew->v16; pOld->v16 = pNew->v16;
@ -156,6 +282,24 @@ int32_t strUpdate(SSdb *pSdb, SStrObj *pOld, SStrObj *pNew) {
return 0; return 0;
} }
int32_t i32Update(SSdb *pSdb, SI32Obj *pOld, SI32Obj *pNew) {
pOld->v8 = pNew->v8;
pOld->v16 = pNew->v16;
pOld->v32 = pNew->v32;
pOld->v64 = pNew->v64;
strcpy(pOld->vstr, pNew->vstr);
return 0;
}
int32_t i64Update(SSdb *pSdb, SI64Obj *pOld, SI64Obj *pNew) {
pOld->v8 = pNew->v8;
pOld->v16 = pNew->v16;
pOld->v32 = pNew->v32;
pOld->v64 = pNew->v64;
strcpy(pOld->vstr, pNew->vstr);
return 0;
}
void strSetDefault(SStrObj *pObj, int32_t index) { void strSetDefault(SStrObj *pObj, int32_t index) {
memset(pObj, 0, sizeof(SStrObj)); memset(pObj, 0, sizeof(SStrObj));
snprintf(pObj->key, sizeof(pObj->key), "k%d", index * 1000); snprintf(pObj->key, sizeof(pObj->key), "k%d", index * 1000);
@ -166,6 +310,26 @@ void strSetDefault(SStrObj *pObj, int32_t index) {
snprintf(pObj->vstr, sizeof(pObj->vstr), "v%d", index * 1000); snprintf(pObj->vstr, sizeof(pObj->vstr), "v%d", index * 1000);
} }
void i32SetDefault(SI32Obj *pObj, int32_t index) {
memset(pObj, 0, sizeof(SI32Obj));
pObj->key = index;
pObj->v8 = index;
pObj->v16 = index;
pObj->v32 = index * 1000;
pObj->v64 = index * 1000;
snprintf(pObj->vstr, sizeof(pObj->vstr), "v%d", index * 1000);
}
void i64SetDefault(SI64Obj *pObj, int32_t index) {
memset(pObj, 0, sizeof(SI64Obj));
pObj->key = index;
pObj->v8 = index;
pObj->v16 = index;
pObj->v32 = index * 1000;
pObj->v64 = index * 1000;
snprintf(pObj->vstr, sizeof(pObj->vstr), "v%d", index * 1000);
}
int32_t strDefault(SMnode *pMnode) { int32_t strDefault(SMnode *pMnode) {
SStrObj strObj; SStrObj strObj;
SSdbRaw *pRaw = NULL; SSdbRaw *pRaw = NULL;
@ -201,7 +365,7 @@ bool sdbTraverseFail(SMnode *pMnode, SStrObj *pObj, int32_t *p1, int32_t *p2, in
return false; return false;
} }
TEST_F(MndTestSdb, 01_Write) { TEST_F(MndTestSdb, 01_Write_Str) {
void *pIter = NULL; void *pIter = NULL;
int32_t num = 0; int32_t num = 0;
SStrObj *pObj = NULL; SStrObj *pObj = NULL;
@ -209,6 +373,8 @@ TEST_F(MndTestSdb, 01_Write) {
SSdb *pSdb = NULL; SSdb *pSdb = NULL;
SSdbOpt opt = {0}; SSdbOpt opt = {0};
SStrObj strObj = {0}; SStrObj strObj = {0};
SI32Obj i32Obj = {0};
SI64Obj i64Obj = {0};
SSdbRaw *pRaw = NULL; SSdbRaw *pRaw = NULL;
int32_t p1 = 0; int32_t p1 = 0;
int32_t p2 = 111; int32_t p2 = 111;
@ -220,7 +386,7 @@ TEST_F(MndTestSdb, 01_Write) {
opt.path = "/tmp/mnode_test_sdb"; opt.path = "/tmp/mnode_test_sdb";
taosRemoveDir(opt.path); taosRemoveDir(opt.path);
SSdbTable strTable = { SSdbTable strTable1 = {
.sdbType = SDB_USER, .sdbType = SDB_USER,
.keyType = SDB_KEY_BINARY, .keyType = SDB_KEY_BINARY,
.deployFp = (SdbDeployFp)strDefault, .deployFp = (SdbDeployFp)strDefault,
@ -231,31 +397,53 @@ TEST_F(MndTestSdb, 01_Write) {
.deleteFp = (SdbDeleteFp)strDelete, .deleteFp = (SdbDeleteFp)strDelete,
}; };
SSdbTable strTable2 = {
.sdbType = SDB_VGROUP,
.keyType = SDB_KEY_INT32,
.encodeFp = (SdbEncodeFp)i32Encode,
.decodeFp = (SdbDecodeFp)i32Decode,
.insertFp = (SdbInsertFp)i32Insert,
.updateFp = (SdbUpdateFp)i32Update,
.deleteFp = (SdbDeleteFp)i32Delete,
};
SSdbTable strTable3 = {
.sdbType = SDB_CONSUMER,
.keyType = SDB_KEY_INT64,
.encodeFp = (SdbEncodeFp)i64Encode,
.decodeFp = (SdbDecodeFp)i64Decode,
.insertFp = (SdbInsertFp)i64Insert,
.updateFp = (SdbUpdateFp)i64Update,
.deleteFp = (SdbDeleteFp)i64Delete,
};
pSdb = sdbInit(&opt); pSdb = sdbInit(&opt);
mnode.pSdb = pSdb; mnode.pSdb = pSdb;
ASSERT_NE(pSdb, nullptr); ASSERT_NE(pSdb, nullptr);
ASSERT_EQ(sdbSetTable(pSdb, strTable), 0); ASSERT_EQ(sdbSetTable(pSdb, strTable1), 0);
ASSERT_EQ(sdbSetTable(pSdb, strTable2), 0);
ASSERT_EQ(sdbSetTable(pSdb, strTable3), 0);
ASSERT_EQ(sdbDeploy(pSdb), 0); ASSERT_EQ(sdbDeploy(pSdb), 0);
pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k1000"); pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k1000");
ASSERT_NE(pObj, nullptr); ASSERT_NE(pObj, nullptr);
EXPECT_STREQ(pObj->key, "k1000"); EXPECT_STREQ(pObj->key, "k1000");
EXPECT_STREQ(pObj->vstr, "v1000"); EXPECT_STREQ(pObj->vstr, "v1000");
EXPECT_EQ(pObj->v8, 1); ASSERT_EQ(pObj->v8, 1);
EXPECT_EQ(pObj->v16, 1); ASSERT_EQ(pObj->v16, 1);
EXPECT_EQ(pObj->v32, 1000); ASSERT_EQ(pObj->v32, 1000);
EXPECT_EQ(pObj->v64, 1000); ASSERT_EQ(pObj->v64, 1000);
sdbRelease(pSdb, pObj); sdbRelease(pSdb, pObj);
pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k2000"); pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k2000");
ASSERT_NE(pObj, nullptr); ASSERT_NE(pObj, nullptr);
EXPECT_STREQ(pObj->key, "k2000"); EXPECT_STREQ(pObj->key, "k2000");
EXPECT_STREQ(pObj->vstr, "v2000"); EXPECT_STREQ(pObj->vstr, "v2000");
EXPECT_EQ(pObj->v8, 2); ASSERT_EQ(pObj->v8, 2);
EXPECT_EQ(pObj->v16, 2); ASSERT_EQ(pObj->v16, 2);
EXPECT_EQ(pObj->v32, 2000); ASSERT_EQ(pObj->v32, 2000);
EXPECT_EQ(pObj->v64, 2000); ASSERT_EQ(pObj->v64, 2000);
sdbRelease(pSdb, pObj); sdbRelease(pSdb, pObj);
pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k200"); pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k200");
@ -270,7 +458,7 @@ TEST_F(MndTestSdb, 01_Write) {
num++; num++;
sdbRelease(pSdb, pObj); sdbRelease(pSdb, pObj);
} while (1); } while (1);
EXPECT_EQ(num, 2); ASSERT_EQ(num, 2);
do { do {
pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pObj); pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pObj);
@ -286,29 +474,30 @@ TEST_F(MndTestSdb, 01_Write) {
p2 = 111; p2 = 111;
p3 = 222; p3 = 222;
sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseSucc1, &p1, &p2, &p3); sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseSucc1, &p1, &p2, &p3);
EXPECT_EQ(p1, 334); ASSERT_EQ(p1, 334);
p1 = 0; p1 = 0;
p2 = 111; p2 = 111;
p3 = 222; p3 = 222;
sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseSucc2, &p1, &p2, &p3); sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseSucc2, &p1, &p2, &p3);
EXPECT_EQ(p1, 669); ASSERT_EQ(p1, 669);
p1 = 0; p1 = 0;
p2 = 111; p2 = 111;
p3 = 222; p3 = 222;
sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseFail, &p1, &p2, &p3); sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseFail, &p1, &p2, &p3);
EXPECT_EQ(p1, 333); ASSERT_EQ(p1, 333);
EXPECT_EQ(sdbGetSize(pSdb, SDB_USER), 2); ASSERT_EQ(sdbGetSize(pSdb, SDB_USER), 2);
EXPECT_EQ(sdbGetMaxId(pSdb, SDB_USER), -1); ASSERT_EQ(sdbGetMaxId(pSdb, SDB_USER), -1);
EXPECT_EQ(sdbGetTableVer(pSdb, SDB_USER), 1); ASSERT_EQ(sdbGetTableVer(pSdb, SDB_USER), 2 );
EXPECT_EQ(sdbUpdateVer(pSdb, 0), -1); ASSERT_EQ(sdbUpdateVer(pSdb, 0), -1);
EXPECT_EQ(sdbUpdateVer(pSdb, 1), 0); ASSERT_EQ(sdbUpdateVer(pSdb, 1), 0);
EXPECT_EQ(sdbUpdateVer(pSdb, -1), -1); ASSERT_EQ(sdbUpdateVer(pSdb, -1), -1);
EXPECT_EQ(mnode.insertTimes, 2); ASSERT_EQ(mnode.insertTimes, 2);
EXPECT_EQ(mnode.deleteTimes, 0); ASSERT_EQ(mnode.deleteTimes, 0);
{
// insert, call func // insert, call func
strSetDefault(&strObj, 3); strSetDefault(&strObj, 3);
pRaw = strEncode(&strObj); pRaw = strEncode(&strObj);
@ -318,12 +507,16 @@ TEST_F(MndTestSdb, 01_Write) {
ASSERT_NE(pObj, nullptr); ASSERT_NE(pObj, nullptr);
EXPECT_STREQ(pObj->key, "k3000"); EXPECT_STREQ(pObj->key, "k3000");
EXPECT_STREQ(pObj->vstr, "v3000"); EXPECT_STREQ(pObj->vstr, "v3000");
EXPECT_EQ(pObj->v8, 3); ASSERT_EQ(pObj->v8, 3);
EXPECT_EQ(pObj->v16, 3); ASSERT_EQ(pObj->v16, 3);
EXPECT_EQ(pObj->v32, 3000); ASSERT_EQ(pObj->v32, 3000);
EXPECT_EQ(pObj->v64, 3000); ASSERT_EQ(pObj->v64, 3000);
sdbRelease(pSdb, pObj); sdbRelease(pSdb, pObj);
ASSERT_EQ(sdbGetSize(pSdb, SDB_USER), 3);
ASSERT_EQ(sdbGetTableVer(pSdb, SDB_USER), 3);
ASSERT_EQ(sdbGetMaxId(pSdb, SDB_USER), -1);
// update, call func // update, call func
strSetDefault(&strObj, 3); strSetDefault(&strObj, 3);
strObj.v8 = 4; strObj.v8 = 4;
@ -334,19 +527,19 @@ TEST_F(MndTestSdb, 01_Write) {
ASSERT_NE(pObj, nullptr); ASSERT_NE(pObj, nullptr);
EXPECT_STREQ(pObj->key, "k3000"); EXPECT_STREQ(pObj->key, "k3000");
EXPECT_STREQ(pObj->vstr, "v3000"); EXPECT_STREQ(pObj->vstr, "v3000");
EXPECT_EQ(pObj->v8, 4); ASSERT_EQ(pObj->v8, 4);
EXPECT_EQ(pObj->v16, 3); ASSERT_EQ(pObj->v16, 3);
EXPECT_EQ(pObj->v32, 3000); ASSERT_EQ(pObj->v32, 3000);
EXPECT_EQ(pObj->v64, 3000); ASSERT_EQ(pObj->v64, 3000);
sdbRelease(pSdb, pObj); sdbRelease(pSdb, pObj);
EXPECT_EQ(sdbGetSize(pSdb, SDB_USER), 3); ASSERT_EQ(sdbGetSize(pSdb, SDB_USER), 3);
EXPECT_EQ(sdbGetTableVer(pSdb, SDB_USER), 3); ASSERT_EQ(sdbGetTableVer(pSdb, SDB_USER), 4);
EXPECT_EQ(sdbUpdateVer(pSdb, 0), -1); ASSERT_EQ(sdbUpdateVer(pSdb, 0), -1);
EXPECT_EQ(sdbUpdateVer(pSdb, 1), 0); ASSERT_EQ(sdbUpdateVer(pSdb, 1), 0);
EXPECT_EQ(sdbUpdateVer(pSdb, -1), -1); ASSERT_EQ(sdbUpdateVer(pSdb, -1), -1);
EXPECT_EQ(mnode.insertTimes, 3); ASSERT_EQ(mnode.insertTimes, 3);
EXPECT_EQ(mnode.deleteTimes, 0); ASSERT_EQ(mnode.deleteTimes, 0);
// delete, call func 2 // delete, call func 2
strSetDefault(&strObj, 3); strSetDefault(&strObj, 3);
@ -356,23 +549,170 @@ TEST_F(MndTestSdb, 01_Write) {
ASSERT_EQ(sdbWrite(pSdb, pRaw), 0); ASSERT_EQ(sdbWrite(pSdb, pRaw), 0);
pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k3000"); pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k3000");
ASSERT_EQ(pObj, nullptr); ASSERT_EQ(pObj, nullptr);
EXPECT_EQ(sdbGetSize(pSdb, SDB_USER), 2); ASSERT_EQ(sdbGetSize(pSdb, SDB_USER), 2);
EXPECT_EQ(sdbGetTableVer(pSdb, SDB_USER), 4); ASSERT_EQ(sdbGetTableVer(pSdb, SDB_USER), 5);
EXPECT_EQ(mnode.insertTimes, 3); ASSERT_EQ(mnode.insertTimes, 3);
EXPECT_EQ(mnode.deleteTimes, 1); ASSERT_EQ(mnode.deleteTimes, 1);
}
{
int32_t key = 4;
i32SetDefault(&i32Obj, key);
pRaw = i32Encode(&i32Obj);
sdbSetRawStatus(pRaw, SDB_STATUS_READY);
ASSERT_EQ(sdbWrite(pSdb, pRaw), 0);
SI32Obj *pI32Obj = (SI32Obj *)sdbAcquire(pSdb, SDB_VGROUP, &key);
ASSERT_NE(pI32Obj, nullptr);
ASSERT_EQ(pI32Obj->key, key);
ASSERT_EQ(pI32Obj->v8, 4);
ASSERT_EQ(pI32Obj->v16, 4);
ASSERT_EQ(pI32Obj->v32, 4000);
ASSERT_EQ(pI32Obj->v64, 4000);
sdbRelease(pSdb, pI32Obj);
ASSERT_EQ(sdbGetSize(pSdb, SDB_VGROUP), 1);
ASSERT_EQ(sdbGetTableVer(pSdb, SDB_VGROUP), 1);
ASSERT_EQ(sdbGetMaxId(pSdb, SDB_VGROUP), 5);
i32SetDefault(&i32Obj, key);
i32Obj.v8 = 5;
pRaw = i32Encode(&i32Obj);
sdbSetRawStatus(pRaw, SDB_STATUS_READY);
ASSERT_EQ(sdbWrite(pSdb, pRaw), 0);
pI32Obj = (SI32Obj *)sdbAcquire(pSdb, SDB_VGROUP, &key);
ASSERT_NE(pI32Obj, nullptr);
ASSERT_EQ(pI32Obj->key, key);
ASSERT_EQ(pI32Obj->v8, 5);
ASSERT_EQ(pI32Obj->v16, 4);
ASSERT_EQ(pI32Obj->v32, 4000);
ASSERT_EQ(pI32Obj->v64, 4000);
sdbRelease(pSdb, pI32Obj);
ASSERT_EQ(sdbGetSize(pSdb, SDB_VGROUP), 1);
ASSERT_EQ(sdbGetTableVer(pSdb, SDB_VGROUP), 2);
ASSERT_EQ(mnode.insertTimes, 4);
ASSERT_EQ(mnode.deleteTimes, 1);
// delete, call func 2
key = 4;
i32SetDefault(&i32Obj, key);
pRaw = i32Encode(&i32Obj);
sdbSetRawStatus(pRaw, SDB_STATUS_DROPPED);
ASSERT_EQ(sdbWrite(pSdb, pRaw), 0);
pObj = (SStrObj *)sdbAcquire(pSdb, SDB_VGROUP, &key);
ASSERT_EQ(pObj, nullptr);
ASSERT_EQ(sdbGetSize(pSdb, SDB_VGROUP), 0);
ASSERT_EQ(sdbGetTableVer(pSdb, SDB_VGROUP), 3);
ASSERT_EQ(sdbGetMaxId(pSdb, SDB_VGROUP), 5);
ASSERT_EQ(mnode.insertTimes, 4);
ASSERT_EQ(mnode.deleteTimes, 2);
key = 6;
i32SetDefault(&i32Obj, key);
pRaw = i32Encode(&i32Obj);
sdbSetRawStatus(pRaw, SDB_STATUS_READY);
ASSERT_EQ(sdbWrite(pSdb, pRaw), 0);
pI32Obj = (SI32Obj *)sdbAcquire(pSdb, SDB_VGROUP, &key);
ASSERT_NE(pI32Obj, nullptr);
ASSERT_EQ(pI32Obj->key, key);
ASSERT_EQ(pI32Obj->v8, 6);
ASSERT_EQ(pI32Obj->v16, 6);
ASSERT_EQ(pI32Obj->v32, 6000);
ASSERT_EQ(pI32Obj->v64, 6000);
sdbRelease(pSdb, pI32Obj);
ASSERT_EQ(sdbGetSize(pSdb, SDB_VGROUP), 1);
ASSERT_EQ(sdbGetTableVer(pSdb, SDB_VGROUP), 4);
ASSERT_EQ(sdbGetMaxId(pSdb, SDB_VGROUP), 7);
ASSERT_EQ(mnode.insertTimes, 5);
ASSERT_EQ(mnode.deleteTimes, 2);
}
{
int64_t key = 4;
i64SetDefault(&i64Obj, key);
pRaw = i64Encode(&i64Obj);
sdbSetRawStatus(pRaw, SDB_STATUS_READY);
ASSERT_EQ(sdbWrite(pSdb, pRaw), 0);
SI64Obj *pI64Obj = (SI64Obj *)sdbAcquire(pSdb, SDB_CONSUMER, &key);
ASSERT_NE(pI64Obj, nullptr);
ASSERT_EQ(pI64Obj->key, key);
ASSERT_EQ(pI64Obj->v8, 4);
ASSERT_EQ(pI64Obj->v16, 4);
ASSERT_EQ(pI64Obj->v32, 4000);
ASSERT_EQ(pI64Obj->v64, 4000);
sdbRelease(pSdb, pI64Obj);
ASSERT_EQ(sdbGetSize(pSdb, SDB_CONSUMER), 1);
ASSERT_EQ(sdbGetTableVer(pSdb, SDB_CONSUMER), 1);
ASSERT_EQ(sdbGetMaxId(pSdb, SDB_CONSUMER), -1);
i64SetDefault(&i64Obj, key);
i64Obj.v8 = 5;
pRaw = i64Encode(&i64Obj);
sdbSetRawStatus(pRaw, SDB_STATUS_READY);
ASSERT_EQ(sdbWrite(pSdb, pRaw), 0);
pI64Obj = (SI64Obj *)sdbAcquire(pSdb, SDB_CONSUMER, &key);
ASSERT_NE(pI64Obj, nullptr);
ASSERT_EQ(pI64Obj->key, key);
ASSERT_EQ(pI64Obj->v8, 5);
ASSERT_EQ(pI64Obj->v16, 4);
ASSERT_EQ(pI64Obj->v32, 4000);
ASSERT_EQ(pI64Obj->v64, 4000);
sdbRelease(pSdb, pI64Obj);
ASSERT_EQ(sdbGetSize(pSdb, SDB_CONSUMER), 1);
ASSERT_EQ(sdbGetTableVer(pSdb, SDB_CONSUMER), 2);
ASSERT_EQ(mnode.insertTimes, 6);
ASSERT_EQ(mnode.deleteTimes, 2);
// delete, call func 2
key = 4;
i64SetDefault(&i64Obj, key);
pRaw = i64Encode(&i64Obj);
sdbSetRawStatus(pRaw, SDB_STATUS_DROPPED);
ASSERT_EQ(sdbWrite(pSdb, pRaw), 0);
pObj = (SStrObj *)sdbAcquire(pSdb, SDB_CONSUMER, &key);
ASSERT_EQ(pObj, nullptr);
ASSERT_EQ(sdbGetSize(pSdb, SDB_CONSUMER), 0);
ASSERT_EQ(sdbGetTableVer(pSdb, SDB_CONSUMER), 3);
ASSERT_EQ(sdbGetMaxId(pSdb, SDB_CONSUMER), -1);
ASSERT_EQ(mnode.insertTimes, 6);
ASSERT_EQ(mnode.deleteTimes, 3);
key = 7;
i64SetDefault(&i64Obj, key);
pRaw = i64Encode(&i64Obj);
sdbSetRawStatus(pRaw, SDB_STATUS_READY);
ASSERT_EQ(sdbWrite(pSdb, pRaw), 0);
pI64Obj = (SI64Obj *)sdbAcquire(pSdb, SDB_CONSUMER, &key);
ASSERT_NE(pI64Obj, nullptr);
ASSERT_EQ(pI64Obj->key, key);
ASSERT_EQ(pI64Obj->v8, 7);
ASSERT_EQ(pI64Obj->v16, 7);
ASSERT_EQ(pI64Obj->v32, 7000);
ASSERT_EQ(pI64Obj->v64, 7000);
sdbRelease(pSdb, pI64Obj);
ASSERT_EQ(sdbGetSize(pSdb, SDB_CONSUMER), 1);
ASSERT_EQ(sdbGetTableVer(pSdb, SDB_CONSUMER), 4);
ASSERT_EQ(sdbGetMaxId(pSdb, SDB_CONSUMER), -1);
ASSERT_EQ(mnode.insertTimes, 7);
ASSERT_EQ(mnode.deleteTimes, 3);
}
// write version // write version
EXPECT_EQ(sdbUpdateVer(pSdb, 1), 0); ASSERT_EQ(sdbUpdateVer(pSdb, 1), 0);
EXPECT_EQ(sdbUpdateVer(pSdb, 1), 1); ASSERT_EQ(sdbUpdateVer(pSdb, 1), 1);
ASSERT_EQ(sdbWriteFile(pSdb), 0); ASSERT_EQ(sdbWriteFile(pSdb), 0);
ASSERT_EQ(sdbWriteFile(pSdb), 0); ASSERT_EQ(sdbWriteFile(pSdb), 0);
sdbCleanup(pSdb); sdbCleanup(pSdb);
EXPECT_EQ(mnode.insertTimes, 3); ASSERT_EQ(mnode.insertTimes, 7);
EXPECT_EQ(mnode.deleteTimes, 3); ASSERT_EQ(mnode.deleteTimes, 7);
} }
TEST_F(MndTestSdb, 01_Read) { TEST_F(MndTestSdb, 01_Read_Str) {
void *pIter = NULL; void *pIter = NULL;
int32_t num = 0; int32_t num = 0;
SStrObj *pObj = NULL; SStrObj *pObj = NULL;
@ -390,7 +730,7 @@ TEST_F(MndTestSdb, 01_Read) {
opt.pMnode = &mnode; opt.pMnode = &mnode;
opt.path = "/tmp/mnode_test_sdb"; opt.path = "/tmp/mnode_test_sdb";
SSdbTable strTable = { SSdbTable strTable1 = {
.sdbType = SDB_USER, .sdbType = SDB_USER,
.keyType = SDB_KEY_BINARY, .keyType = SDB_KEY_BINARY,
.deployFp = (SdbDeployFp)strDefault, .deployFp = (SdbDeployFp)strDefault,
@ -401,37 +741,60 @@ TEST_F(MndTestSdb, 01_Read) {
.deleteFp = (SdbDeleteFp)strDelete, .deleteFp = (SdbDeleteFp)strDelete,
}; };
SSdbTable strTable2 = {
.sdbType = SDB_VGROUP,
.keyType = SDB_KEY_INT32,
.encodeFp = (SdbEncodeFp)i32Encode,
.decodeFp = (SdbDecodeFp)i32Decode,
.insertFp = (SdbInsertFp)i32Insert,
.updateFp = (SdbUpdateFp)i32Update,
.deleteFp = (SdbDeleteFp)i32Delete,
};
SSdbTable strTable3 = {
.sdbType = SDB_CONSUMER,
.keyType = SDB_KEY_INT64,
.encodeFp = (SdbEncodeFp)i64Encode,
.decodeFp = (SdbDecodeFp)i64Decode,
.insertFp = (SdbInsertFp)i64Insert,
.updateFp = (SdbUpdateFp)i64Update,
.deleteFp = (SdbDeleteFp)i64Delete,
};
pSdb = sdbInit(&opt); pSdb = sdbInit(&opt);
mnode.pSdb = pSdb; mnode.pSdb = pSdb;
ASSERT_NE(pSdb, nullptr); ASSERT_NE(pSdb, nullptr);
ASSERT_EQ(sdbSetTable(pSdb, strTable), 0); ASSERT_NE(pSdb, nullptr);
ASSERT_EQ(sdbSetTable(pSdb, strTable1), 0);
ASSERT_EQ(sdbSetTable(pSdb, strTable2), 0);
ASSERT_EQ(sdbSetTable(pSdb, strTable3), 0);
ASSERT_EQ(sdbReadFile(pSdb), 0); ASSERT_EQ(sdbReadFile(pSdb), 0);
EXPECT_EQ(sdbGetSize(pSdb, SDB_USER), 2); ASSERT_EQ(sdbGetSize(pSdb, SDB_USER), 2);
EXPECT_EQ(sdbGetMaxId(pSdb, SDB_USER), -1); ASSERT_EQ(sdbGetMaxId(pSdb, SDB_USER), -1);
EXPECT_EQ(sdbGetTableVer(pSdb, SDB_USER), 4); ASSERT_EQ(sdbGetTableVer(pSdb, SDB_USER), 5);
EXPECT_EQ(sdbUpdateVer(pSdb, 0), 1); ASSERT_EQ(sdbUpdateVer(pSdb, 0), 1);
EXPECT_EQ(mnode.insertTimes, 2); ASSERT_EQ(mnode.insertTimes, 4);
EXPECT_EQ(mnode.deleteTimes, 0); ASSERT_EQ(mnode.deleteTimes, 0);
pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k1000"); pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k1000");
ASSERT_NE(pObj, nullptr); ASSERT_NE(pObj, nullptr);
EXPECT_STREQ(pObj->key, "k1000"); EXPECT_STREQ(pObj->key, "k1000");
EXPECT_STREQ(pObj->vstr, "v1000"); EXPECT_STREQ(pObj->vstr, "v1000");
EXPECT_EQ(pObj->v8, 1); ASSERT_EQ(pObj->v8, 1);
EXPECT_EQ(pObj->v16, 1); ASSERT_EQ(pObj->v16, 1);
EXPECT_EQ(pObj->v32, 1000); ASSERT_EQ(pObj->v32, 1000);
EXPECT_EQ(pObj->v64, 1000); ASSERT_EQ(pObj->v64, 1000);
sdbRelease(pSdb, pObj); sdbRelease(pSdb, pObj);
pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k2000"); pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k2000");
ASSERT_NE(pObj, nullptr); ASSERT_NE(pObj, nullptr);
EXPECT_STREQ(pObj->key, "k2000"); EXPECT_STREQ(pObj->key, "k2000");
EXPECT_STREQ(pObj->vstr, "v2000"); EXPECT_STREQ(pObj->vstr, "v2000");
EXPECT_EQ(pObj->v8, 2); ASSERT_EQ(pObj->v8, 2);
EXPECT_EQ(pObj->v16, 2); ASSERT_EQ(pObj->v16, 2);
EXPECT_EQ(pObj->v32, 2000); ASSERT_EQ(pObj->v32, 2000);
EXPECT_EQ(pObj->v64, 2000); ASSERT_EQ(pObj->v64, 2000);
sdbRelease(pSdb, pObj); sdbRelease(pSdb, pObj);
pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k200"); pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k200");
@ -446,7 +809,7 @@ TEST_F(MndTestSdb, 01_Read) {
num++; num++;
sdbRelease(pSdb, pObj); sdbRelease(pSdb, pObj);
} while (1); } while (1);
EXPECT_EQ(num, 2); ASSERT_EQ(num, 2);
do { do {
pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pObj); pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pObj);
@ -462,21 +825,48 @@ TEST_F(MndTestSdb, 01_Read) {
p2 = 111; p2 = 111;
p3 = 222; p3 = 222;
sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseSucc1, &p1, &p2, &p3); sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseSucc1, &p1, &p2, &p3);
EXPECT_EQ(p1, 334); ASSERT_EQ(p1, 334);
p1 = 0; p1 = 0;
p2 = 111; p2 = 111;
p3 = 222; p3 = 222;
sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseSucc2, &p1, &p2, &p3); sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseSucc2, &p1, &p2, &p3);
EXPECT_EQ(p1, 669); ASSERT_EQ(p1, 669);
p1 = 0; p1 = 0;
p2 = 111; p2 = 111;
p3 = 222; p3 = 222;
sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseFail, &p1, &p2, &p3); sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseFail, &p1, &p2, &p3);
EXPECT_EQ(p1, 333); ASSERT_EQ(p1, 333);
int32_t i32key = 6;
SI32Obj *pI32Obj = (SI32Obj *)sdbAcquire(pSdb, SDB_VGROUP, &i32key);
ASSERT_NE(pI32Obj, nullptr);
ASSERT_EQ(pI32Obj->key, 6);
ASSERT_EQ(pI32Obj->v8, 6);
ASSERT_EQ(pI32Obj->v16, 6);
ASSERT_EQ(pI32Obj->v32, 6000);
ASSERT_EQ(pI32Obj->v64, 6000);
sdbRelease(pSdb, pI32Obj);
ASSERT_EQ(sdbGetSize(pSdb, SDB_VGROUP), 1);
ASSERT_EQ(sdbGetTableVer(pSdb, SDB_VGROUP), 4);
ASSERT_EQ(sdbGetMaxId(pSdb, SDB_VGROUP), 7);
int64_t i64key = 7;
SI64Obj *pI64Obj = (SI64Obj *)sdbAcquire(pSdb, SDB_CONSUMER, &i64key);
ASSERT_NE(pI64Obj, nullptr);
ASSERT_EQ(pI64Obj->key, 7);
ASSERT_EQ(pI64Obj->v8, 7);
ASSERT_EQ(pI64Obj->v16, 7);
ASSERT_EQ(pI64Obj->v32, 7000);
ASSERT_EQ(pI64Obj->v64, 7000);
sdbRelease(pSdb, pI64Obj);
ASSERT_EQ(sdbGetSize(pSdb, SDB_CONSUMER), 1);
ASSERT_EQ(sdbGetTableVer(pSdb, SDB_CONSUMER), 4);
sdbCleanup(pSdb); sdbCleanup(pSdb);
EXPECT_EQ(mnode.insertTimes, 2); ASSERT_EQ(mnode.insertTimes, 4);
EXPECT_EQ(mnode.deleteTimes, 2); ASSERT_EQ(mnode.deleteTimes, 4);
} }

2
source/dnode/mnode/sdb/src/sdb.c
View File

@ -50,7 +50,7 @@ SSdb *sdbInit(SSdbOpt *pOption) {
for (ESdbType i = 0; i < SDB_MAX; ++i) { for (ESdbType i = 0; i < SDB_MAX; ++i) {
taosInitRWLatch(&pSdb->locks[i]); taosInitRWLatch(&pSdb->locks[i]);
pSdb->maxId[i] = 0; pSdb->maxId[i] = 0;
pSdb->tableVer[i] = -1; pSdb->tableVer[i] = 0;
pSdb->keyTypes[i] = SDB_KEY_INT32; pSdb->keyTypes[i] = SDB_KEY_INT32;
} }

6
source/dnode/mnode/sdb/src/sdbFile.c
View File

@ -50,7 +50,7 @@ static int32_t sdbReadFileHead(SSdb *pSdb, TdFilePtr pFile) {
} }
for (int32_t i = 0; i < SDB_TABLE_SIZE; ++i) { for (int32_t i = 0; i < SDB_TABLE_SIZE; ++i) {
int64_t maxId = -1; int64_t maxId = 0;
ret = taosReadFile(pFile, &maxId, sizeof(int64_t)); ret = taosReadFile(pFile, &maxId, sizeof(int64_t));
if (ret < 0) { if (ret < 0) {
terrno = TAOS_SYSTEM_ERROR(errno); terrno = TAOS_SYSTEM_ERROR(errno);
@ -102,7 +102,7 @@ static int32_t sdbWriteFileHead(SSdb *pSdb, TdFilePtr pFile) {
} }
for (int32_t i = 0; i < SDB_TABLE_SIZE; ++i) { for (int32_t i = 0; i < SDB_TABLE_SIZE; ++i) {
int64_t maxId = -1; int64_t maxId = 0;
if (i < SDB_MAX) { if (i < SDB_MAX) {
maxId = pSdb->maxId[i]; maxId = pSdb->maxId[i];
} }
@ -113,7 +113,7 @@ static int32_t sdbWriteFileHead(SSdb *pSdb, TdFilePtr pFile) {
} }
for (int32_t i = 0; i < SDB_TABLE_SIZE; ++i) { for (int32_t i = 0; i < SDB_TABLE_SIZE; ++i) {
int64_t ver = -1; int64_t ver = 0;
if (i < SDB_MAX) { if (i < SDB_MAX) {
ver = pSdb->tableVer[i]; ver = pSdb->tableVer[i];
} }