react-native-mmkv 2.10.2 → 2.12.0

package/MMKV/Core/MMKV_IO.cpp

@@ -52,6 +52,8 @@
 using namespace std;
 using namespace mmkv;
 using KVHolderRet_t = std::pair<bool, KeyValueHolder>;
+extern ThreadLock *g_instanceLock;
+extern unordered_map<string, MMKV *> *g_instanceDic;
 
 MMKV_NAMESPACE_BEGIN
 
@@ -65,7 +67,7 @@ void MMKV::loadFromFile() {
     }
 #endif
     if (!m_file->isFileValid()) {
-        m_file->reloadFromFile();
+        m_file->reloadFromFile(m_expectedCapacity);
     }
     if (!m_file->isFileValid()) {
         MMKVError("file [%s] not valid", m_path.c_str());
@@ -132,6 +134,9 @@ void MMKV::loadFromFile() {
 
 // read from last m_position
 void MMKV::partialLoadFromFile() {
+    if (!m_file->isFileValid()) {
+        return;
+    }
     m_metaInfo->read(m_metaFile->getMemory());
 
     size_t oldActualSize = m_actualSize;
@@ -187,7 +192,8 @@ void MMKV::loadMetaInfoAndCheck() {
     m_metaInfo->read(m_metaFile->getMemory());
     // the meta file is in specious status
     if (m_metaInfo->m_version >= MMKVVersionHolder) {
-        MMKVWarning("meta file [%s] in specious state, version %u, flags 0x%llx", m_mmapID.c_str(), m_metaInfo->m_version, m_metaInfo->m_flags);
+        MMKVWarning("meta file [%s] in specious state, version %u, flags 0x%llx", m_mmapID.c_str(),
+                    m_metaInfo->m_version, m_metaInfo->m_flags);
 
         // MMKVVersionActualSize is the last version we don't check meta file
         m_metaInfo->m_version = MMKVVersionActualSize;
@@ -197,6 +203,10 @@ void MMKV::loadMetaInfoAndCheck() {
 
     if (m_metaInfo->m_version >= MMKVVersionFlag) {
         m_enableKeyExpire = m_metaInfo->hasFlag(MMKVMetaInfo::EnableKeyExipre);
+        if (m_enableKeyExpire && m_enableCompareBeforeSet) {
+            MMKVError("enableCompareBeforeSet will be invalid when Expiration is on");
+            m_enableCompareBeforeSet = false;
+        }
         MMKVInfo("meta file [%s] has flag [%llu]", m_mmapID.c_str(), m_metaInfo->m_flags);
     } else {
         if (m_metaInfo->m_flags != 0) {
@@ -253,8 +263,8 @@ void MMKV::checkDataValid(bool &loadFromFile, bool &needFullWriteback) {
             loadFromFile = true;
         } else {
             checkLastConfirmedInfo();
-
             if (!loadFromFile) {
+
                 auto strategic = onMMKVCRCCheckFail(m_mmapID);
                 if (strategic == OnErrorRecover) {
                     loadFromFile = true;
@@ -392,22 +402,25 @@ bool MMKV::ensureMemorySize(size_t newSize) {
         }
         // try a full rewrite to make space
         auto preparedData = m_crypter ? prepareEncode(*m_dicCrypt) : prepareEncode(*m_dic);
-        return expandAndWriteBack(newSize, std::move(preparedData));
+        // dic.empty() means inserting key-value for the first time, no need to call msync()
+        return expandAndWriteBack(newSize, std::move(preparedData), m_crypter ? !m_dicCrypt->empty() : !m_dic->empty());
     }
     return true;
 }
 
 // try a full rewrite to make space
-bool MMKV::expandAndWriteBack(size_t newSize, std::pair<mmkv::MMBuffer, size_t> preparedData) {
+bool MMKV::expandAndWriteBack(size_t newSize, std::pair<mmkv::MMBuffer, size_t> preparedData, bool needSync) {
     auto fileSize = m_file->getFileSize();
     auto sizeOfDic = preparedData.second;
     size_t lenNeeded = sizeOfDic + Fixed32Size + newSize;
-    size_t dicCount = m_crypter ? m_dicCrypt->size() : m_dic->size();
-    size_t avgItemSize = lenNeeded / std::max<size_t>(1, dicCount);
-    size_t futureUsage = avgItemSize * std::max<size_t>(8, (dicCount + 1) / 2);
+    size_t nowDicCount = m_crypter ? m_dicCrypt->size() : m_dic->size();
+    size_t laterDicCount = std::max<size_t>(1, nowDicCount + 1);
+    // or use <cmath> ceil()
+    size_t avgItemSize = (lenNeeded + laterDicCount - 1) / laterDicCount;
+    size_t futureUsage = avgItemSize * std::max<size_t>(8, laterDicCount / 2);
     // 1. no space for a full rewrite, double it
     // 2. or space is not large enough for future usage, double it to avoid frequently full rewrite
-    if (lenNeeded >= fileSize || (lenNeeded + futureUsage) >= fileSize) {
+    if (lenNeeded >= fileSize || (needSync && (lenNeeded + futureUsage) >= fileSize)) {
         size_t oldSize = fileSize;
         do {
             fileSize *= 2;
@@ -416,6 +429,7 @@ bool MMKV::expandAndWriteBack(size_t newSize, std::pair<mmkv::MMBuffer, size_t>
                  oldSize, fileSize, newSize, futureUsage);
 
         // if we can't extend size, rollback to old state
+        // this is a good place to mock enlarging file failure
         if (!m_file->truncate(fileSize)) {
             return false;
         }
@@ -426,7 +440,7 @@ bool MMKV::expandAndWriteBack(size_t newSize, std::pair<mmkv::MMBuffer, size_t>
             return false;
         }
     }
-    return doFullWriteBack(std::move(preparedData), nullptr);
+    return doFullWriteBack(std::move(preparedData), nullptr, needSync);
 }
 
 size_t MMKV::readActualSize() {
@@ -573,10 +587,21 @@ bool MMKV::setDataForKey(MMBuffer &&data, MMKVKey_t key, bool isDataHolder) {
         }
         auto itr = m_dicCrypt->find(key);
         if (itr != m_dicCrypt->end()) {
+            bool onlyOneKey = !m_isInterProcess && m_dicCrypt->size() == 1;
 #    ifdef MMKV_APPLE
-            auto ret = appendDataWithKey(data, key, itr->second, isDataHolder);
+            KVHolderRet_t ret;
+            if (onlyOneKey) {
+                ret = overrideDataWithKey(data, key, itr->second, isDataHolder);
+            } else {
+                ret = appendDataWithKey(data, key, itr->second, isDataHolder);
+            }
 #    else
-            auto ret = appendDataWithKey(data, key, isDataHolder);
+            KVHolderRet_t ret;
+            if (onlyOneKey) {
+                ret = overrideDataWithKey(data, key, isDataHolder);
+            } else {
+                ret = appendDataWithKey(data, key, isDataHolder);
+            }
 #    endif
             if (!ret.first) {
                 return false;
@@ -597,11 +622,17 @@ bool MMKV::setDataForKey(MMBuffer &&data, MMKVKey_t key, bool isDataHolder) {
                 } else {
                     // in case filterExpiredKeys() is triggered
                     m_dicCrypt->emplace(key, std::move(kvHolder));
-                    retain_key(key);
+                    mmkv_retain_key(key);
                 }
             }
         } else {
-            auto ret = appendDataWithKey(data, key, isDataHolder);
+            bool needOverride = !m_isInterProcess && m_dicCrypt->empty() && m_actualSize > 0;
+            KVHolderRet_t ret;
+            if (needOverride) {
+                ret = overrideDataWithKey(data, key, isDataHolder);
+            } else {
+                ret = appendDataWithKey(data, key, isDataHolder);
+            }
             if (!ret.first) {
                 return false;
             }
@@ -614,21 +645,58 @@ bool MMKV::setDataForKey(MMBuffer &&data, MMKVKey_t key, bool isDataHolder) {
             } else {
                 m_dicCrypt->emplace(key, KeyValueHolderCrypt(std::move(data)));
             }
-            retain_key(key);
+            mmkv_retain_key(key);
         }
     } else
 #endif // MMKV_DISABLE_CRYPT
     {
         auto itr = m_dic->find(key);
         if (itr != m_dic->end()) {
+            // compare data before appending to file
+            if (isCompareBeforeSetEnabled()) {
+                auto basePtr = (uint8_t *) (m_file->getMemory()) + Fixed32Size;
+                MMBuffer oldValueData = itr->second.toMMBuffer(basePtr);
+                if (isDataHolder) {
+                    CodedInputData inputData(oldValueData.getPtr(), oldValueData.length());
+                    try {
+                        // read extra holder header bytes and to real MMBuffer
+                        oldValueData = CodedInputData::readRealData(oldValueData);
+                        if (oldValueData == data) {
+                            // MMKVInfo("[key] %s, set the same data", key.c_str());
+                            return true;
+                        }
+                    } catch (std::exception &exception) {
+                        MMKVError("compareBeforeSet exception: %s", exception.what());
+                    } catch (...) {
+                        MMKVError("compareBeforeSet fail");
+                    }
+                } else {
+                    if (oldValueData == data) {
+                        //  MMKVInfo("[key] %s, set the same data", key.c_str());
+                        return true;
+                    }
+                }
+            }
+
+            bool onlyOneKey = !m_isInterProcess && m_dic->size() == 1;
             if (likely(!m_enableKeyExpire)) {
-                auto ret = appendDataWithKey(data, itr->second, isDataHolder);
+                KVHolderRet_t ret;
+                if (onlyOneKey) {
+                    ret = overrideDataWithKey(data, itr->second, isDataHolder);
+                } else {
+                    ret = appendDataWithKey(data, itr->second, isDataHolder);
+                }
                 if (!ret.first) {
                     return false;
                 }
                 itr->second = std::move(ret.second);
             } else {
-                auto ret = appendDataWithKey(data, key, isDataHolder);
+                KVHolderRet_t ret;
+                if (onlyOneKey) {
+                    ret = overrideDataWithKey(data, key, isDataHolder);
+                } else {
+                    ret = appendDataWithKey(data, key, isDataHolder);
+                }
                 if (!ret.first) {
                     return false;
                 }
@@ -638,16 +706,22 @@ bool MMKV::setDataForKey(MMBuffer &&data, MMKVKey_t key, bool isDataHolder) {
                 } else {
                     // in case filterExpiredKeys() is triggered
                     m_dic->emplace(key, std::move(ret.second));
-                    retain_key(key);
+                    mmkv_retain_key(key);
                 }
             }
         } else {
-            auto ret = appendDataWithKey(data, key, isDataHolder);
+            bool needOverride = !m_isInterProcess && m_dic->empty() && m_actualSize > 0;
+            KVHolderRet_t ret;
+            if (needOverride) {
+                ret = overrideDataWithKey(data, key, isDataHolder);
+            } else {
+                ret = appendDataWithKey(data, key, isDataHolder);
+            }
             if (!ret.first) {
                 return false;
             }
             m_dic->emplace(key, std::move(ret.second));
-            retain_key(key);
+            mmkv_retain_key(key);
         }
     }
     m_hasFullWriteback = false;
@@ -772,6 +846,9 @@ MMKV::doAppendDataWithKey(const MMBuffer &data, const MMBuffer &keyData, bool is
     } catch (std::exception &e) {
         MMKVError("%s", e.what());
         return make_pair(false, KeyValueHolder());
+    } catch (...) {
+        MMKVError("append fail");
+        return make_pair(false, KeyValueHolder());
     }
 
     auto offset = static_cast<uint32_t>(m_actualSize);
@@ -787,6 +864,97 @@ MMKV::doAppendDataWithKey(const MMBuffer &data, const MMBuffer &keyData, bool is
     return make_pair(true, KeyValueHolder(originKeyLength, valueLength, offset));
 }
 
+KVHolderRet_t MMKV::doOverrideDataWithKey(const MMBuffer &data,
+                                          const MMBuffer &keyData,
+                                          bool isDataHolder,
+                                          uint32_t originKeyLength) {
+    auto isKeyEncoded = (originKeyLength < keyData.length());
+    auto keyLength = static_cast<uint32_t>(keyData.length());
+    auto valueLength = static_cast<uint32_t>(data.length());
+    if (isDataHolder) {
+        valueLength += pbRawVarint32Size(valueLength);
+    }
+    // size needed to encode the key
+    size_t size = isKeyEncoded ? keyLength : (keyLength + pbRawVarint32Size(keyLength));
+    // size needed to encode the value
+    size += valueLength + pbRawVarint32Size(valueLength);
+
+    if (!checkSizeForOverride(size)) {
+        return doAppendDataWithKey(data, keyData, isDataHolder, originKeyLength);
+    }
+
+    // we don't not support override in multi-process mode
+    // SCOPED_LOCK(m_exclusiveProcessLock);
+
+#ifdef MMKV_IOS
+    auto ret = guardForBackgroundWriting(m_output->curWritePointer(), size);
+    if (!ret.first) {
+        return make_pair(false, KeyValueHolder());
+    }
+#endif
+#ifndef MMKV_DISABLE_CRYPT
+    if (m_crypter) {
+        if (m_metaInfo->m_version >= MMKVVersionRandomIV) {
+            m_crypter->resetIV(m_metaInfo->m_vector, sizeof(m_metaInfo->m_vector));
+        } else {
+            m_crypter->resetIV();
+        }
+        if (KeyValueHolderCrypt::isValueStoredAsOffset(valueLength)) {
+            m_crypter->getCurStatus(t_status);
+        }
+    }
+#endif
+    try {
+        // write ItemSizeHolder
+        m_output->setPosition(0);
+        m_output->writeRawVarint32(ItemSizeHolder);
+        m_actualSize = ItemSizeHolderSize;
+
+        if (isKeyEncoded) {
+            m_output->writeRawData(keyData);
+        } else {
+            m_output->writeData(keyData);
+        }
+        if (isDataHolder) {
+            m_output->writeRawVarint32((int32_t) valueLength);
+        }
+        m_output->writeData(data); // note: write size of data
+    } catch (std::exception &e) {
+        MMKVError("%s", e.what());
+        return make_pair(false, KeyValueHolder());
+    } catch (...) {
+        MMKVError("append fail");
+        return make_pair(false, KeyValueHolder());
+    }
+
+    auto offset = static_cast<uint32_t>(m_actualSize);
+    m_actualSize += size;
+    auto ptr = (uint8_t *) m_file->getMemory() + Fixed32Size;
+#ifndef MMKV_DISABLE_CRYPT
+    if (m_crypter) {
+        m_crypter->encrypt(ptr, ptr, m_actualSize);
+    }
+#endif
+    recaculateCRCDigestOnly();
+
+    return make_pair(true, KeyValueHolder(originKeyLength, valueLength, offset));
+}
+
+bool MMKV::checkSizeForOverride(size_t size) {
+    if (!isFileValid()) {
+        MMKVWarning("[%s] file not valid", m_mmapID.c_str());
+        return false;
+    }
+
+    // only override if the file can hole it without ftruncate()
+    auto fileSize = m_file->getFileSize();
+    auto spaceNeededForOverride = size + Fixed32Size + ItemSizeHolderSize;
+    if (size > fileSize || spaceNeededForOverride > fileSize) {
+        return false;
+    }
+    return true;
+}
+
 KVHolderRet_t MMKV::appendDataWithKey(const MMBuffer &data, MMKVKey_t key, bool isDataHolder) {
 #ifdef MMKV_APPLE
     auto oData = [key dataUsingEncoding:NSUTF8StringEncoding];
@@ -797,6 +965,16 @@ KVHolderRet_t MMKV::appendDataWithKey(const MMBuffer &data, MMKVKey_t key, bool
     return doAppendDataWithKey(data, keyData, isDataHolder, static_cast<uint32_t>(keyData.length()));
 }
 
+KVHolderRet_t MMKV::overrideDataWithKey(const MMBuffer &data, MMKVKey_t key, bool isDataHolder) {
+#ifdef MMKV_APPLE
+    auto oData = [key dataUsingEncoding:NSUTF8StringEncoding];
+    auto keyData = MMBuffer(oData, MMBufferNoCopy);
+#else
+    auto keyData = MMBuffer((void *) key.data(), key.size(), MMBufferNoCopy);
+#endif
+    return doOverrideDataWithKey(data, keyData, isDataHolder, static_cast<uint32_t>(keyData.length()));
+}
+
 KVHolderRet_t MMKV::appendDataWithKey(const MMBuffer &data, const KeyValueHolder &kvHolder, bool isDataHolder) {
     SCOPED_LOCK(m_exclusiveProcessLock);
 
@@ -822,7 +1000,35 @@ KVHolderRet_t MMKV::appendDataWithKey(const MMBuffer &data, const KeyValueHolder
     return doAppendDataWithKey(data, keyData, isDataHolder, keyLength);
 }
 
-bool MMKV::fullWriteback(AESCrypt *newCrypter) {
+// only one key in dict, do not append, just rewrite from beginning
+KVHolderRet_t MMKV::overrideDataWithKey(const MMBuffer &data, const KeyValueHolder &kvHolder, bool isDataHolder) {
+    // we don't not support override in multi-process mode
+    // SCOPED_LOCK(m_exclusiveProcessLock);
+
+    uint32_t keyLength = kvHolder.keySize;
+    // size needed to encode the key
+    size_t rawKeySize = keyLength + pbRawVarint32Size(keyLength);
+
+    // ensureMemorySize() (inside doAppendDataWithKey() which be called from doOverrideDataWithKey())
+    // might change kvHolder.offset, so have to do it early
+    {
+        auto valueLength = static_cast<uint32_t>(data.length());
+        if (isDataHolder) {
+            valueLength += pbRawVarint32Size(valueLength);
+        }
+        auto size = rawKeySize + valueLength + pbRawVarint32Size(valueLength);
+        bool hasEnoughSize = checkSizeForOverride(size);
+        if (!hasEnoughSize) {
+            return appendDataWithKey(data, kvHolder, isDataHolder);
+        }
+    }
+    auto basePtr = (uint8_t *) m_file->getMemory() + Fixed32Size;
+    MMBuffer keyData(basePtr + kvHolder.offset, rawKeySize, MMBufferNoCopy);
+
+    return doOverrideDataWithKey(data, keyData, isDataHolder, keyLength);
+}
+
+bool MMKV::fullWriteback(AESCrypt *newCrypter, bool onlyWhileExpire) {
     if (m_hasFullWriteback) {
         return true;
     }
@@ -835,10 +1041,14 @@ bool MMKV::fullWriteback(AESCrypt *newCrypter) {
     }
 
     if (unlikely(m_enableKeyExpire)) {
-        filterExpiredKeys();
+        auto expiredCount = filterExpiredKeys();
+        if (onlyWhileExpire && expiredCount == 0) {
+            return true;
+        }
     }
 
-    if (m_crypter ? m_dicCrypt->empty() : m_dic->empty()) {
+    auto isEmpty = m_crypter ? m_dicCrypt->empty() : m_dic->empty();
+    if (isEmpty) {
         clearAll();
         return true;
     }
@@ -1012,25 +1222,25 @@ static void fullWriteBackWholeData(MMBuffer allData, size_t totalSize, CodedOutp
     if (allData.length() > 0) {
         auto dataSize = CodedInputData(allData.getPtr(), allData.length()).readUInt32();
         if (dataSize > 0) {
-            auto dataPtr = (uint8_t *)allData.getPtr() + pbRawVarint32Size(dataSize);
+            auto dataPtr = (uint8_t *) allData.getPtr() + pbRawVarint32Size(dataSize);
             memcpy(output->curWritePointer(), dataPtr, dataSize);
             output->seek(dataSize);
         }
     }
-    [[maybe_unused]] auto writtenSize = (size_t) (output->curWritePointer() - originOutputPtr);
+    [[maybe_unused]] auto writtenSize = (size_t)(output->curWritePointer() - originOutputPtr);
     assert(writtenSize == totalSize);
 }
 
 #ifndef MMKV_DISABLE_CRYPT
-bool MMKV::doFullWriteBack(pair<MMBuffer, size_t> prepared, AESCrypt *newCrypter) {
+bool MMKV::doFullWriteBack(pair<MMBuffer, size_t> prepared, AESCrypt *newCrypter, bool needSync) {
     auto ptr = (uint8_t *) m_file->getMemory();
     auto totalSize = prepared.second;
-#ifdef MMKV_IOS
+#    ifdef MMKV_IOS
     auto ret = guardForBackgroundWriting(ptr + Fixed32Size, totalSize);
     if (!ret.first) {
         return false;
     }
-#endif
+#    endif
 
     uint8_t newIV[AES_KEY_LEN];
     auto encrypter = (newCrypter == InvalidCryptPtr) ? nullptr : (newCrypter ? newCrypter : m_crypter);
@@ -1061,22 +1271,24 @@ bool MMKV::doFullWriteBack(pair<MMBuffer, size_t> prepared, AESCrypt *newCrypter
         recaculateCRCDigestWithIV(nullptr);
     }
     m_hasFullWriteback = true;
-    // make sure lastConfirmedMetaInfo is saved
-    sync(MMKV_SYNC);
+    // make sure lastConfirmedMetaInfo is saved if needed
+    if (needSync) {
+        sync(MMKV_SYNC);
+    }
     return true;
 }
 
 #else // MMKV_DISABLE_CRYPT
 
-bool MMKV::doFullWriteBack(pair<MMBuffer, size_t> prepared, AESCrypt *) {
+bool MMKV::doFullWriteBack(pair<MMBuffer, size_t> prepared, AESCrypt *, bool needSync) {
     auto ptr = (uint8_t *) m_file->getMemory();
     auto totalSize = prepared.second;
-#ifdef MMKV_IOS
+#    ifdef MMKV_IOS
     auto ret = guardForBackgroundWriting(ptr + Fixed32Size, totalSize);
     if (!ret.first) {
         return false;
     }
-#endif
+#    endif
 
     delete m_output;
     m_output = new CodedOutputData(ptr + Fixed32Size, m_file->getFileSize() - Fixed32Size);
@@ -1091,8 +1303,10 @@ bool MMKV::doFullWriteBack(pair<MMBuffer, size_t> prepared, AESCrypt *) {
     m_actualSize = totalSize;
     recaculateCRCDigestWithIV(nullptr);
     m_hasFullWriteback = true;
-    // make sure lastConfirmedMetaInfo is saved
-    sync(MMKV_SYNC);
+    // make sure lastConfirmedMetaInfo is saved if needed
+    if (needSync) {
+        sync(MMKV_SYNC);
+    }
     return true;
 }
 #endif // MMKV_DISABLE_CRYPT
@@ -1102,6 +1316,10 @@ bool MMKV::reKey(const string &cryptKey) {
     SCOPED_LOCK(m_lock);
     SCOPED_LOCK(m_exclusiveProcessLock);
     checkLoadData();
+    if (!isFileValid()) {
+        MMKVWarning("[%s] file not valid", m_mmapID.c_str());
+        return false;
+    }
 
     bool ret = false;
     if (m_crypter) {
@@ -1167,11 +1385,15 @@ void MMKV::trim() {
     MMKVInfo("prepare to trim %s", m_mmapID.c_str());
 
     checkLoadData();
+    if (!isFileValid()) {
+        MMKVWarning("[%s] file not valid", m_mmapID.c_str());
+        return;
+    }
 
     if (m_actualSize == 0) {
         clearAll();
         return;
-    } else if (m_file->getFileSize() <= DEFAULT_MMAP_SIZE) {
+    } else if (m_file->getFileSize() <= m_expectedCapacity) {
         return;
     }
     SCOPED_LOCK(m_exclusiveProcessLock);
@@ -1182,7 +1404,7 @@ void MMKV::trim() {
     while (fileSize > (m_actualSize + Fixed32Size) * 2) {
         fileSize /= 2;
     }
-    fileSize = std::max<size_t>(fileSize, DEFAULT_MMAP_SIZE);
+    fileSize = std::max<size_t>(fileSize, m_expectedCapacity);
     if (oldSize == fileSize) {
         MMKVInfo("there's no need to trim %s with size %zu, actualSize %zu", m_mmapID.c_str(), fileSize, m_actualSize);
         return;
@@ -1202,18 +1424,25 @@ void MMKV::trim() {
     MMKVInfo("finish trim %s from %zu to %zu", m_mmapID.c_str(), oldSize, fileSize);
 }
 
-void MMKV::clearAll() {
+void MMKV::clearAll(bool keepSpace) {
     MMKVInfo("cleaning all key-values from [%s]", m_mmapID.c_str());
     SCOPED_LOCK(m_lock);
     SCOPED_LOCK(m_exclusiveProcessLock);
 
     checkLoadData();
+    if (!isFileValid()) {
+        MMKVWarning("[%s] file not valid", m_mmapID.c_str());
+        return;
+    }
 
-    if (m_file->getFileSize() == DEFAULT_MMAP_SIZE && m_actualSize == 0) {
+    if (m_file->getFileSize() == m_expectedCapacity && m_actualSize == 0) {
         MMKVInfo("nothing to clear for [%s]", m_mmapID.c_str());
         return;
     }
-    m_file->truncate(DEFAULT_MMAP_SIZE);
+
+    if (!keepSpace) {
+        m_file->truncate(m_expectedCapacity);
+    }
 
 #ifndef MMKV_DISABLE_CRYPT
     uint8_t newIV[AES_KEY_LEN];
@@ -1225,9 +1454,10 @@ void MMKV::clearAll() {
 #else
     writeActualSize(0, 0, nullptr, IncreaseSequence);
 #endif
+
     m_metaFile->msync(MMKV_SYNC);
 
-    clearMemoryCache();
+    clearMemoryCache(keepSpace);
     loadFromFile();
 }
 
@@ -1275,6 +1505,54 @@ bool MMKV::isFileValid(const string &mmapID, MMKVPath_t *relatePath) {
     }
 }
 
+bool MMKV::removeStorage(const std::string &mmapID, MMKVPath_t *relatePath) {
+    auto mmapKey = mmapedKVKey(mmapID, relatePath);
+#ifdef MMKV_ANDROID
+    auto &realID = mmapKey; // historically Android mistakenly use mmapKey as mmapID
+#else
+    auto &realID = mmapID;
+#endif
+    MMKVDebug("mmapKey %s", mmapKey.c_str());
+
+    MMKVPath_t kvPath = mappedKVPathWithID(realID, MMKV_SINGLE_PROCESS, relatePath);
+    if (!isFileExist(kvPath)) {
+        MMKVWarning("file not exist %s", kvPath.c_str());
+        return false;
+    }
+    MMKVPath_t crcPath = crcPathWithID(realID, MMKV_SINGLE_PROCESS, relatePath);
+    if (!isFileExist(crcPath)) {
+        MMKVWarning("file not exist %s", crcPath.c_str());
+        return false;
+    }
+
+    MMKVInfo("remove storage [%s]", mmapID.c_str());
+    SCOPED_LOCK(g_instanceLock);
+
+    File crcFile(crcPath, OpenFlag::ReadOnly);
+    if (!crcFile.isFileValid()) {
+        return false;
+    }
+    FileLock fileLock(crcFile.getFd());
+    InterProcessLock lock(&fileLock, ExclusiveLockType);
+    SCOPED_LOCK(&lock);
+
+    auto itr = g_instanceDic->find(mmapKey);
+    if (itr != g_instanceDic->end()) {
+        itr->second->close();
+        // itr is not valid after this
+    }
+
+#ifndef MMKV_WIN32
+    ::unlink(kvPath.c_str());
+    ::unlink(crcPath.c_str());
+#else
+    DeleteFile(kvPath.c_str());
+    DeleteFile(crcPath.c_str());
+#endif
+
+    return true;
+}
+
 // ---- auto expire ----
 
 uint32_t MMKV::getCurrentTimeInSecond() {
@@ -1311,6 +1589,15 @@ bool MMKV::enableAutoKeyExpire(uint32_t expiredInSeconds) {
     SCOPED_LOCK(m_lock);
     SCOPED_LOCK(m_exclusiveProcessLock);
     checkLoadData();
+    if (!isFileValid() || !m_metaFile->isFileValid()) {
+        MMKVWarning("[%s] file not valid", m_mmapID.c_str());
+        return false;
+    }
+
+    if (m_enableCompareBeforeSet) {
+        MMKVError("enableCompareBeforeSet will be invalid when Expiration is on");
+        m_enableCompareBeforeSet = false;
+    }
 
     if (m_expiredInSeconds != expiredInSeconds) {
         MMKVInfo("expiredInSeconds: %u", expiredInSeconds);
@@ -1327,7 +1614,7 @@ bool MMKV::enableAutoKeyExpire(uint32_t expiredInSeconds) {
     m_metaInfo->setFlag(MMKVMetaInfo::EnableKeyExipre);
     m_metaInfo->m_version = MMKVVersionFlag;
 
-    if (m_file->getFileSize() == DEFAULT_MMAP_SIZE && m_actualSize == 0) {
+    if (m_file->getFileSize() == m_expectedCapacity && m_actualSize == 0) {
         MMKVInfo("file is new, don't need a full writeback [%s], just update meta file", m_mmapID.c_str());
         writeActualSize(0, 0, nullptr, IncreaseSequence);
         m_metaFile->msync(MMKV_SYNC);
@@ -1337,7 +1624,7 @@ bool MMKV::enableAutoKeyExpire(uint32_t expiredInSeconds) {
     MMKVVector vec;
     auto packKeyValue = [&](const MMKVKey_t &key, const MMBuffer &value) {
         MMBuffer data(value.length() + Fixed32Size);
-        auto ptr = (uint8_t *)data.getPtr();
+        auto ptr = (uint8_t *) data.getPtr();
         memcpy(ptr, value.getPtr(), value.length());
         memcpy(ptr + value.length(), &time, Fixed32Size);
         vec.emplace_back(key, std::move(data));
@@ -1370,6 +1657,10 @@ bool MMKV::disableAutoKeyExpire() {
     SCOPED_LOCK(m_lock);
     SCOPED_LOCK(m_exclusiveProcessLock);
     checkLoadData();
+    if (!isFileValid() || !m_metaFile->isFileValid()) {
+        MMKVWarning("[%s] file not valid", m_mmapID.c_str());
+        return false;
+    }
 
     m_expiredInSeconds = 0;
     m_enableKeyExpire = false;
@@ -1381,7 +1672,7 @@ bool MMKV::disableAutoKeyExpire() {
     m_metaInfo->unsetFlag(MMKVMetaInfo::EnableKeyExipre);
     m_metaInfo->m_version = MMKVVersionFlag;
 
-    if (m_file->getFileSize() == DEFAULT_MMAP_SIZE && m_actualSize == 0) {
+    if (m_file->getFileSize() == m_expectedCapacity && m_actualSize == 0) {
         MMKVInfo("file is new, don't need a full write-back [%s], just update meta file", m_mmapID.c_str());
         writeActualSize(0, 0, nullptr, IncreaseSequence);
         m_metaFile->msync(MMKV_SYNC);
@@ -1392,7 +1683,7 @@ bool MMKV::disableAutoKeyExpire() {
     auto packKeyValue = [&](const MMKVKey_t &key, const MMBuffer &value) {
         assert(value.length() >= Fixed32Size);
         MMBuffer data(value.length() - Fixed32Size);
-        auto ptr = (uint8_t *)data.getPtr();
+        auto ptr = (uint8_t *) data.getPtr();
         memcpy(ptr, value.getPtr(), value.length() - Fixed32Size);
         vec.emplace_back(key, std::move(data));
     };
@@ -1425,7 +1716,7 @@ uint32_t MMKV::getExpireTimeForKey(MMKVKey_t key) {
     SCOPED_LOCK(m_sharedProcessLock);
     checkLoadData();
 
-    if (!m_enableKeyExpire || key_length(key) == 0) {
+    if (!m_enableKeyExpire || mmkv_key_length(key) == 0) {
         return 0;
     }
     auto raw = getRawDataForKey(key);
@@ -1433,8 +1724,8 @@ uint32_t MMKV::getExpireTimeForKey(MMKVKey_t key) {
     if (raw.length() < Fixed32Size) {
         return 0;
     }
-    auto ptr = (const uint8_t *)raw.getPtr() + raw.length() - Fixed32Size;
-    auto time = *(const uint32_t *)ptr;
+    auto ptr = (const uint8_t *) raw.getPtr() + raw.length() - Fixed32Size;
+    auto time = *(const uint32_t *) ptr;
     return time;
 }
 
@@ -1450,8 +1741,8 @@ mmkv::MMBuffer MMKV::getDataWithoutMTimeForKey(MMKVKey_t key) {
     }
     auto newLength = raw.length() - Fixed32Size;
     if (m_enableKeyExpire) {
-        auto ptr = (const uint8_t *)raw.getPtr() + newLength;
-        auto time = *(const uint32_t *)ptr;
+        auto ptr = (const uint8_t *) raw.getPtr() + newLength;
+        auto time = *(const uint32_t *) ptr;
         if (time != ExpireNever && time <= getCurrentTimeInSecond()) {
 #ifdef MMKV_APPLE
             MMKVInfo("deleting expired key [%@] in mmkv [%s], due date %u", key, m_mmapID.c_str(), time);
@@ -1465,35 +1756,38 @@ mmkv::MMBuffer MMKV::getDataWithoutMTimeForKey(MMKVKey_t key) {
     return MMBuffer(std::move(raw), newLength);
 }
 
-#define NOOP ((void)0)
+#define NOOP ((void) 0)
 
 size_t MMKV::filterExpiredKeys() {
     if (!m_enableKeyExpire || (m_crypter ? m_dicCrypt->empty() : m_dic->empty())) {
         return 0;
     }
+    SCOPED_LOCK(m_sharedProcessLock);
+
     auto now = getCurrentTimeInSecond();
-    MMKVInfo("filtering expired keys inside [%s] now: %u, m_expiredInSeconds: %u", m_mmapID.c_str(), now, m_expiredInSeconds);
+    MMKVInfo("filtering expired keys inside [%s] now: %u, m_expiredInSeconds: %u", m_mmapID.c_str(), now,
+             m_expiredInSeconds);
 
     size_t count = 0;
-    auto basePtr = (uint8_t *)(m_file->getMemory()) + Fixed32Size;
+    auto basePtr = (uint8_t *) (m_file->getMemory()) + Fixed32Size;
 #ifndef MMKV_DISABLE_CRYPT
     if (m_crypter) {
         for (auto itr = m_dicCrypt->begin(); itr != m_dicCrypt->end(); NOOP) {
             auto &kvHolder = itr->second;
             assert(kvHolder.realValueSize() >= Fixed32Size);
             auto buffer = kvHolder.toMMBuffer(basePtr, m_crypter);
-            auto ptr = (uint8_t*) buffer.getPtr();
+            auto ptr = (uint8_t *) buffer.getPtr();
             ptr += buffer.length() - Fixed32Size;
-            auto time = *(const uint32_t *)ptr;
+            auto time = *(const uint32_t *) ptr;
             if (time != ExpireNever && time <= now) {
                 auto oldKey = itr->first;
                 itr = m_dicCrypt->erase(itr);
-#ifdef MMKV_APPLE
+#    ifdef MMKV_APPLE
                 MMKVInfo("deleting expired key [%@], due date %u", oldKey, time);
                 [oldKey release];
-#else
+#    else
                 MMKVInfo("deleting expired key [%s], due date %u", oldKey.c_str(), time);
-#endif
+#    endif
                 count++;
             } else {
                 itr++;
@@ -1507,7 +1801,7 @@ size_t MMKV::filterExpiredKeys() {
             assert(kvHolder.valueSize >= Fixed32Size);
             auto ptr = basePtr + kvHolder.offset + kvHolder.computedKVSize;
             ptr += kvHolder.valueSize - Fixed32Size;
-            auto time = *(const uint32_t *)ptr;
+            auto time = *(const uint32_t *) ptr;
             if (time != ExpireNever && time <= now) {
                 auto oldKey = itr->first;
                 itr = m_dic->erase(itr);
@@ -1523,8 +1817,40 @@ size_t MMKV::filterExpiredKeys() {
             }
         }
     }
-    MMKVInfo("deleted %zu expired keys inside [%s]", count, m_mmapID.c_str());
+    if (count != 0) {
+        MMKVInfo("deleted %zu expired keys inside [%s]", count, m_mmapID.c_str());
+    }
     return count;
 }
 
+bool MMKV::enableCompareBeforeSet() {
+    MMKVInfo("enableCompareBeforeSet for [%s]", m_mmapID.c_str());
+    SCOPED_LOCK(m_lock);
+    SCOPED_LOCK(m_exclusiveProcessLock);
+
+    assert(!m_enableKeyExpire && "enableCompareBeforeSet is invalid when Expiration is on");
+    assert(!m_dicCrypt && "enableCompareBeforeSet is invalid when key encryption is on");
+    if (m_enableKeyExpire || m_dicCrypt) {
+        return false;
+    }
+
+    m_enableCompareBeforeSet = true;
+    return true;
+}
+
+bool MMKV::disableCompareBeforeSet() {
+    MMKVInfo("disableCompareBeforeSet for [%s]", m_mmapID.c_str());
+    SCOPED_LOCK(m_lock);
+    SCOPED_LOCK(m_exclusiveProcessLock);
+
+    assert(!m_enableKeyExpire && "disableCompareBeforeSet is invalid when Expiration is on");
+    assert(!m_dicCrypt && "disableCompareBeforeSet is invalid when key encryption is on");
+    if (m_enableKeyExpire || m_dicCrypt) {
+        return false;
+    }
+
+    m_enableCompareBeforeSet = false;
+    return true;
+}
+
 MMKV_NAMESPACE_END