test: add unitest for sdb

include/dnode/mnode/sdb/sdb.h

@@ -331,7 +331,6 @@ int32_t  sdbGetRawSoftVer(SSdbRaw *pRaw, int8_t *sver);
 int32_t  sdbGetRawTotalSize(SSdbRaw *pRaw);
 
 SSdbRow *sdbAllocRow(int32_t objSize);
-void     sdbFreeRow(SSdb *pSdb, SSdbRow *pRow, bool callFunc);
 void    *sdbGetRowObj(SSdbRow *pRow);
 
 typedef struct SSdb {

source/dnode/mnode/impl/test/sdb/sdbTest.cpp

@@ -73,32 +73,39 @@ SSdbRaw *strEncode(SStrObj *pObj) {
   dataPos += sizeof(pObj->v32);
   sdbSetRawInt64(pRaw, dataPos, pObj->v64);
   dataPos += sizeof(pObj->v64);
-  sdbSetRawBinary(pRaw, dataPos, pObj->key, sizeof(pObj->vstr));
-  dataPos += sizeof(pObj->key);
+  sdbSetRawBinary(pRaw, dataPos, pObj->vstr, sizeof(pObj->vstr));
+  dataPos += sizeof(pObj->vstr);
   sdbSetRawDataLen(pRaw, dataPos);
 
   return pRaw;
 }
 
-SSdbRaw *strDecode(SStrObj *pObj) {
-  int32_t  dataPos = 0;
-  SSdbRaw *pRaw = sdbAllocRaw(SDB_USER, 1, sizeof(SStrObj));
+SSdbRow *strDecode(SSdbRaw *pRaw) {
+  int8_t sver = 0;
+  if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL;
+  if (sver != 1) return NULL;
 
-  sdbSetRawBinary(pRaw, dataPos, pObj->key, sizeof(pObj->key));
+  SSdbRow *pRow = sdbAllocRow(sizeof(SStrObj));
+  if (pRow == NULL) return NULL;
+
+  SStrObj *pObj = (SStrObj *)sdbGetRowObj(pRow);
+  if (pObj == NULL) return NULL;
+
+  int32_t dataPos = 0;
+  sdbGetRawBinary(pRaw, dataPos, pObj->key, sizeof(pObj->key));
   dataPos += sizeof(pObj->key);
-  sdbSetRawInt8(pRaw, dataPos, pObj->v8);
+  sdbGetRawInt8(pRaw, dataPos, &pObj->v8);
   dataPos += sizeof(pObj->v8);
-  sdbSetRawInt16(pRaw, dataPos, pObj->v16);
+  sdbGetRawInt16(pRaw, dataPos, &pObj->v16);
   dataPos += sizeof(pObj->v16);
-  sdbSetRawInt32(pRaw, dataPos, pObj->v32);
+  sdbGetRawInt32(pRaw, dataPos, &pObj->v32);
   dataPos += sizeof(pObj->v32);
-  sdbSetRawInt64(pRaw, dataPos, pObj->v64);
+  sdbGetRawInt64(pRaw, dataPos, &pObj->v64);
   dataPos += sizeof(pObj->v64);
-  sdbSetRawBinary(pRaw, dataPos, pObj->key, sizeof(pObj->vstr));
-  dataPos += sizeof(pObj->key);
-  sdbSetRawDataLen(pRaw, dataPos);
+  sdbGetRawBinary(pRaw, dataPos, pObj->vstr, sizeof(pObj->vstr));
+  dataPos += sizeof(pObj->vstr);
 
-  return pRaw;
+  return pRow;
 }
 
 int32_t strInsert(SSdb *pSdb, SStrObj *pObj) { return 0; }
@@ -110,39 +117,196 @@ int32_t strUpdate(SSdb *pSdb, SStrObj *pOld, SStrObj *pNew) {
   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) {
+  memset(pObj, 0, sizeof(SStrObj));
+  snprintf(pObj->key, sizeof(pObj->key), "k%d", index * 1000);
+  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) {
-  SStrObj strObj = {0};
-  strcpy(strObj.key, "k1000");
-  strObj.v8 = 1;
-  strObj.v16 = 1;
-  strObj.v32 = 1000;
-  strObj.v64 = 1000;
-  strcpy(strObj.vstr, "v1000");
-
-  SSdbRaw *pRaw = strEncode(&strObj);
+  SStrObj  strObj;
+  SSdbRaw *pRaw = NULL;
+
+  strSetDefault(&strObj, 1);
+  pRaw = strEncode(&strObj);
+  sdbSetRawStatus(pRaw, SDB_STATUS_READY);
+  if (sdbWrite(pMnode->pSdb, pRaw) != 0) return -1;
+
+  strSetDefault(&strObj, 2);
+  pRaw = strEncode(&strObj);
   sdbSetRawStatus(pRaw, SDB_STATUS_READY);
-  return sdbWrite(pMnode->pSdb, pRaw);
+  if (sdbWriteWithoutFree(pMnode->pSdb, pRaw) != 0) return -1;
+  sdbFreeRaw(pRaw);
+
+  return 0;
+}
+
+bool sdbTraverseSucc1(SMnode *pMnode, SStrObj *pObj, int32_t *p1, int32_t *p2, int32_t *p3) {
+  if (pObj->v8 == 1) {
+    *p1 = *p2 + *p3 + pObj->v8;
+  }
+  return true;
+}
+
+bool sdbTraverseSucc2(SMnode *pMnode, SStrObj *pObj, int32_t *p1, int32_t *p2, int32_t *p3) {
+  *p1 = *p2 + *p3 + pObj->v8;
+  return true;
+}
+
+bool sdbTraverseFail(SMnode *pMnode, SStrObj *pObj, int32_t *p1, int32_t *p2, int32_t *p3) {
+  *p1 = *p2 + *p3;
+  return false;
 }
 
-TEST_F(MndTestSdb, 01_Basic) {
+TEST_F(MndTestSdb, 01_Write) {
+  void    *pIter;
+  int32_t  num;
+  SStrObj *pObj;
   SMnode   mnode;
+  SSdb    *pSdb;
+  SSdbOpt  opt = {0};
+  int32_t  p1 = 0;
+  int32_t  p2 = 111;
+  int32_t  p3 = 222;
+
   mnode.v100 = 100;
   mnode.v200 = 200;
+  opt.pMnode = &mnode;
+  opt.path = "/tmp/mnode_test_sdb";
+  taosRemoveDir(opt.path);
 
+  SSdbTable strTable = {
+      .sdbType = SDB_USER,
+      .keyType = SDB_KEY_BINARY,
+      .deployFp = (SdbDeployFp)strDefault,
+      .encodeFp = (SdbEncodeFp)strEncode,
+      .decodeFp = (SdbDecodeFp)strDecode,
+      .insertFp = (SdbInsertFp)strInsert,
+      .updateFp = (SdbUpdateFp)strUpdate,
+      .deleteFp = (SdbDeleteFp)strDelete,
+  };
+
+  pSdb = sdbInit(&opt);
+  mnode.pSdb = pSdb;
+
+  ASSERT_NE(pSdb, nullptr);
+  ASSERT_EQ(sdbSetTable(pSdb, strTable), 0);
+  ASSERT_EQ(sdbDeploy(pSdb), 0);
+#if 0
+  pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k1000");
+  ASSERT_NE(pObj, nullptr);
+  EXPECT_STREQ(pObj->key, "k1000");
+  EXPECT_STREQ(pObj->vstr, "v1000");
+  EXPECT_EQ(pObj->v8, 1);
+  EXPECT_EQ(pObj->v16, 1);
+  EXPECT_EQ(pObj->v32, 1000);
+  EXPECT_EQ(pObj->v64, 1000);
+  sdbRelease(pSdb, pObj);
+
+  pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k2000");
+  ASSERT_NE(pObj, nullptr);
+  EXPECT_STREQ(pObj->key, "k2000");
+  EXPECT_STREQ(pObj->vstr, "v2000");
+  EXPECT_EQ(pObj->v8, 2);
+  EXPECT_EQ(pObj->v16, 2);
+  EXPECT_EQ(pObj->v32, 2000);
+  EXPECT_EQ(pObj->v64, 2000);
+  sdbRelease(pSdb, pObj);
+
+  pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k200");
+  ASSERT_EQ(pObj, nullptr);
+
+  pIter = NULL;
+  num = 0;
+  do {
+    pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pObj);
+    if (pIter == NULL) break;
+    ASSERT_NE(pObj, nullptr);
+    num++;
+    sdbRelease(pSdb, pObj);
+  } while (1);
+  EXPECT_EQ(num, 2);
+
+  do {
+    pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pObj);
+    if (pIter == NULL) break;
+    if (strcmp(pObj->key, "k1000") == 0) {
+      sdbCancelFetch(pSdb, pIter);
+      break;
+    }
+  } while (1);
+  EXPECT_STREQ(pObj->key, "k1000");
+
+  p1 = 0;
+  p2 = 111;
+  p3 = 222;
+  sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseSucc2, &p1, &p2, &p3);
+  EXPECT_EQ(p1, 334);
+
+  p1 = 0;
+  p2 = 111;
+  p3 = 222;
+  sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseSucc2, &p1, &p2, &p3);
+  EXPECT_EQ(p1, 669);
+
+  p1 = 0;
+  p2 = 111;
+  p3 = 222;
+  sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseFail, &p1, &p2, &p3);
+  EXPECT_EQ(p1, 333);
+
+  EXPECT_EQ(sdbGetSize(pSdb, SDB_USER), 2);
+  EXPECT_EQ(sdbGetMaxId(pSdb, SDB_USER), -1);
+  EXPECT_EQ(sdbGetTableVer(pSdb, SDB_USER), 2);
+  EXPECT_EQ(sdbUpdateVer(pSdb, 0), 2);
+  EXPECT_EQ(sdbUpdateVer(pSdb, 1), 3);
+  EXPECT_EQ(sdbUpdateVer(pSdb, -1), 2);
+
+  // insert, call func
+
+  // update, call func
+
+  // delete, call func 2
+
+  // write version
+
+  // sdb Write ver
+
+  // sdbRead
+#endif
+  ASSERT_EQ(sdbWriteFile(pSdb), 0);
+  sdbCleanup(pSdb);
+}
+
+TEST_F(MndTestSdb, 01_Read) {
+  void    *pIter;
+  int32_t  num;
+  SStrObj *pObj;
+  SMnode   mnode;
+  SSdb    *pSdb;
   SSdbOpt  opt = {0};
+  int32_t  p1 = 0;
+  int32_t  p2 = 111;
+  int32_t  p3 = 222;
+
+  mnode.v100 = 100;
+  mnode.v200 = 200;
   opt.pMnode = &mnode;
   opt.path = "/tmp/mnode_test_sdb";
-
-  SSdb *pSdb = sdbInit(&opt);
-  EXPECT_NE(pSdb, nullptr);
+  taosRemoveDir(opt.path);
 
   SSdbTable strTable = {
       .sdbType = SDB_USER,
       .keyType = SDB_KEY_BINARY,
-      .deployFp = (SdbDeployFp)strEncode,
+      .deployFp = (SdbDeployFp)strDefault,
       .encodeFp = (SdbEncodeFp)strEncode,
       .decodeFp = (SdbDecodeFp)strDecode,
       .insertFp = (SdbInsertFp)strInsert,
@@ -150,7 +314,9 @@ TEST_F(MndTestSdb, 01_Basic) {
       .deleteFp = (SdbDeleteFp)strUpdate,
   };
 
-  sdbSetTable(pSdb, strTable);
+  pSdb = sdbInit(&opt);
+  mnode.pSdb = pSdb;
 
+  ASSERT_EQ(sdbReadFile(pSdb), 0);
   sdbCleanup(pSdb);
 }
\ No newline at end of file

source/dnode/mnode/sdb/inc/sdbInt.h

@@ -52,6 +52,8 @@ typedef struct SSdbRow {
 const char *sdbTableName(ESdbType type);
 void        sdbPrintOper(SSdb *pSdb, SSdbRow *pRow, const char *oper);
 
+void sdbFreeRow(SSdb *pSdb, SSdbRow *pRow, bool callFunc);
+
 #ifdef __cplusplus
 }
 #endif

source/os/src/osDir.c

@@ -72,8 +72,8 @@ void taosRemoveDir(const char *dirname) {
   while ((de = taosReadDir(pDir)) != NULL) {
     if (strcmp(taosGetDirEntryName(de), ".") == 0 || strcmp(taosGetDirEntryName(de), "..") == 0) continue;
 
-    char filename[1024];
-    snprintf(filename, sizeof(filename), "%s/%s", dirname, taosGetDirEntryName(de));
+    char filename[1024] = {0};
+    snprintf(filename, sizeof(filename), "%s%s%s", dirname, TD_DIRSEP, taosGetDirEntryName(de));
     if (taosDirEntryIsDir(de)) {
       taosRemoveDir(filename);
     } else {