diff --git a/src/tsdb/inc/tsdbFile.h b/src/tsdb/inc/tsdbFile.h
index c92cc430419a81bc05c2995e792c8ef772b9ab95..4365807036629700fceab4563282c3824dcd27a1 100644
--- a/src/tsdb/inc/tsdbFile.h
+++ b/src/tsdb/inc/tsdbFile.h
@@ -37,7 +37,11 @@
 #define TSDB_FILE_SET_STATE(tf, s) ((tf)->state = (s))
 #define TSDB_FILE_IS_OK(tf) (TSDB_FILE_STATE(tf) == TSDB_FILE_STATE_OK)
 #define TSDB_FILE_IS_BAD(tf) (TSDB_FILE_STATE(tf) == TSDB_FILE_STATE_BAD)
-#define TSDB_FSET_NFILES_VALID(s) (((s)->nFiles >= TSDB_FILE_MIN) && ((s)->nFiles <= TSDB_FILE_MAX))
+#define ASSERT_TSDB_FSET_NFILES_VALID(s)                                    \
+  do {                                                                \
+    uint8_t nDFiles = tsdbGetNFiles(s);                               \
+    ASSERT((nDFiles >= TSDB_FILE_MIN) && (nDFiles <= TSDB_FILE_MAX)); \
+  } while (0)
 typedef enum {
   TSDB_FILE_HEAD = 0,
   TSDB_FILE_DATA,
@@ -297,10 +301,28 @@ static FORCE_INLINE int tsdbCopyDFile(SDFile* pSrc, SDFile* pDest) {
 typedef struct {
   int     fid;
   int     state;
-  uint8_t nFiles;
+  uint8_t ver;  // fset version
   SDFile  files[TSDB_FILE_MAX];
 } SDFileSet;
 
+typedef enum {
+  TSDB_FSET_VER_0,  // .head/.data/.last
+  TSDB_FSET_VER_1,  // .head/.data/.last/.smad/.smal
+} ETsdbFSetVer;
+
+#define TSDB_LATEST_FSET_VER TSDB_FSET_VER_1
+
+// get nDFiles in SDFileSet
+static FORCE_INLINE uint8_t tsdbGetNFiles(SDFileSet* pSet) {
+  switch (pSet->ver) {
+    case TSDB_FSET_VER_0:
+      return TSDB_FILE_MIN;
+    case TSDB_FSET_VER_1:
+    default:
+      return TSDB_FILE_MAX;
+  }
+}
+
 #define TSDB_FSET_FID(s) ((s)->fid)
 #define TSDB_DFILE_IN_SET(s, t) ((s)->files + (t))
 #define TSDB_FSET_LEVEL(s) TSDB_FILE_LEVEL(TSDB_DFILE_IN_SET(s, 0))
@@ -311,20 +333,20 @@ typedef struct {
       TSDB_FILE_SET_CLOSED(TSDB_DFILE_IN_SET(s, ftype));                       \
     }                                                                          \
   } while (0);
-#define TSDB_FSET_SET_CLOSED(s)                                              \
-  do {                                                                       \
-    for (TSDB_FILE_T ftype = TSDB_FILE_HEAD; ftype < (s)->nFiles; ftype++) { \
-      TSDB_FILE_SET_CLOSED(TSDB_DFILE_IN_SET(s, ftype));                     \
-    }                                                                        \
+#define TSDB_FSET_SET_CLOSED(s)                                                   \
+  do {                                                                            \
+    for (TSDB_FILE_T ftype = TSDB_FILE_HEAD; ftype < tsdbGetNFiles(s); ftype++) { \
+      TSDB_FILE_SET_CLOSED(TSDB_DFILE_IN_SET(s, ftype));                          \
+    }                                                                             \
   } while (0);
-#define TSDB_FSET_FSYNC(s)                                                   \
-  do {                                                                       \
-    for (TSDB_FILE_T ftype = TSDB_FILE_HEAD; ftype < (s)->nFiles; ftype++) { \
-      TSDB_FILE_FSYNC(TSDB_DFILE_IN_SET(s, ftype));                          \
-    }                                                                        \
+#define TSDB_FSET_FSYNC(s)                                                        \
+  do {                                                                            \
+    for (TSDB_FILE_T ftype = TSDB_FILE_HEAD; ftype < tsdbGetNFiles(s); ftype++) { \
+      TSDB_FILE_FSYNC(TSDB_DFILE_IN_SET(s, ftype));                               \
+    }                                                                             \
   } while (0);
 
-void  tsdbInitDFileSet(SDFileSet* pSet, SDiskID did, int vid, int fid, uint32_t ver, uint8_t nFiles);
+void  tsdbInitDFileSet(SDFileSet* pSet, SDiskID did, int vid, int fid, uint32_t ver, uint8_t fsetVer);
 void  tsdbInitDFileSetEx(SDFileSet* pSet, SDFileSet* pOSet);
 int   tsdbEncodeDFileSet(void** buf, SDFileSet* pSet);
 void* tsdbDecodeDFileSet(void* buf, SDFileSet* pSet, uint32_t sfver);
@@ -336,15 +358,15 @@ int   tsdbUpdateDFileSetHeader(SDFileSet* pSet);
 int   tsdbScanAndTryFixDFileSet(STsdbRepo *pRepo, SDFileSet* pSet);
 
 static FORCE_INLINE void tsdbCloseDFileSet(SDFileSet* pSet) {
-  ASSERT(pSet->nFiles <= TSDB_FILE_MAX);
-  for (TSDB_FILE_T ftype = 0; ftype < pSet->nFiles; ftype++) {
+  ASSERT(tsdbGetNFiles(pSet) <= TSDB_FILE_MAX);
+  for (TSDB_FILE_T ftype = 0; ftype < tsdbGetNFiles(pSet); ftype++) {
     tsdbCloseDFile(TSDB_DFILE_IN_SET(pSet, ftype));
   }
 }
 
 static FORCE_INLINE int tsdbOpenDFileSet(SDFileSet* pSet, int flags) {
-  ASSERT(TSDB_FSET_NFILES_VALID(pSet));
-  for (TSDB_FILE_T ftype = 0; ftype < pSet->nFiles; ftype++) {
+  ASSERT_TSDB_FSET_NFILES_VALID(pSet);
+  for (TSDB_FILE_T ftype = 0; ftype < tsdbGetNFiles(pSet); ftype++) {
     if (tsdbOpenDFile(TSDB_DFILE_IN_SET(pSet, ftype), flags) < 0) {
       tsdbCloseDFileSet(pSet);
       return -1;
@@ -354,15 +376,15 @@ static FORCE_INLINE int tsdbOpenDFileSet(SDFileSet* pSet, int flags) {
 }
 
 static FORCE_INLINE void tsdbRemoveDFileSet(SDFileSet* pSet) {
-  ASSERT(TSDB_FSET_NFILES_VALID(pSet));
-  for (TSDB_FILE_T ftype = 0; ftype < pSet->nFiles; ftype++) {
+  ASSERT_TSDB_FSET_NFILES_VALID(pSet);
+  for (TSDB_FILE_T ftype = 0; ftype < tsdbGetNFiles(pSet); ftype++) {
     (void)tsdbRemoveDFile(TSDB_DFILE_IN_SET(pSet, ftype));
   }
 }
 
 static FORCE_INLINE int tsdbCopyDFileSet(SDFileSet* pSrc, SDFileSet* pDest) {
-  ASSERT(TSDB_FSET_NFILES_VALID(pSrc));
-  for (TSDB_FILE_T ftype = 0; ftype < pSrc->nFiles; ftype++) {
+  ASSERT_TSDB_FSET_NFILES_VALID(pSrc);
+  for (TSDB_FILE_T ftype = 0; ftype < tsdbGetNFiles(pSrc); ftype++) {
     if (tsdbCopyDFile(TSDB_DFILE_IN_SET(pSrc, ftype), TSDB_DFILE_IN_SET(pDest, ftype)) < 0) {
       tsdbRemoveDFileSet(pDest);
       return -1;
diff --git a/src/tsdb/src/tsdbCommit.c b/src/tsdb/src/tsdbCommit.c
index 88bab494ba2e032324d8774cdaa0debb6028ac8f..2347b8b619a9529600b67239c99edece32d003f9 100644
--- a/src/tsdb/src/tsdbCommit.c
+++ b/src/tsdb/src/tsdbCommit.c
@@ -139,7 +139,7 @@ int tsdbApplyRtnOnFSet(STsdbRepo *pRepo, SDFileSet *pSet, SRtn *pRtn) {
 
   if (did.level > TSDB_FSET_LEVEL(pSet)) {
     // Need to move the FSET to higher level
-    tsdbInitDFileSet(&nSet, did, REPO_ID(pRepo), pSet->fid, FS_TXN_VERSION(pfs), TSDB_FILE_MAX);
+    tsdbInitDFileSet(&nSet, did, REPO_ID(pRepo), pSet->fid, FS_TXN_VERSION(pfs), pSet->ver);
 
     if (tsdbCopyDFileSet(pSet, &nSet) < 0) {
       tsdbError("vgId:%d failed to copy FSET %d from level %d to level %d since %s", REPO_ID(pRepo), pSet->fid,
@@ -1562,7 +1562,7 @@ static int tsdbSetAndOpenCommitFile(SCommitH *pCommith, SDFileSet *pSet, int fid
   // Set and open commit FSET
   if (pSet == NULL || did.level > TSDB_FSET_LEVEL(pSet)) {
     // Create a new FSET to write data
-    tsdbInitDFileSet(pWSet, did, REPO_ID(pRepo), fid, FS_TXN_VERSION(REPO_FS(pRepo)), TSDB_FILE_MAX);
+    tsdbInitDFileSet(pWSet, did, REPO_ID(pRepo), fid, FS_TXN_VERSION(REPO_FS(pRepo)), TSDB_LATEST_FSET_VER);
 
     if (tsdbCreateDFileSet(pWSet, true) < 0) {
       tsdbError("vgId:%d failed to create FSET %d at level %d disk id %d since %s", REPO_ID(pRepo),
@@ -1583,8 +1583,8 @@ static int tsdbSetAndOpenCommitFile(SCommitH *pCommith, SDFileSet *pSet, int fid
 
     pCommith->wSet.fid = fid;
     pCommith->wSet.state = 0;
-    pCommith->wSet.nFiles = TSDB_FILE_MAX;
-  
+    pCommith->wSet.ver = TSDB_LATEST_FSET_VER;
+
     // TSDB_FILE_HEAD
     SDFile *pWHeadf = TSDB_COMMIT_HEAD_FILE(pCommith);
     tsdbInitDFile(pWHeadf, did, REPO_ID(pRepo), fid, FS_TXN_VERSION(REPO_FS(pRepo)), TSDB_FILE_HEAD);
@@ -1685,7 +1685,7 @@ static int tsdbSetAndOpenCommitFile(SCommitH *pCommith, SDFileSet *pSet, int fid
     }
 
     // TSDB_FILE_SMAL
-    ASSERT(pWSet->nFiles >= TSDB_FILE_SMAL);
+    ASSERT(tsdbGetNFiles(pWSet) >= TSDB_FILE_SMAL);
     SDFile *pRSmalF = TSDB_READ_SMAL_FILE(&(pCommith->readh));
     SDFile *pWSmalF = TSDB_COMMIT_SMAL_FILE(pCommith);
     
diff --git a/src/tsdb/src/tsdbCompact.c b/src/tsdb/src/tsdbCompact.c
index 1f827e7cdb7cd40fff3efa45f4542f50f28298ff..f20e27ceb76e819bc71c8b256ed611ca3e55011a 100644
--- a/src/tsdb/src/tsdbCompact.c
+++ b/src/tsdb/src/tsdbCompact.c
@@ -197,7 +197,7 @@ static int tsdbCompactMeta(STsdbRepo *pRepo) {
       }
 
       tsdbInitDFileSet(TSDB_COMPACT_WSET(pComph), did, REPO_ID(pRepo), TSDB_FSET_FID(pSet),
-                      FS_TXN_VERSION(REPO_FS(pRepo)), TSDB_FILE_MAX);
+                      FS_TXN_VERSION(REPO_FS(pRepo)), TSDB_LATEST_FSET_VER);
       if (tsdbCreateDFileSet(TSDB_COMPACT_WSET(pComph), true) < 0) {
         tsdbError("vgId:%d failed to compact FSET %d since %s", REPO_ID(pRepo), pSet->fid, tstrerror(terrno));
         tsdbCompactFSetEnd(pComph);
diff --git a/src/tsdb/src/tsdbFS.c b/src/tsdb/src/tsdbFS.c
index 6256b45d02a660c1b2b3da511a0a23c6ab73dc58..971ade13222ce15d5c9943c8290f073d071b461f 100644
--- a/src/tsdb/src/tsdbFS.c
+++ b/src/tsdb/src/tsdbFS.c
@@ -93,7 +93,7 @@ static int tsdbEncodeDFileSetArray(void **buf, SArray *pArray) {
 static int tsdbDecodeDFileSetArray(void **originBuf, void *buf, SArray *pArray, SFSHeader *pSFSHeader) {
   uint64_t  nset;
   SDFileSet dset;
-  dset.nFiles = TSDB_FILE_MIN;  // default value: .head/.data/.last
+  dset.ver = TSDB_FSET_VER_0;  // default value
 
   taosArrayClear(pArray);
 
@@ -986,7 +986,7 @@ static bool tsdbIsTFileInFS(STsdbFS *pfs, const TFILE *pf) {
   SDFileSet *pSet;
 
   while ((pSet = tsdbFSIterNext(&fsiter))) {
-    for (TSDB_FILE_T ftype = 0; ftype < pSet->nFiles; ftype++) {
+    for (TSDB_FILE_T ftype = 0; ftype < tsdbGetNFiles(pSet); ftype++) {
       SDFile *pDFile = TSDB_DFILE_IN_SET(pSet, ftype);
       if (tfsIsSameFile(pf, TSDB_FILE_F(pDFile))) {
         return true;
@@ -1288,7 +1288,7 @@ static int tsdbRestoreDFileSet(STsdbRepo *pRepo) {
     }
 
     tsdbInfo("vgId:%d FSET %d is restored", REPO_ID(pRepo), fset.fid);
-    fset.nFiles = 3;
+    fset.ver = TSDB_LATEST_FSET_VER;
     taosArrayPush(pfs->cstatus->df, &fset);
   }
 
@@ -1323,6 +1323,7 @@ static int tsdbRestoreDFileSet(STsdbRepo *pRepo) {
 
   // Loop to recover each file set
   SDFileSet fset = {0};
+  uint8_t   nDFiles = 0;
   bool      isOneFSetFinish = true;
   int       lastFType = -1;
   // one fileset ends when (1) the array ends or (2) encounter different fid
@@ -1349,29 +1350,29 @@ static int tsdbRestoreDFileSet(STsdbRepo *pRepo) {
     if (index == 0) {
       memset(&fset, 0, sizeof(SDFileSet));
       TSDB_FSET_SET_INIT(&fset);
-      fset.nFiles = 1;
+      nDFiles = 1;
       fset.fid = tfid;
       pDFile->f = *pf;
       isOneFSetFinish = false;
     } else {
       if (fset.fid == tfid) {
-        ++fset.nFiles;
+        ++nDFiles;
         pDFile->f = *pf;
         // (1) the array ends
-        if ((index == fArraySize - 1) && (fset.nFiles >= TSDB_FILE_MIN)) {
-          tsdbInfo("vgId:%d DFileSet %d is fetched, nFiles=%" PRIu8, REPO_ID(pRepo), fset.fid, fset.nFiles);
+        if ((index == fArraySize - 1) && (nDFiles >= TSDB_FILE_MIN)) {
+          tsdbInfo("vgId:%d DFileSet %d is fetched, nDFiles=%" PRIu8, REPO_ID(pRepo), fset.fid, nDFiles);
           isOneFSetFinish = true;
         }
       } else {
         // (2) encounter different fid
-        if (fset.nFiles >= TSDB_FILE_MIN) {
-          tsdbInfo("vgId:%d DFileSet %d is fetched, nFiles=%" PRIu8, REPO_ID(pRepo), fset.fid, fset.nFiles);
+        if (nDFiles >= TSDB_FILE_MIN) {
+          tsdbInfo("vgId:%d DFileSet %d is fetched, nDFiles=%" PRIu8, REPO_ID(pRepo), fset.fid, nDFiles);
           isOneFSetFinish = true;
         } else {
           // next FSet
           memset(&fset, 0, sizeof(SDFileSet));
           TSDB_FSET_SET_INIT(&fset);
-          fset.nFiles = 1;
+          nDFiles = 1;
           fset.fid = tfid;
           pDFile->f = *pf;
           isOneFSetFinish = false;
@@ -1381,7 +1382,7 @@ static int tsdbRestoreDFileSet(STsdbRepo *pRepo) {
     }
 
     if (isOneFSetFinish) {
-      for (TSDB_FILE_T ftype = 0; ftype < fset.nFiles; ++ftype) {
+      for (TSDB_FILE_T ftype = 0; ftype < nDFiles; ++ftype) {
         SDFile * pDFile1 = TSDB_DFILE_IN_SET(&fset, ftype);
         if (tsdbOpenDFile(pDFile1, O_RDONLY) < 0) {
           tsdbError("vgId:%d failed to open DFile %s since %s", REPO_ID(pRepo), TSDB_FILE_FULL_NAME(pDFile1),
@@ -1418,12 +1419,20 @@ static int tsdbRestoreDFileSet(STsdbRepo *pRepo) {
         tsdbCloseDFile(pDFile1);
       }
       tsdbInfo("vgId:%d FSET %d is restored", REPO_ID(pRepo), fset.fid);
+
+      // TODO: update the logic when TSDB_FSET_VER definition update.
+      if (nDFiles == TSDB_FILE_MIN) {
+        fset.ver = TSDB_FSET_VER_0;
+      } else {
+        fset.ver = TSDB_LATEST_FSET_VER;
+      }
+
       taosArrayPush(pfs->cstatus->df, &fset);
 
       // next FSet
       memset(&fset, 0, sizeof(SDFileSet));
       TSDB_FSET_SET_INIT(&fset);
-      fset.nFiles = 1;
+      nDFiles = 1;
       fset.fid = tfid;
       pDFile->f = *pf;
       isOneFSetFinish = false;
@@ -1512,7 +1521,7 @@ static void tsdbScanAndTryFixDFilesHeader(STsdbRepo *pRepo, int32_t *nExpired) {
       continue;
     }
 
-    for (TSDB_FILE_T ftype = 0; ftype < fset.nFiles; ftype++) {
+    for (TSDB_FILE_T ftype = 0; ftype < tsdbGetNFiles(&fset); ftype++) {
       SDFile *pDFile = TSDB_DFILE_IN_SET(&fset, ftype);
 
       if ((tsdbLoadDFileHeader(pDFile, &info) < 0) || pDFile->info.size != info.size ||
diff --git a/src/tsdb/src/tsdbFile.c b/src/tsdb/src/tsdbFile.c
index 626756fc3973a7e61253970d11a47fb6487d384a..d406b6fe67fea0e98141b397c7e2960bbb9f232a 100644
--- a/src/tsdb/src/tsdbFile.c
+++ b/src/tsdb/src/tsdbFile.c
@@ -563,22 +563,22 @@ static int tsdbRollBackDFile(SDFile *pDFile) {
 }
 
 // ============== Operations on SDFileSet
-void tsdbInitDFileSet(SDFileSet *pSet, SDiskID did, int vid, int fid, uint32_t ver, uint8_t nFiles) {
+void tsdbInitDFileSet(SDFileSet *pSet, SDiskID did, int vid, int fid, uint32_t ver, uint8_t fsetVer) {
   pSet->fid = fid;
   pSet->state = 0;
-  pSet->nFiles = nFiles;
+  pSet->ver = fsetVer;
 
-  for (TSDB_FILE_T ftype = 0; ftype < nFiles; ftype++) {
+  for (TSDB_FILE_T ftype = 0; ftype < tsdbGetNFiles(pSet); ftype++) {
     SDFile *pDFile = TSDB_DFILE_IN_SET(pSet, ftype);
     tsdbInitDFile(pDFile, did, vid, fid, ver, ftype);
   }
 }
 
 void tsdbInitDFileSetEx(SDFileSet *pSet, SDFileSet *pOSet) {
-  ASSERT(TSDB_FSET_NFILES_VALID(pOSet));
+  ASSERT_TSDB_FSET_NFILES_VALID(pOSet);
   pSet->fid = pOSet->fid;
-  pSet->nFiles = pOSet->nFiles;
-  for (TSDB_FILE_T ftype = 0; ftype < pSet->nFiles; ftype++) {
+  pSet->ver = pOSet->ver;
+  for (TSDB_FILE_T ftype = 0; ftype < tsdbGetNFiles(pSet); ftype++) {
     tsdbInitDFileEx(TSDB_DFILE_IN_SET(pSet, ftype), TSDB_DFILE_IN_SET(pOSet, ftype));
   }
 }
@@ -587,8 +587,8 @@ int tsdbEncodeDFileSet(void **buf, SDFileSet *pSet) {
   int tlen = 0;
 
   tlen += taosEncodeFixedI32(buf, pSet->fid);
-  tlen += taosEncodeFixedU8(buf, pSet->nFiles);
-  for (TSDB_FILE_T ftype = 0; ftype < pSet->nFiles; ftype++) {
+  tlen += taosEncodeFixedU8(buf, pSet->ver);
+  for (TSDB_FILE_T ftype = 0; ftype < tsdbGetNFiles(pSet); ftype++) {
     tlen += tsdbEncodeSDFile(buf, TSDB_DFILE_IN_SET(pSet, ftype));
   }
 
@@ -603,11 +603,11 @@ void *tsdbDecodeDFileSet(void *buf, SDFileSet *pSet, uint32_t sfver) {
   pSet->fid = fid;
 
   if (sfver > TSDB_FS_VER_0) {
-    buf = taosDecodeFixedU8(buf, &(pSet->nFiles));
+    buf = taosDecodeFixedU8(buf, &(pSet->ver));
   }
 
-  ASSERT(TSDB_FSET_NFILES_VALID(pSet));
-  for (TSDB_FILE_T ftype = 0; ftype < pSet->nFiles; ftype++) {
+  ASSERT_TSDB_FSET_NFILES_VALID(pSet);
+  for (TSDB_FILE_T ftype = 0; ftype < tsdbGetNFiles(pSet); ftype++) {
     buf = tsdbDecodeSDFile(buf, TSDB_DFILE_IN_SET(pSet, ftype), sfver);
   }
   return buf;
@@ -617,8 +617,8 @@ int tsdbEncodeDFileSetEx(void **buf, SDFileSet *pSet) {
   int tlen = 0;
 
   tlen += taosEncodeFixedI32(buf, pSet->fid);
-  tlen += taosEncodeFixedU8(buf, pSet->nFiles);
-  for (TSDB_FILE_T ftype = 0; ftype < pSet->nFiles; ftype++) {
+  tlen += taosEncodeFixedU8(buf, pSet->ver);
+  for (TSDB_FILE_T ftype = 0; ftype < tsdbGetNFiles(pSet); ftype++) {
     tlen += tsdbEncodeSDFileEx(buf, TSDB_DFILE_IN_SET(pSet, ftype));
   }
 
@@ -629,17 +629,17 @@ void *tsdbDecodeDFileSetEx(void *buf, SDFileSet *pSet) {
   int32_t fid;
 
   buf = taosDecodeFixedI32(buf, &(fid));
-  buf = taosDecodeFixedU8(buf, &(pSet->nFiles));
+  buf = taosDecodeFixedU8(buf, &(pSet->ver));
   pSet->fid = fid;
-  for (TSDB_FILE_T ftype = 0; ftype < pSet->nFiles; ftype++) {
+  for (TSDB_FILE_T ftype = 0; ftype < tsdbGetNFiles(pSet); ftype++) {
     buf = tsdbDecodeSDFileEx(buf, TSDB_DFILE_IN_SET(pSet, ftype));
   }
   return buf;
 }
 
 int tsdbApplyDFileSetChange(SDFileSet *from, SDFileSet *to) {
-  ASSERT(from == NULL || TSDB_FSET_NFILES_VALID(from));
-  for (TSDB_FILE_T ftype = 0; ftype < from->nFiles; ftype++) {
+  uint8_t nDFiles = (from == NULL) ? TSDB_FILE_MAX : tsdbGetNFiles(from);
+  for (TSDB_FILE_T ftype = 0; ftype < nDFiles; ftype++) {
     SDFile *pDFileFrom = (from) ? TSDB_DFILE_IN_SET(from, ftype) : NULL;
     SDFile *pDFileTo = (to) ? TSDB_DFILE_IN_SET(to, ftype) : NULL;
     if (tsdbApplyDFileChange(pDFileFrom, pDFileTo) < 0) {
@@ -651,7 +651,7 @@ int tsdbApplyDFileSetChange(SDFileSet *from, SDFileSet *to) {
 }
 
 int tsdbCreateDFileSet(SDFileSet *pSet, bool updateHeader) {
-  for (TSDB_FILE_T ftype = 0; ftype < pSet->nFiles; ftype++) {
+  for (TSDB_FILE_T ftype = 0; ftype < tsdbGetNFiles(pSet); ftype++) {
     if (tsdbCreateDFile(TSDB_DFILE_IN_SET(pSet, ftype), updateHeader, ftype) < 0) {
       tsdbCloseDFileSet(pSet);
       tsdbRemoveDFileSet(pSet);
@@ -663,7 +663,7 @@ int tsdbCreateDFileSet(SDFileSet *pSet, bool updateHeader) {
 }
 
 int tsdbUpdateDFileSetHeader(SDFileSet *pSet) {
-  for (TSDB_FILE_T ftype = 0; ftype < pSet->nFiles; ftype++) {
+  for (TSDB_FILE_T ftype = 0; ftype < tsdbGetNFiles(pSet); ftype++) {
     if (tsdbUpdateDFileHeader(TSDB_DFILE_IN_SET(pSet, ftype)) < 0) {
       return -1;
     }
@@ -672,8 +672,8 @@ int tsdbUpdateDFileSetHeader(SDFileSet *pSet) {
 }
 
 int tsdbScanAndTryFixDFileSet(STsdbRepo *pRepo, SDFileSet *pSet) {
-  ASSERT(TSDB_FSET_NFILES_VALID(pSet));
-  for (TSDB_FILE_T ftype = 0; ftype < pSet->nFiles; ftype++) {
+  ASSERT_TSDB_FSET_NFILES_VALID(pSet);
+  for (TSDB_FILE_T ftype = 0; ftype < tsdbGetNFiles(pSet); ftype++) {
     if (tsdbScanAndTryFixDFile(pRepo, TSDB_DFILE_IN_SET(pSet, ftype)) < 0) {
       return -1;
     }
diff --git a/src/tsdb/src/tsdbSync.c b/src/tsdb/src/tsdbSync.c
index debbabd38c58466edcc9c16da1f1010742fdbded..0e01cf37bb264b1d2eb36b7332e2ebea28edfce9 100644
--- a/src/tsdb/src/tsdbSync.c
+++ b/src/tsdb/src/tsdbSync.c
@@ -466,7 +466,7 @@ static int32_t tsdbSyncRecvDFileSetArray(SSyncH *pSynch) {
           return -1;
         }
 
-        tsdbInitDFileSet(&fset, did, REPO_ID(pRepo), pSynch->pdf->fid, FS_TXN_VERSION(pfs), pSynch->pdf->nFiles);
+        tsdbInitDFileSet(&fset, did, REPO_ID(pRepo), pSynch->pdf->fid, FS_TXN_VERSION(pfs), pSynch->pdf->ver);
 
         // Create new FSET
         if (tsdbCreateDFileSet(&fset, false) < 0) {
@@ -474,7 +474,7 @@ static int32_t tsdbSyncRecvDFileSetArray(SSyncH *pSynch) {
           return -1;
         }
 
-        for (TSDB_FILE_T ftype = 0; ftype < pSynch->pdf->nFiles; ftype++) {
+        for (TSDB_FILE_T ftype = 0; ftype < tsdbGetNFiles(pSynch->pdf); ftype++) {
           SDFile *pDFile = TSDB_DFILE_IN_SET(&fset, ftype);         // local file
           SDFile *pRDFile = TSDB_DFILE_IN_SET(pSynch->pdf, ftype);  // remote file
 
@@ -550,10 +550,10 @@ static int32_t tsdbSyncRecvDFileSetArray(SSyncH *pSynch) {
 }
 
 static bool tsdbIsTowFSetSame(SDFileSet *pSet1, SDFileSet *pSet2) {
-  if (pSet1->nFiles != pSet2->nFiles) {
+  if (pSet1->ver != pSet2->ver) {
     return false;
   }
-  for (TSDB_FILE_T ftype = 0; ftype < pSet1->nFiles; ftype++) {
+  for (TSDB_FILE_T ftype = 0; ftype < tsdbGetNFiles(pSet1); ftype++) {
     SDFile *pDFile1 = TSDB_DFILE_IN_SET(pSet1, ftype);
     SDFile *pDFile2 = TSDB_DFILE_IN_SET(pSet2, ftype);
 
@@ -595,7 +595,7 @@ static int32_t tsdbSyncSendDFileSet(SSyncH *pSynch, SDFileSet *pSet) {
   if (toSend) {
     tsdbInfo("vgId:%d, fileset:%d will be sent", REPO_ID(pRepo), pSet->fid);
 
-    for (TSDB_FILE_T ftype = 0; ftype < pSet->nFiles; ftype++) {
+    for (TSDB_FILE_T ftype = 0; ftype < tsdbGetNFiles(pSet); ftype++) {
       SDFile df = *TSDB_DFILE_IN_SET(pSet, ftype);
       
       if (tsdbOpenDFile(&df, O_RDONLY) < 0) {