diff --git a/frameworks/libs/distributeddb/common/include/auto_launch.h b/frameworks/libs/distributeddb/common/include/auto_launch.h
index a2794eb96202242ae83091bc64591e417b3e0b3c..00075878d7ee04d78c4dad1750e358b6e6ccb0d7 100644
--- a/frameworks/libs/distributeddb/common/include/auto_launch.h
+++ b/frameworks/libs/distributeddb/common/include/auto_launch.h
@@ -40,7 +40,7 @@ enum class AutoLaunchItemState {
 };
 
 enum class DBType {
-    DB_KV = 0,
+    DB_KV = 1,
     DB_RELATION,
     DB_INVALID,
 };
@@ -164,7 +164,7 @@ protected:
 
     void TryCloseRelationConnection(AutoLaunchItem &autoLaunchItem);
 
-    void EraseAutoLauchItem(const std::string &identifier, const std::string &userId);
+    void EraseAutoLaunchItem(const std::string &identifier, const std::string &userId);
 
     void NotifyInvalidParam(const AutoLaunchItem &autoLaunchItem);
 
diff --git a/frameworks/libs/distributeddb/common/include/db_constant.h b/frameworks/libs/distributeddb/common/include/db_constant.h
index 5db4590e9056caa53b1f58fc964eb113b5714e55..532cfae9d07418584a895d266c7111db5d1d293f 100644
--- a/frameworks/libs/distributeddb/common/include/db_constant.h
+++ b/frameworks/libs/distributeddb/common/include/db_constant.h
@@ -155,6 +155,8 @@ public:
     static constexpr uint32_t MAX_CONDITION_KEY_LEN = 128;
     static constexpr uint32_t MAX_CONDITION_VALUE_LEN = 128;
     static constexpr uint32_t MAX_CONDITION_COUNT = 32;
+
+    static constexpr uint32_t REMOTE_QUERY_MAX_SQL_LEN = 1000000U;
 };
 } // namespace DistributedDB
 
diff --git a/frameworks/libs/distributeddb/common/include/db_dfx_adapter.h b/frameworks/libs/distributeddb/common/include/db_dfx_adapter.h
index cc4f40cd06587eca4b6c7a86fc6acf548c28643a..b1b67e048c2f494b39a605c6326c3b9c5d88c514 100644
--- a/frameworks/libs/distributeddb/common/include/db_dfx_adapter.h
+++ b/frameworks/libs/distributeddb/common/include/db_dfx_adapter.h
@@ -33,7 +33,7 @@ struct ReportTask {
     std::string storeId;
     int errCode = 0;
 };
-class DBDfxAdapter {
+class DBDfxAdapter final {
 public:
     static void Dump(int fd, const std::vector<std::u16string> &args);
 
diff --git a/frameworks/libs/distributeddb/common/include/db_types.h b/frameworks/libs/distributeddb/common/include/db_types.h
index 656beaacae8717a1d56d17299a70c706b939ea6b..0ea4d305f46160f8e8c7b21f0adb60e81a463a7a 100644
--- a/frameworks/libs/distributeddb/common/include/db_types.h
+++ b/frameworks/libs/distributeddb/common/include/db_types.h
@@ -138,7 +138,7 @@ struct SyncTimeRange {
 };
 
 // field types stored in sqlite
-enum class StorageType {
+enum class StorageType : int32_t {
     STORAGE_TYPE_NONE = 0,
     STORAGE_TYPE_NULL,
     STORAGE_TYPE_INTEGER,
diff --git a/frameworks/libs/distributeddb/common/include/performance_analysis.h b/frameworks/libs/distributeddb/common/include/performance_analysis.h
index 51a84dfe9215d5c2761f90a6324a985634d704cc..286fe4ac35a53a7e6f718e26b437f97c140767db 100644
--- a/frameworks/libs/distributeddb/common/include/performance_analysis.h
+++ b/frameworks/libs/distributeddb/common/include/performance_analysis.h
@@ -69,9 +69,6 @@ struct SingleStatistics {
 
 class PerformanceAnalysis {
 public:
-    explicit PerformanceAnalysis(uint32_t step);
-    ~PerformanceAnalysis();
-
     static PerformanceAnalysis *GetInstance(int stepNum = 20);
 
     void Initialization();
@@ -93,6 +90,9 @@ public:
     void SetFileName(const std::string &fileName);
 
 private:
+    explicit PerformanceAnalysis(uint32_t step);
+
+    ~PerformanceAnalysis();
 
     bool IsStepValid(uint32_t step) const;
 
diff --git a/frameworks/libs/distributeddb/common/include/runtime_context.h b/frameworks/libs/distributeddb/common/include/runtime_context.h
index e504950ba36f849929cd2808a7ba746be1d455b4..85c22557ed5b0b51ffe6569b6cad0dd04bfe0f6d 100644
--- a/frameworks/libs/distributeddb/common/include/runtime_context.h
+++ b/frameworks/libs/distributeddb/common/include/runtime_context.h
@@ -137,6 +137,8 @@ public:
     virtual int SetPermissionConditionCallback(const PermissionConditionCallback &callback) = 0;
 
     virtual std::map<std::string, std::string> GetPermissionCheckParam(const DBProperties &properties) = 0;
+
+    virtual void StopTaskPool() = 0;
 protected:
     RuntimeContext() = default;
     virtual ~RuntimeContext() {}
diff --git a/frameworks/libs/distributeddb/common/include/semaphore_utils.h b/frameworks/libs/distributeddb/common/include/semaphore_utils.h
index 9cdb3f561dc4bec5784670af7ab9c798b0dc957d..c5e96e24a228745abb7ed2e83e4295f1ae6b1150 100644
--- a/frameworks/libs/distributeddb/common/include/semaphore_utils.h
+++ b/frameworks/libs/distributeddb/common/include/semaphore_utils.h
@@ -16,8 +16,6 @@
 #ifndef SEMAPHORE_UTILS_H
 #define SEMAPHORE_UTILS_H
 
-#include <cstdio>
-#include <cstdlib>
 #include <mutex>
 #include <condition_variable>
 #include "macro_utils.h"
diff --git a/frameworks/libs/distributeddb/common/src/auto_launch.cpp b/frameworks/libs/distributeddb/common/src/auto_launch.cpp
index 5e599fde4c121e94e676b251cc519acccecdb6c6..db7db1f17cd9c8b9d5a85e18adfdacbda068d709 100644
--- a/frameworks/libs/distributeddb/common/src/auto_launch.cpp
+++ b/frameworks/libs/distributeddb/common/src/auto_launch.cpp
@@ -62,13 +62,13 @@ void AutoLaunch::SetCommunicatorAggregator(ICommunicatorAggregator *aggregator)
     errCode = aggregator->RegOnConnectCallback(std::bind(&AutoLaunch::OnlineCallBack, this,
         std::placeholders::_1, std::placeholders::_2), nullptr);
     if (errCode != E_OK) {
-        LOGW("[AutoLaunch] RegOnConnectCallback errCode:%d", errCode);
+        LOGE("[AutoLaunch] RegOnConnectCallback errCode:%d", errCode);
     }
     errCode = aggregator->RegCommunicatorLackCallback(
         std::bind(&AutoLaunch::ReceiveUnknownIdentifierCallBack, this, std::placeholders::_1, std::placeholders::_2),
         nullptr);
     if (errCode != E_OK) {
-        LOGW("[AutoLaunch] RegCommunicatorLackCallback errCode:%d", errCode);
+        LOGE("[AutoLaunch] RegCommunicatorLackCallback errCode:%d", errCode);
     }
 }
 
@@ -205,7 +205,7 @@ int AutoLaunch::GetKVConnectionInEnable(AutoLaunchItem &autoLaunchItem, const st
         return E_OK;
     }
     if (autoLaunchItem.conn == nullptr) {
-        EraseAutoLauchItem(identifier, userId);
+        EraseAutoLaunchItem(identifier, userId);
         return errCode;
     }
     bool isEmpty = false;
@@ -219,7 +219,7 @@ int AutoLaunch::GetKVConnectionInEnable(AutoLaunchItem &autoLaunchItem, const st
         errCode = KvDBManager::ReleaseDatabaseConnection(kvConn);
         if (errCode != E_OK) {
             LOGE("[AutoLaunch] GetKVConnectionInEnable ReleaseDatabaseConnection failed errCode:%d", errCode);
-            EraseAutoLauchItem(identifier, userId);
+            EraseAutoLaunchItem(identifier, userId);
             return errCode;
         }
         std::lock_guard<std::mutex> autoLock(dataLock_);
@@ -235,7 +235,7 @@ int AutoLaunch::GetKVConnectionInEnable(AutoLaunchItem &autoLaunchItem, const st
     } else {
         LOGE("[AutoLaunch] GetKVConnectionInEnable RegisterObserverAndLifeCycleCallback err, do CloseConnection");
         TryCloseConnection(autoLaunchItem); // do nothing if failed
-        EraseAutoLauchItem(identifier, userId);
+        EraseAutoLaunchItem(identifier, userId);
     }
     return errCode;
 }
@@ -384,11 +384,12 @@ void AutoLaunch::ObserverFunc(const KvDBCommitNotifyData &notifyData, const std:
 int AutoLaunch::DisableKvStoreAutoLaunch(const std::string &normalIdentifier, const std::string &dualTupleIdentifier,
     const std::string &userId)
 {
-    std::string identifier = (autoLaunchItemMap_.count(normalIdentifier) == 0) ? dualTupleIdentifier : normalIdentifier;
-    LOGI("[AutoLaunch] DisableKvStoreAutoLaunch identifier=%.6s", STR_TO_HEX(identifier));
+    std::string identifier;
     AutoLaunchItem autoLaunchItem;
     {
         std::unique_lock<std::mutex> autoLock(dataLock_);
+        identifier = (autoLaunchItemMap_.count(normalIdentifier) == 0) ? dualTupleIdentifier : normalIdentifier;
+        LOGI("[AutoLaunch] DisableKvStoreAutoLaunch identifier=%.6s", STR_TO_HEX(identifier));
         if (autoLaunchItemMap_.count(identifier) == 0 || autoLaunchItemMap_[identifier].count(userId) == 0) {
             LOGE("[AutoLaunch] DisableKvStoreAutoLaunch identifier is not exist!");
             return -E_NOT_FOUND;
@@ -423,7 +424,7 @@ int AutoLaunch::DisableKvStoreAutoLaunch(const std::string &normalIdentifier, co
         return errCode;
     }
 
-    EraseAutoLauchItem(identifier, userId);
+    EraseAutoLaunchItem(identifier, userId);
     cv_.notify_all();
     if (autoLaunchItem.isWriteOpenNotified && autoLaunchItem.notifier) {
         RuntimeContext::GetInstance()->ScheduleTask([autoLaunchItem] { CloseNotifier(autoLaunchItem); });
@@ -693,17 +694,20 @@ int AutoLaunch::ReceiveUnknownIdentifierCallBack(const LabelType &label, const s
     const std::string identifier(label.begin(), label.end());
     // originalUserId size maybe 0
     std::string userId = originalUserId;
-    if (originalUserId.size() == 0 && autoLaunchItemMap_.count(identifier) != 0 &&
-        autoLaunchItemMap_[identifier].size() > 1) {
-        LOGE("[AutoLaunch] normal tuple mode userId larger than one userId");
-        goto EXT;
-    }
-    if (originalUserId.size() == 0 && autoLaunchItemMap_.count(identifier) != 0 &&
-        autoLaunchItemMap_[identifier].size() == 1) {
-        // normal tuple mode
-        userId = autoLaunchItemMap_[identifier].begin()->first;
+    {
+        std::lock_guard<std::mutex> autoLock(dataLock_);
+        if (originalUserId.size() == 0 && autoLaunchItemMap_.count(identifier) != 0 &&
+            autoLaunchItemMap_[identifier].size() > 1) {
+            LOGE("[AutoLaunch] normal tuple mode userId larger than one userId");
+            goto EXT;
+        }
+        if (originalUserId.size() == 0 && autoLaunchItemMap_.count(identifier) != 0 &&
+            autoLaunchItemMap_[identifier].size() == 1) {
+            // normal tuple mode
+            userId = autoLaunchItemMap_[identifier].begin()->first;
+        }
+        LOGI("[AutoLaunch] ReceiveUnknownIdentifierCallBack identifier=%.6s", STR_TO_HEX(identifier));
     }
-    LOGI("[AutoLaunch] ReceiveUnknownIdentifierCallBack identifier=%.6s", STR_TO_HEX(identifier));
     int errCode;
     {
         std::lock_guard<std::mutex> autoLock(dataLock_);
@@ -733,7 +737,6 @@ int AutoLaunch::ReceiveUnknownIdentifierCallBack(const LabelType &label, const s
         autoLaunchItemMap_[identifier][userId].state = AutoLaunchItemState::IDLE;
     }
     return errCode;
-
 EXT:
     return AutoLaunchExt(identifier, userId);
 }
@@ -1179,7 +1182,7 @@ void AutoLaunch::TryCloseRelationConnection(AutoLaunchItem &autoLaunchItem)
     }
 }
 
-void AutoLaunch::EraseAutoLauchItem(const std::string &identifier, const std::string &userId)
+void AutoLaunch::EraseAutoLaunchItem(const std::string &identifier, const std::string &userId)
 {
     std::lock_guard<std::mutex> autoLock(dataLock_);
     autoLaunchItemMap_[identifier].erase(userId);
diff --git a/frameworks/libs/distributeddb/common/src/data_value.cpp b/frameworks/libs/distributeddb/common/src/data_value.cpp
index d5f7ae772e7813598fc009213252cf111852aebd..99fc897dcbb66b061a7e7a2a8aa2fbf05c10fc65 100644
--- a/frameworks/libs/distributeddb/common/src/data_value.cpp
+++ b/frameworks/libs/distributeddb/common/src/data_value.cpp
@@ -84,9 +84,7 @@ int Blob::WriteBlob(const uint8_t *ptrArray, const uint32_t &size)
 
 std::vector<uint8_t> Blob::ToVector() const
 {
-    std::vector<uint8_t> vec;
-    vec.insert(vec.end(), ptr_, ptr_ + size_);
-    return vec;
+    return std::vector<uint8_t>(ptr_, ptr_ + size_);
 }
 
 DataValue::DataValue() : type_(StorageType::STORAGE_TYPE_NULL)
diff --git a/frameworks/libs/distributeddb/common/src/evloop/include/event_fd.h b/frameworks/libs/distributeddb/common/src/evloop/src/event_fd.h
similarity index 100%
rename from frameworks/libs/distributeddb/common/src/evloop/include/event_fd.h
rename to frameworks/libs/distributeddb/common/src/evloop/src/event_fd.h
diff --git a/frameworks/libs/distributeddb/common/src/evloop/src/event_impl.h b/frameworks/libs/distributeddb/common/src/evloop/src/event_impl.h
index 48964b5585161d970ec98bacbbd29ce326d2fe11..da3eb074927a102f3427c524a5d1fbf1c43a0fc6 100644
--- a/frameworks/libs/distributeddb/common/src/evloop/src/event_impl.h
+++ b/frameworks/libs/distributeddb/common/src/evloop/src/event_impl.h
@@ -18,7 +18,7 @@
 
 #include <climits>
 #include <condition_variable>
-#include "../include/ievent.h"
+#include "ievent.h"
 
 namespace DistributedDB {
 class EventLoopImpl;
diff --git a/frameworks/libs/distributeddb/common/src/evloop/src/event_loop_impl.cpp b/frameworks/libs/distributeddb/common/src/evloop/src/event_loop_impl.cpp
index bc920a86464796defbdc12b7a31d327ccca6f4a7..61d539c7d691a8726947676ca4c57d7fc1260c22 100644
--- a/frameworks/libs/distributeddb/common/src/evloop/src/event_loop_impl.cpp
+++ b/frameworks/libs/distributeddb/common/src/evloop/src/event_loop_impl.cpp
@@ -98,7 +98,8 @@ private:
 };
 
 EventLoopImpl::EventLoopImpl()
-    : pollingSetChanged_(false)
+    : pollingSetChanged_(false),
+      running_(true)
 {
     OnKill([this](){ OnKillLoop(); });
 }
@@ -169,7 +170,7 @@ int EventLoopImpl::Run()
     int errCode;
     IncObjRef(this);
 
-    while (true) {
+    while (running_) {
         errCode = ProcessRequest();
         if (errCode != E_OK) {
             break;
@@ -207,6 +208,12 @@ int EventLoopImpl::Run()
     return errCode;
 }
 
+int EventLoopImpl::Stop()
+{
+    running_ = false;
+    return E_OK;
+}
+
 int EventLoopImpl::Modify(EventImpl *event, bool isAdd, EventsMask events)
 {
     if (event == nullptr) {
diff --git a/frameworks/libs/distributeddb/common/src/evloop/src/event_loop_impl.h b/frameworks/libs/distributeddb/common/src/evloop/src/event_loop_impl.h
index 91c270ba396cabd2a73a0638536d77d317f95bba..2fc2c502677e87c3ffbe8c652c4ffe55a4820a45 100644
--- a/frameworks/libs/distributeddb/common/src/evloop/src/event_loop_impl.h
+++ b/frameworks/libs/distributeddb/common/src/evloop/src/event_loop_impl.h
@@ -20,8 +20,8 @@
 #include <set>
 #include <thread>
 #include "platform_specific.h"
-#include "../include/ievent_loop.h"
-#include "../include/ievent.h"
+#include "ievent_loop.h"
+#include "ievent.h"
 
 #if defined EVLOOP_TIMER_ONLY
 #define EVENT_LOOP_USE_SELECT
@@ -42,6 +42,7 @@ public:
     int Add(IEvent *event) override;
     int Remove(IEvent *event) override;
     int Run() override;
+    int Stop() override;
     int Modify(EventImpl *event, bool isAdd, EventsMask events);
     int Modify(EventImpl *event, EventTime time);
 
@@ -79,6 +80,7 @@ private:
     std::set<EventImpl *> polling_;
     bool pollingSetChanged_;
     std::thread::id loopThread_;
+    volatile bool running_;
 };
 }
 
diff --git a/frameworks/libs/distributeddb/common/src/evloop/src/ievent.cpp b/frameworks/libs/distributeddb/common/src/evloop/src/ievent.cpp
index 361edfe06a508b0f66c45ec6e0d9d2f06b72e2a9..de28f3261902fdde49c55d6e97a0571889c63790 100644
--- a/frameworks/libs/distributeddb/common/src/evloop/src/ievent.cpp
+++ b/frameworks/libs/distributeddb/common/src/evloop/src/ievent.cpp
@@ -13,7 +13,8 @@
  * limitations under the License.
  */
 
-#include "../include/ievent.h"
+#include "ievent.h"
+
 #include "db_errno.h"
 #include "event_impl.h"
 
diff --git a/frameworks/libs/distributeddb/common/src/evloop/include/ievent.h b/frameworks/libs/distributeddb/common/src/evloop/src/ievent.h
similarity index 100%
rename from frameworks/libs/distributeddb/common/src/evloop/include/ievent.h
rename to frameworks/libs/distributeddb/common/src/evloop/src/ievent.h
diff --git a/frameworks/libs/distributeddb/common/src/evloop/include/ievent_loop.h b/frameworks/libs/distributeddb/common/src/evloop/src/ievent_loop.h
similarity index 97%
rename from frameworks/libs/distributeddb/common/src/evloop/include/ievent_loop.h
rename to frameworks/libs/distributeddb/common/src/evloop/src/ievent_loop.h
index b7451b8c4129afd4676709c8cbd89416a881d2f4..cfb3805317635c5630cf825592d753a389e1c9d8 100644
--- a/frameworks/libs/distributeddb/common/src/evloop/include/ievent_loop.h
+++ b/frameworks/libs/distributeddb/common/src/evloop/src/ievent_loop.h
@@ -38,6 +38,8 @@ public:
     // Run the loop.
     virtual int Run() = 0;
 
+    virtual int Stop() = 0;
+
     // Create a loop object.
     static IEventLoop *CreateEventLoop(int &errCode);
 
diff --git a/frameworks/libs/distributeddb/common/src/flatbuffer_schema.cpp b/frameworks/libs/distributeddb/common/src/flatbuffer_schema.cpp
index 8e50136ced0828149a7f6acb46c9d649556404ff..4c19a06ab51ec8895d84b1f19fd151236891223c 100644
--- a/frameworks/libs/distributeddb/common/src/flatbuffer_schema.cpp
+++ b/frameworks/libs/distributeddb/common/src/flatbuffer_schema.cpp
@@ -241,9 +241,14 @@ int SchemaObject::FlatBufferSchema::VerifyFlatBufferValue(const RawValue &inValu
 }
 
 namespace {
+struct BaseTypeNode {
+    reflection::BaseType type;
+    FieldType fieldType;
+};
+
 FieldType MapFieldType(reflection::BaseType inType)
 {
-    static std::map<reflection::BaseType, FieldType> fieldTypeMap{
+    static const BaseTypeNode baseTypeNodes[] = {
         {reflection::BaseType::Bool, FieldType::LEAF_FIELD_BOOL},
         {reflection::BaseType::Byte, FieldType::LEAF_FIELD_INTEGER},
         {reflection::BaseType::UByte, FieldType::LEAF_FIELD_INTEGER},
@@ -257,12 +262,14 @@ FieldType MapFieldType(reflection::BaseType inType)
         {reflection::BaseType::Double, FieldType::LEAF_FIELD_DOUBLE},
         {reflection::BaseType::String, FieldType::LEAF_FIELD_STRING},
         {reflection::BaseType::Vector, FieldType::LEAF_FIELD_ARRAY},
-        {reflection::BaseType::Obj, FieldType::INTERNAL_FIELD_OBJECT},
+        {reflection::BaseType::Obj, FieldType::INTERNAL_FIELD_OBJECT}
     };
-    if (fieldTypeMap.count(inType) == 0) {
-        return FieldType::LEAF_FIELD_NULL;
+    for (const auto &node : baseTypeNodes) {
+        if (node.type == inType) {
+            return node.fieldType;
+        }
     }
-    return fieldTypeMap[inType];
+    return FieldType::LEAF_FIELD_NULL;
 }
 
 RawString CheckDollarDotAndSkipIt(RawString inPath)
diff --git a/frameworks/libs/distributeddb/common/src/notification_chain.cpp b/frameworks/libs/distributeddb/common/src/notification_chain.cpp
index 237fcf9d38a952a276f5e06e741d1d6bb1d66ef7..02a83c3f6a6db27127f71475d42aaffdceff0f5a 100644
--- a/frameworks/libs/distributeddb/common/src/notification_chain.cpp
+++ b/frameworks/libs/distributeddb/common/src/notification_chain.cpp
@@ -186,7 +186,7 @@ int NotificationChain::ListenerChain::UnRegisterListener(Listener *listener, boo
 void NotificationChain::ListenerChain::BackupListenerSet(std::set<Listener *> &backupSet) const
 {
     for (auto listener : listenerSet_) {
-        listener->IncObjRef(listener);
+        RefObject::IncObjRef(listener);
         backupSet.insert(listener);
     }
 }
diff --git a/frameworks/libs/distributeddb/common/src/parcel.cpp b/frameworks/libs/distributeddb/common/src/parcel.cpp
index 815597416fac4d7b0f33071646184778e6420739..0041d37cf625260a5b3689286bf454a0fa0e3622 100644
--- a/frameworks/libs/distributeddb/common/src/parcel.cpp
+++ b/frameworks/libs/distributeddb/common/src/parcel.cpp
@@ -524,6 +524,15 @@ uint32_t Parcel::GetMultiVerCommitsLen(const std::vector<MultiVerCommitNode> &co
 
 void Parcel::EightByteAlign()
 {
+    if (IsError()) {
+        LOGE("EightByteAlign already error");
+        return;
+    }
+    if (BYTE_8_ALIGN(parcelLen_) > totalLen_) {
+        LOGE("byte 8 align failed");
+        isError_ = true;
+        return;
+    }
     bufPtr_ += BYTE_8_ALIGN(parcelLen_) - parcelLen_;
     parcelLen_ = BYTE_8_ALIGN(parcelLen_);
 }
diff --git a/frameworks/libs/distributeddb/common/src/platform_specific.cpp b/frameworks/libs/distributeddb/common/src/platform_specific.cpp
index 8e087dfa084fc00c691e304f9632096838b60d1d..839d643b5588d013a835de7c3b2352f03394c909 100644
--- a/frameworks/libs/distributeddb/common/src/platform_specific.cpp
+++ b/frameworks/libs/distributeddb/common/src/platform_specific.cpp
@@ -456,6 +456,7 @@ int GetRealPath(const std::string &inOriPath, std::string &outRealPath)
     return E_OK;
 }
 
+#ifndef RUNNING_ON_SIMULATED_ENV
 int GetCurrentSysTimeInMicrosecond(uint64_t &outTime)
 {
     struct timeval rawTime;
@@ -468,6 +469,7 @@ int GetCurrentSysTimeInMicrosecond(uint64_t &outTime)
               static_cast<uint64_t>(rawTime.tv_usec);
     return E_OK;
 }
+#endif // RUNNING_ON_SIMULATED_ENV
 
 namespace {
     const uint64_t MULTIPLES_BETWEEN_MICROSECONDS_AND_NANOSECONDS = 1000;
diff --git a/frameworks/libs/distributeddb/common/src/relational/prepared_stmt.cpp b/frameworks/libs/distributeddb/common/src/relational/prepared_stmt.cpp
index 03db2eb0f285673b6c975cbe3aa55f93404a3767..285596f4f09c085275feaf38b71b5ce9fa789232 100644
--- a/frameworks/libs/distributeddb/common/src/relational/prepared_stmt.cpp
+++ b/frameworks/libs/distributeddb/common/src/relational/prepared_stmt.cpp
@@ -89,7 +89,7 @@ int PreparedStmt::Serialize(Parcel &parcel) const
         }
     }
 
-    (void)parcel.EightByteAlign();
+    parcel.EightByteAlign();
     if (parcel.IsError()) {
         return -E_PARSE_FAIL;
     }
@@ -137,7 +137,10 @@ int PreparedStmt::DeSerialize(Parcel &parcel)
         }
     }
 
-    (void)parcel.EightByteAlign();
+    parcel.EightByteAlign();
+    if (parcel.IsError()) {
+        return -E_PARSE_FAIL;
+    }
     return E_OK;
 }
 }
diff --git a/frameworks/libs/distributeddb/common/src/relational/relational_row_data_set.cpp b/frameworks/libs/distributeddb/common/src/relational/relational_row_data_set.cpp
index e602066006e94fc46ab81d3456c4bf6e042e9b2d..46a2bac72f2a2187d32028e4ade0fab424e0b85f 100644
--- a/frameworks/libs/distributeddb/common/src/relational/relational_row_data_set.cpp
+++ b/frameworks/libs/distributeddb/common/src/relational/relational_row_data_set.cpp
@@ -79,7 +79,7 @@ int RelationalRowDataSet::Serialize(Parcel &parcel) const
         rowData->Serialize(parcel);
     };
 
-    (void)parcel.EightByteAlign();
+    parcel.EightByteAlign();
     if (parcel.IsError()) {
         return -E_PARSE_FAIL;
     }
@@ -118,7 +118,10 @@ int RelationalRowDataSet::DeSerialize(Parcel &parcel)
         }
         data_.push_back(rowData);
     }
-    (void)parcel.EightByteAlign();
+    parcel.EightByteAlign();
+    if (parcel.IsError()) {
+        return -E_PARSE_FAIL;
+    }
     return E_OK;
 };
 
diff --git a/frameworks/libs/distributeddb/common/src/relational/table_info.cpp b/frameworks/libs/distributeddb/common/src/relational/table_info.cpp
index ca82ea7a6104c42c27bb04988e1055c553e41357..0ad6fd4a54510f96b8feb2f5a1f8b575ff96d47b 100644
--- a/frameworks/libs/distributeddb/common/src/relational/table_info.cpp
+++ b/frameworks/libs/distributeddb/common/src/relational/table_info.cpp
@@ -418,7 +418,6 @@ int TableInfo::CompareWithTableFields(const std::map<std::string, FieldInfo> &in
     auto itInTable = inTableFields.begin();
     int errCode = -E_RELATIONAL_TABLE_EQUAL;
     while (itLocal != fields_.end() && itInTable != inTableFields.end()) {
-        LOGD("--> field name %s", itLocal->first.c_str());
         if (itLocal->first == itInTable->first) { // Same field
             if (!itLocal->second.CompareWithField(itInTable->second, isLite)) { // Compare field
                 LOGW("[Relational][Compare] Table field is incompatible"); // not compatible
@@ -560,8 +559,6 @@ int TableInfo::CompareWithLiteTableFields(const std::map<std::string, FieldInfo>
 
 int TableInfo::CompareWithLiteSchemaTable(const TableInfo &liteTableInfo) const
 {
-    LOGE("--> check table primary key, %d %d %d", primaryKey_.empty(), liteTableInfo.GetPrimaryKey().empty(), autoInc_);
-
     if (!liteTableInfo.GetPrimaryKey().empty() && (primaryKey_.at(0) != "rowid") &&
         liteTableInfo.GetPrimaryKey() != primaryKey_) {
         LOGE("[Relational][Compare] Table primary key is not same");
diff --git a/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp b/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
index 0fba976541a6131bf950fa75df458c615ef5cf8d..8398c979b1f0b460c6b4364776d2c7b71687cc43 100644
--- a/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
+++ b/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
@@ -48,6 +48,7 @@ RuntimeContextImpl::~RuntimeContextImpl()
         taskPool_ = nullptr;
     }
     if (mainLoop_ != nullptr) {
+        mainLoop_->Stop();
         mainLoop_->KillAndDecObjRef(mainLoop_);
         mainLoop_ = nullptr;
     }
@@ -392,9 +393,8 @@ int RuntimeContextImpl::RunPermissionCheck(const PermissionCheckParam &param, ui
     }
     if (checkResult) {
         return E_OK;
-    } else {
-        return -E_NOT_PERMIT;
     }
+    return -E_NOT_PERMIT;
 }
 
 int RuntimeContextImpl::EnableKvStoreAutoLaunch(const KvDBProperties &properties, AutoLaunchNotifier notifier,
@@ -542,6 +542,7 @@ bool RuntimeContextImpl::CheckDeviceSecurityAbility(const std::string &devId, co
     {
         std::lock_guard<std::recursive_mutex> autoLock(systemApiAdapterLock_);
         if (systemApiAdapter_ == nullptr) {
+            LOGI("[CheckDeviceSecurityAbility] security not set");
             return true;
         }
         tempSystemApiAdapter = systemApiAdapter_;
@@ -722,4 +723,14 @@ std::map<std::string, std::string> RuntimeContextImpl::GetPermissionCheckParam(c
     }
     return permissionConditionCallback_(param);
 }
+
+void RuntimeContextImpl::StopTaskPool()
+{
+    std::lock_guard<std::mutex> autoLock(taskLock_);
+    if (taskPool_ != nullptr) {
+        taskPool_->Stop();
+        TaskPool::Release(taskPool_);
+        taskPool_ = nullptr;
+    }
+}
 } // namespace DistributedDB
diff --git a/frameworks/libs/distributeddb/common/src/runtime_context_impl.h b/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
index 7ee478543f1d4e8a663e0cbe52a847c100552710..e79d23eee3db91ab9ccfcff3a0139bb23817a405 100644
--- a/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
+++ b/frameworks/libs/distributeddb/common/src/runtime_context_impl.h
@@ -21,8 +21,8 @@
 #include <shared_mutex>
 
 #include "auto_launch.h"
-#include "evloop/include/ievent.h"
-#include "evloop/include/ievent_loop.h"
+#include "evloop/src/ievent.h"
+#include "evloop/src/ievent_loop.h"
 #include "icommunicator_aggregator.h"
 #include "lock_status_observer.h"
 #include "task_pool.h"
@@ -125,6 +125,8 @@ public:
     int SetPermissionConditionCallback(const PermissionConditionCallback &callback) override;
 
     std::map<std::string, std::string> GetPermissionCheckParam(const DBProperties &properties) override;
+
+    void StopTaskPool() override;
 private:
     static constexpr int MAX_TP_THREADS = 10;  // max threads of the task pool.
     static constexpr int MIN_TP_THREADS = 1;   // min threads of the task pool.
diff --git a/frameworks/libs/distributeddb/common/src/schema_negotiate.cpp b/frameworks/libs/distributeddb/common/src/schema_negotiate.cpp
index e1669b7f7487619e5a464d8aeb4cbe2430ed7fbe..82325e7c574f930fbd91d6a625b146266a2ae7a5 100644
--- a/frameworks/libs/distributeddb/common/src/schema_negotiate.cpp
+++ b/frameworks/libs/distributeddb/common/src/schema_negotiate.cpp
@@ -213,12 +213,12 @@ int SchemaNegotiate::SerializeData(const RelationalSyncOpinion &opinions, Parcel
     (void)parcel.WriteString(MAGIC);
     (void)parcel.WriteUInt32(SYNC_OPINION_VERSION);
     (void)parcel.WriteUInt32(static_cast<uint32_t>(opinions.size()));
-    (void)parcel.EightByteAlign();
+    parcel.EightByteAlign();
     for (const auto &it : opinions) {
         (void)parcel.WriteString(it.first);
         (void)parcel.WriteUInt32(it.second.permitSync);
         (void)parcel.WriteUInt32(it.second.requirePeerConvert);
-        (void)parcel.EightByteAlign();
+        parcel.EightByteAlign();
     }
     return parcel.IsError() ? -E_INVALID_ARGS : E_OK;
 }
@@ -242,7 +242,7 @@ int SchemaNegotiate::DeserializeData(Parcel &parcel, RelationalSyncOpinion &opin
     }
     uint32_t opinionSize;
     (void)parcel.ReadUInt32(opinionSize);
-    (void)parcel.EightByteAlign();
+    parcel.EightByteAlign();
     static const uint32_t MAX_OPINION_SIZE = 1024; // max 1024 opinions
     if (parcel.IsError() || opinionSize > MAX_OPINION_SIZE) {
         return -E_INVALID_ARGS;
@@ -257,7 +257,7 @@ int SchemaNegotiate::DeserializeData(Parcel &parcel, RelationalSyncOpinion &opin
         uint32_t requirePeerConvert;
         (void)parcel.ReadUInt32(requirePeerConvert);
         tableOpinion.requirePeerConvert = static_cast<bool>(requirePeerConvert);
-        (void)parcel.EightByteAlign();
+        parcel.EightByteAlign();
         opinion[tableName] =  tableOpinion;
     }
     return parcel.IsError() ? -E_INVALID_ARGS : E_OK;
diff --git a/frameworks/libs/distributeddb/communicator/include/communicator_aggregator.h b/frameworks/libs/distributeddb/communicator/include/communicator_aggregator.h
index 30ca55f93cf29aecb48df41b115b33eca8e391ac..c3a31cdc1271b90bd2d3680f78464a12bb4bee26 100644
--- a/frameworks/libs/distributeddb/communicator/include/communicator_aggregator.h
+++ b/frameworks/libs/distributeddb/communicator/include/communicator_aggregator.h
@@ -16,20 +16,20 @@
 #ifndef COMMUNICATORAGGREGATOR_H
 #define COMMUNICATORAGGREGATOR_H
 
+#include <atomic>
+#include <condition_variable>
+#include <cstdint>
 #include <map>
 #include <mutex>
 #include <string>
-#include <atomic>
 #include <thread>
-#include <cstdint>
-#include <condition_variable>
-#include "iadapter.h"
-#include "parse_result.h"
-#include "icommunicator.h"
 #include "frame_combiner.h"
 #include "frame_retainer.h"
-#include "send_task_scheduler.h"
+#include "iadapter.h"
+#include "icommunicator.h"
 #include "icommunicator_aggregator.h"
+#include "parse_result.h"
+#include "send_task_scheduler.h"
 
 namespace DistributedDB {
 // Forward Declarations
@@ -83,8 +83,8 @@ public:
     // Called by communicator to make itself really in work
     void ActivateCommunicator(const LabelType &commLabel);
 
-    // SerialBuffer surely is heap memory, CreateSendTask responsible for lifecycle
-    int CreateSendTask(const std::string &dstTarget, SerialBuffer *inBuff, FrameType inType,
+    // SerialBuffer surely is heap memory, ScheduleSendTask responsible for lifecycle
+    int ScheduleSendTask(const std::string &dstTarget, SerialBuffer *inBuff, FrameType inType,
         const TaskConfig &inConfig, const OnSendEnd &onEnd = nullptr);
 
     static void EnableCommunicatorNotFoundFeedback(bool isEnable);
diff --git a/frameworks/libs/distributeddb/communicator/include/frame_combiner.h b/frameworks/libs/distributeddb/communicator/include/frame_combiner.h
index 33124c497c406cbd976f569d8614838d7af6e688..d1ec81f82671369e3cfbdaee5aea45d27b8db7e6 100644
--- a/frameworks/libs/distributeddb/communicator/include/frame_combiner.h
+++ b/frameworks/libs/distributeddb/communicator/include/frame_combiner.h
@@ -16,20 +16,20 @@
 #ifndef FRAME_COMBINER_H
 #define FRAME_COMBINER_H
 
+#include <cstdint>
 #include <map>
 #include <mutex>
-#include <cstdint>
-#include "semaphore_utils.h"
+#include "combine_status.h"
 #include "macro_utils.h"
 #include "parse_result.h"
-#include "combine_status.h"
 #include "runtime_context.h"
+#include "semaphore_utils.h"
 
 namespace DistributedDB {
 class SerialBuffer; // Forward Declarations
 
 struct CombineWork {
-    SerialBuffer *buffer;
+    SerialBuffer *buffer = nullptr;
     CombineStatus status;
     ParseResult frameInfo;
 };
diff --git a/frameworks/libs/distributeddb/communicator/include/frame_retainer.h b/frameworks/libs/distributeddb/communicator/include/frame_retainer.h
index 259007369b33411447f08540796833d1b75c028e..a0b144087082fcda0f754da9890f2dbc5fdaee5d 100644
--- a/frameworks/libs/distributeddb/communicator/include/frame_retainer.h
+++ b/frameworks/libs/distributeddb/communicator/include/frame_retainer.h
@@ -27,16 +27,16 @@ namespace DistributedDB {
 class SerialBuffer; // Forward Declarations
 
 struct FrameInfo {
-    SerialBuffer *buffer;
+    SerialBuffer *buffer = nullptr;
     std::string srcTarget;
     LabelType commLabel;
-    uint32_t frameId;
+    uint32_t frameId = 0u;
 };
 
 struct RetainWork {
-    SerialBuffer *buffer;
-    uint32_t frameId;
-    uint32_t remainTime; // in second
+    SerialBuffer *buffer = nullptr;
+    uint32_t frameId = 0u;
+    uint32_t remainTime = 0u; // in second
 };
 
 class FrameRetainer {
diff --git a/frameworks/libs/distributeddb/communicator/include/iadapter.h b/frameworks/libs/distributeddb/communicator/include/iadapter.h
index f238114ca4b16f8c80e900dfa7e09465bfe47c02..d68916fa6cbbb99dbef38d2d1f6b250e993adc3e 100644
--- a/frameworks/libs/distributeddb/communicator/include/iadapter.h
+++ b/frameworks/libs/distributeddb/communicator/include/iadapter.h
@@ -16,10 +16,10 @@
 #ifndef IADAPTER_H
 #define IADAPTER_H
 
-#include <string>
 #include <cstdint>
 #include <functional>
 #include <memory>
+#include <string>
 #include "communicator_type_define.h"
 #include "iprocess_communicator.h"
 
diff --git a/frameworks/libs/distributeddb/communicator/include/icommunicator_aggregator.h b/frameworks/libs/distributeddb/communicator/include/icommunicator_aggregator.h
index ee5c59dfda2febf2acba05f9bc6a86cf63eaf89b..06ae9e7c1e91e74188cf57540be44690eb309fe8 100644
--- a/frameworks/libs/distributeddb/communicator/include/icommunicator_aggregator.h
+++ b/frameworks/libs/distributeddb/communicator/include/icommunicator_aggregator.h
@@ -17,9 +17,9 @@
 #define ICOMMUNICATORAGGREGATOR_H
 
 #include <cstdint>
+#include "communicator_type_define.h"
 #include "iadapter.h"
 #include "ref_object.h"
-#include "communicator_type_define.h"
 
 namespace DistributedDB {
 class ICommunicator; // Forward Declaration
diff --git a/frameworks/libs/distributeddb/communicator/include/parse_result.h b/frameworks/libs/distributeddb/communicator/include/parse_result.h
index 0e1278821a1492a77cf03e5780ac876fcb4a60ec..99d0cebd6137e708a567e4d7fc116d7f5a4c7729 100644
--- a/frameworks/libs/distributeddb/communicator/include/parse_result.h
+++ b/frameworks/libs/distributeddb/communicator/include/parse_result.h
@@ -16,8 +16,8 @@
 #ifndef PARSE_RESULT_H
 #define PARSE_RESULT_H
 
-#include <set>
 #include <cstdint>
+#include <set>
 #include "communicator_type_define.h"
 
 namespace DistributedDB {
diff --git a/frameworks/libs/distributeddb/communicator/include/send_task_scheduler.h b/frameworks/libs/distributeddb/communicator/include/send_task_scheduler.h
index 8c1e3e12ec32d62d6dd55ad06ba06e00473b05fa..0725474062a4a2efc4239b2ef34b10ce39aa90d1 100644
--- a/frameworks/libs/distributeddb/communicator/include/send_task_scheduler.h
+++ b/frameworks/libs/distributeddb/communicator/include/send_task_scheduler.h
@@ -16,14 +16,14 @@
 #ifndef SEND_TASK_SCHEDULER_H
 #define SEND_TASK_SCHEDULER_H
 
-#include <map>
+#include <cstdint>
 #include <list>
+#include <map>
 #include <mutex>
-#include <vector>
 #include <string>
-#include <cstdint>
-#include "macro_utils.h"
+#include <vector>
 #include "communicator_type_define.h"
+#include "macro_utils.h"
 
 namespace DistributedDB {
 enum class TargetPolicy {
@@ -34,14 +34,14 @@ enum class TargetPolicy {
 class SerialBuffer; // Forward Declaration
 
 struct SendTask {
-    SerialBuffer *buffer;
+    SerialBuffer *buffer = nullptr;
     std::string dstTarget;
     OnSendEnd onEnd;
 };
 
 struct SendTaskInfo {
-    bool delayFlag;
-    Priority taskPrio;
+    bool delayFlag = false;
+    Priority taskPrio = Priority::LOW;
 };
 
 using TaskListByTarget = std::map<std::string, std::list<SendTask>>;
diff --git a/frameworks/libs/distributeddb/communicator/src/communicator.cpp b/frameworks/libs/distributeddb/communicator/src/communicator.cpp
index e5c97f4126738d07594a7101a7fe5464d81b48c3..04b818e8185f8eb0e625d4d64315ad4f8fd87a52 100644
--- a/frameworks/libs/distributeddb/communicator/src/communicator.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/communicator.cpp
@@ -116,7 +116,7 @@ int Communicator::SendMessage(const std::string &dstTarget, const Message *inMsg
     }
     int error = E_OK;
     // if error is not E_OK , null pointer will be returned
-    SerialBuffer *buffer = ProtocolProto::ToSerialBuffer(inMsg, error, extendHandle, false);
+    SerialBuffer *buffer = ProtocolProto::ToSerialBuffer(inMsg, extendHandle, false, error);
     extendHandle = nullptr;
     if (error != E_OK) {
         LOGE("[Comm][Send] Serial fail, label=%s, error=%d.", VEC_TO_STR(commLabel_), error);
@@ -131,7 +131,7 @@ int Communicator::SendMessage(const std::string &dstTarget, const Message *inMsg
     }
 
     TaskConfig taskConfig {config.nonBlock, config.timeout, inMsg->GetPriority()};
-    errCode = commAggrHandle_->CreateSendTask(dstTarget, buffer, FrameType::APPLICATION_MESSAGE, taskConfig, onEnd);
+    errCode = commAggrHandle_->ScheduleSendTask(dstTarget, buffer, FrameType::APPLICATION_MESSAGE, taskConfig, onEnd);
     if (errCode == E_OK) {
         // if ok, free inMsg, otherwise the caller should take over inMsg
         delete inMsg;
@@ -226,7 +226,7 @@ void Communicator::TriggerVersionNegotiation(const std::string &dstTarget)
     }
 
     TaskConfig config{true, 0, Priority::HIGH};
-    errCode = commAggrHandle_->CreateSendTask(dstTarget, buffer, FrameType::EMPTY, config);
+    errCode = commAggrHandle_->ScheduleSendTask(dstTarget, buffer, FrameType::EMPTY, config);
     if (errCode != E_OK) {
         LOGE("[Comm][TrigVer] Send empty frame fail, errCode=%d", errCode);
         // if send fails, free buffer, otherwise buffer will be taked over by comminucator aggregator
@@ -259,7 +259,7 @@ void Communicator::TriggerUnknownMessageFeedback(const std::string &dstTarget, M
     }
 
     TaskConfig config{true, 0, Priority::HIGH};
-    errCode = commAggrHandle_->CreateSendTask(dstTarget, buffer, FrameType::APPLICATION_MESSAGE, config);
+    errCode = commAggrHandle_->ScheduleSendTask(dstTarget, buffer, FrameType::APPLICATION_MESSAGE, config);
     if (errCode != E_OK) {
         LOGE("[Comm][TrigFeedback] Send unknown message feedback frame fail, errCode=%d", errCode);
         // if send fails, free buffer, otherwise buffer will be taked over by comminucator aggregator
diff --git a/frameworks/libs/distributeddb/communicator/src/communicator.h b/frameworks/libs/distributeddb/communicator/src/communicator.h
index c1f2ce39d4a8139905cfa57a6acf19e31b0e90be..fd9436ddfa66735c52262ada5bfd6d6382608d0f 100644
--- a/frameworks/libs/distributeddb/communicator/src/communicator.h
+++ b/frameworks/libs/distributeddb/communicator/src/communicator.h
@@ -16,16 +16,16 @@
 #ifndef COMMUNICATOR_H
 #define COMMUNICATOR_H
 
-#include <set>
-#include <mutex>
 #include <chrono>
-#include <string>
+#include <condition_variable>
 #include <cstdint>
 #include <functional>
-#include <condition_variable>
-#include "serial_buffer.h"
-#include "icommunicator.h"
+#include <mutex>
+#include <set>
+#include <string>
 #include "communicator_aggregator.h"
+#include "icommunicator.h"
+#include "serial_buffer.h"
 
 namespace DistributedDB {
 class Communicator : public ICommunicator {
diff --git a/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp b/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
index 7c9151c9fc2d80e9abca2fd8d3b492f1ae4f2fe3..3cb9f9aab447e1014d37bdebba8e481af0ac4e28 100644
--- a/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
@@ -16,12 +16,11 @@
 #include "communicator_aggregator.h"
 
 #include <sstream>
-
-#include "hash.h"
 #include "communicator.h"
 #include "communicator_linker.h"
 #include "db_common.h"
 #include "endian_convert.h"
+#include "hash.h"
 #include "log_print.h"
 #include "protocol_proto.h"
 
@@ -280,7 +279,7 @@ void DoOnSendEndByTaskIfNeed(const OnSendEnd &onEnd, int result)
 }
 }
 
-int CommunicatorAggregator::CreateSendTask(const std::string &dstTarget, SerialBuffer *inBuff,
+int CommunicatorAggregator::ScheduleSendTask(const std::string &dstTarget, SerialBuffer *inBuff,
     FrameType inType, const TaskConfig &inConfig, const OnSendEnd &onEnd)
 {
     if (inBuff == nullptr) {
@@ -318,7 +317,7 @@ int CommunicatorAggregator::CreateSendTask(const std::string &dstTarget, SerialB
     std::lock_guard<std::mutex> wakingLockGuard(wakingMutex_);
     wakingSignal_ = true;
     wakingCv_.notify_one();
-    LOGI("[CommAggr][Create] Exit ok, thread=%s, frameId=%u", GetThreadId().c_str(), info.frameId); // Delete In Future
+    LOGI("[CommAggr][Create] Exit ok, thread=%s, frameId=%u", GetThreadId().c_str(), info.frameId);
     return E_OK;
 }
 
@@ -343,9 +342,9 @@ void CommunicatorAggregator::SendDataRoutine()
     while (!shutdown_) {
         if (scheduler_.GetNoDelayTaskCount() == 0) {
             std::unique_lock<std::mutex> wakingUniqueLock(wakingMutex_);
-            LOGI("[CommAggr][Routine] Send done and sleep."); // Delete In Future
+            LOGI("[CommAggr][Routine] Send done and sleep.");
             wakingCv_.wait(wakingUniqueLock, [this] { return this->wakingSignal_; });
-            LOGI("[CommAggr][Routine] Send continue."); // Delete In Future
+            LOGI("[CommAggr][Routine] Send continue.");
             wakingSignal_ = false;
             continue;
         }
@@ -366,7 +365,7 @@ void CommunicatorAggregator::SendDataRoutine()
         }
         // <addr, <extendHeadSize, totalLen>>
         std::vector<std::pair<const uint8_t *, std::pair<uint32_t, uint32_t>>> eachPacket;
-        if (piecePackets.size() == 0) {
+        if (piecePackets.empty()) {
             // Case that no need to split a frame, just use original buffer as a packet
             std::pair<const uint8_t *, uint32_t> tmpEntry = taskToSend.buffer->GetReadOnlyBytesForEntireBuffer();
             std::pair<const uint8_t *, std::pair<uint32_t, uint32_t>> entry;
@@ -392,8 +391,8 @@ void CommunicatorAggregator::SendPacketsAndDisposeTask(const SendTask &inTask,
     bool taskNeedFinalize = true;
     int errCode = E_OK;
     for (auto &entry : eachPacket) {
-        LOGI("[CommAggr][SendPackets] DoSendBytes, dstTarget=%s{private}, extendHeadLength=%u, totalLength=%u.",
-            inTask.dstTarget.c_str(), entry.second.first, entry.second.second);
+        LOGI("[CommAggr][SendPackets] DoSendBytes, dstTarget=%s{private}, extendHeadLength=%" PRIu32
+            ", totalLength=%" PRIu32 ".", inTask.dstTarget.c_str(), entry.second.first, entry.second.second);
         ProtocolProto::DisplayPacketInformation(entry.first + entry.second.first, entry.second.second);
         errCode = adapterHandle_->SendBytes(inTask.dstTarget, entry.first, entry.second.second);
         if (errCode == -E_WAIT_RETRY) {
@@ -479,7 +478,7 @@ void CommunicatorAggregator::NotifySendableToAllCommunicator()
 void CommunicatorAggregator::OnBytesReceive(const std::string &srcTarget, const uint8_t *bytes, uint32_t length,
     const std::string &userId)
 {
-    ProtocolProto::DisplayPacketInformation(bytes, length); // For debug, delete in the future
+    ProtocolProto::DisplayPacketInformation(bytes, length);
     ParseResult packetResult;
     int errCode = ProtocolProto::CheckAndParsePacket(srcTarget, bytes, length, packetResult);
     if (errCode != E_OK) {
@@ -536,10 +535,7 @@ void CommunicatorAggregator::OnTargetChange(const std::string &target, bool isCo
             LOGE("[CommAggr][OnTarget] TargetOnline fail, target=%s{private}, errCode=%d.", target.c_str(), errCode);
         }
     } else {
-        int errCode = commLinker_->TargetOffline(target, relatedLabels);
-        if (errCode != E_OK) {
-            LOGE("[CommAggr][OnTarget] TargetOffline fail, target=%s{private}, errCode=%d.", target.c_str(), errCode);
-        }
+        commLinker_->TargetOffline(target, relatedLabels);
     }
     // All related communicator online or offline this target, no matter TargetOnline or TargetOffline fail or not
     std::lock_guard<std::mutex> commMapLockGuard(commMapMutex_);
@@ -782,7 +778,7 @@ void CommunicatorAggregator::GenerateLocalSourceId()
     // The localSourceId is std::atomic<uint64_t>, so there is no concurrency risk
     uint64_t identityHash = Hash::HashFunc(identity);
     if (identityHash != localSourceId_) {
-        LOGI("[CommAggr][GenSrcId] identity=%s{private}, localSourceId=%llu.", identity.c_str(), ULL(identityHash));
+        LOGI("[CommAggr][GenSrcId] identity=%s{private}, localSourceId=%" PRIu64, identity.c_str(), ULL(identityHash));
     }
     localSourceId_ = identityHash;
 }
@@ -808,7 +804,7 @@ void CommunicatorAggregator::TriggerVersionNegotiation(const std::string &dstTar
     }
 
     TaskConfig config{true, 0, Priority::HIGH};
-    errCode = CreateSendTask(dstTarget, buffer, FrameType::EMPTY, config);
+    errCode = ScheduleSendTask(dstTarget, buffer, FrameType::EMPTY, config);
     if (errCode != E_OK) {
         LOGE("[CommAggr][TrigVer] Send empty frame fail, errCode=%d", errCode);
         // if send fails, free buffer, otherwise buffer will be taked over by SendTaskScheduler
@@ -860,10 +856,10 @@ void CommunicatorAggregator::TriggerCommunicatorNotFoundFeedback(const std::stri
     }
 
     TaskConfig config{true, 0, Priority::HIGH};
-    errCode = CreateSendTask(dstTarget, buffer, FrameType::APPLICATION_MESSAGE, config);
+    errCode = ScheduleSendTask(dstTarget, buffer, FrameType::APPLICATION_MESSAGE, config);
     if (errCode != E_OK) {
         LOGE("[CommAggr][TrigNotFound] Send communicator not found feedback frame fail, errCode=%d", errCode);
-        // if send fails, free buffer, otherwise buffer will be taked over by CreateSendTask
+        // if send fails, free buffer, otherwise buffer will be taked over by ScheduleSendTask
         delete buffer;
         buffer = nullptr;
     }
diff --git a/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp b/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
index 59a1b77950d4870a0954c7e5c6840e103a509856..ab51b370d34c2d2a7361f70f99c9418ff2392bd8 100644
--- a/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
@@ -14,12 +14,12 @@
  */
 
 #include "communicator_linker.h"
-#include "hash.h"
+#include "communicator_aggregator.h"
 #include "db_errno.h"
+#include "hash.h"
 #include "log_print.h"
-#include "protocol_proto.h"
 #include "platform_specific.h"
-#include "communicator_aggregator.h"
+#include "protocol_proto.h"
 
 namespace DistributedDB {
 namespace {
@@ -51,7 +51,7 @@ void CommunicatorLinker::Initialize()
     }
     std::string curTimeStr = std::to_string(curTime);
     localDistinctValue_ = Hash::HashFunc(curTimeStr);
-    LOGI("[Linker][Init] curTime=%llu, distinct=%llu.", ULL(curTime), ULL(localDistinctValue_));
+    LOGI("[Linker][Init] curTime=%" PRIu64 ", distinct=%" PRIu64 ".", ULL(curTime), ULL(localDistinctValue_));
 }
 
 // Create async task to send out label_exchange and waiting for label_exchange_ack.
@@ -73,7 +73,7 @@ int CommunicatorLinker::TargetOnline(const std::string &inTarget, std::set<Label
 
 // Clear all labels related to this target. Let no longer waiting for ack of this target.
 // The caller should notify all related communicator about this target offline.
-int CommunicatorLinker::TargetOffline(const std::string &inTarget, std::set<LabelType> &outRelatedLabels)
+void CommunicatorLinker::TargetOffline(const std::string &inTarget, std::set<LabelType> &outRelatedLabels)
 {
     std::lock_guard<std::mutex> entireInfoLockGuard(entireInfoMutex_);
     outRelatedLabels = targetMapOnlineLabels_[inTarget];
@@ -83,7 +83,6 @@ int CommunicatorLinker::TargetOffline(const std::string &inTarget, std::set<Labe
     // the distinctValue of this remote target may be changed, and the sequenceId may start from zero
     targetDistinctValue_.erase(inTarget);
     topRecvLabelSeq_.erase(inTarget);
-    return E_OK;
 }
 
 // Add local label. Create async task to send out label_exchange and waiting for label_exchange_ack.
@@ -151,8 +150,8 @@ int CommunicatorLinker::ReceiveLabelExchange(const std::string &inTarget, const
         } else if (inSequenceId < topRecvLabelSeq_[inTarget]) {
             // inSequenceId can be equal to topRecvLabelSeq, in this case, the ack of this sequence send to this target
             // may be lost, this target resend LabelExchange, and we should resend ack to this target
-            LOGW("[Linker][RecvLabel] inSequenceId=%llu smaller than topRecvLabelSeq=%llu. Frame Ignored.",
-                ULL(inSequenceId), ULL(topRecvLabelSeq_[inTarget]));
+            LOGW("[Linker][RecvLabel] inSequenceId=%" PRIu64 " smaller than topRecvLabelSeq=%" PRIu64
+                ". Frame Ignored.", ULL(inSequenceId), ULL(topRecvLabelSeq_[inTarget]));
             return -E_OUT_OF_DATE;
         } else {
             // Update top sequenceId of received LabelExchange
@@ -192,11 +191,11 @@ int CommunicatorLinker::ReceiveLabelExchangeAck(const std::string &inTarget, uin
     // This two judge is for detecting case that local device process restart so incSequenceId_ restart from 0
     // The remote device may send an ack cause by previous process, which may destroy the functionality of this process
     if (waitAckSeq_.count(inTarget) == 0) {
-        LOGW("[Linker][RecvAck] Not waiting any ack now, inSequenceId=%llu", ULL(inSequenceId));
+        LOGW("[Linker][RecvAck] Not waiting any ack now, inSequenceId=%" PRIu64 "", ULL(inSequenceId));
         return -E_NOT_FOUND;
     }
     if (waitAckSeq_[inTarget] < inSequenceId) {
-        LOGW("[Linker][RecvAck] Not waiting this ack now, inSequenceId=%llu, waitAckSeq_=%llu",
+        LOGW("[Linker][RecvAck] Not waiting this ack now, inSequenceId=%" PRIu64 ", waitAckSeq_=%" PRIu64,
             ULL(inSequenceId), ULL(waitAckSeq_[inTarget]));
         return -E_NOT_FOUND;
     }
@@ -205,7 +204,7 @@ int CommunicatorLinker::ReceiveLabelExchangeAck(const std::string &inTarget, uin
         // Firstly receive LabelExchangeAck from this target
         recvAckSeq_[inTarget] = inSequenceId;
     } else if (inSequenceId <= recvAckSeq_[inTarget]) {
-        LOGW("[Linker][RecvAck] inSequenceId=%llu not greater than recvAckSeq_=%llu. Frame Ignored.",
+        LOGW("[Linker][RecvAck] inSequenceId=%" PRIu64 " not greater than recvAckSeq_=%" PRIu64 ". Frame Ignored.",
             ULL(inSequenceId), ULL(recvAckSeq_[inTarget]));
         return -E_OUT_OF_DATE;
     } else {
@@ -237,12 +236,13 @@ void CommunicatorLinker::SuspendByOnceTimer(const std::function<void(void)> &inA
     RuntimeContext *context = RuntimeContext::GetInstance();
     int errCode = context->SetTimer(static_cast<int>(inCountDown), [inAction](TimerId inTimerId)->int{
         // Note: inAction should be captured by value (must not by reference)
-        LOGI("[Linker][Suspend] Timer Due : inTimerId=%llu.", ULL(inTimerId));
+        LOGI("[Linker][Suspend] Timer Due : inTimerId=%" PRIu64 ".", ULL(inTimerId));
         inAction();
         return -E_END_TIMER;
     }, nullptr, thisTimerId);
     if (errCode == E_OK) {
-        LOGI("[Linker][Suspend] SetTimer Success : thisTimerId=%llu, wait=%u(ms).", ULL(thisTimerId), inCountDown);
+        LOGI("[Linker][Suspend] SetTimer Success : thisTimerId=%" PRIu64 ", wait=%u(ms).",
+            ULL(thisTimerId), inCountDown);
     } else {
         LOGI("[Linker][Suspend] SetTimer Fail Raise Thread Instead : errCode=%d, wait=%u(ms).", errCode, inCountDown);
         std::thread timerThread([inAction, inCountDown]() {
@@ -269,7 +269,7 @@ void CommunicatorLinker::DetectDistinctValueChange(const std::string &inTarget,
     }
 
     // DistinctValue change detected !!! This must be caused by malfunctioning of underlayer communication component.
-    LOGE("[Linker][Detect] ######## DISTINCT VALUE CHANGE DETECTED : %llu VS %llu ########",
+    LOGE("[Linker][Detect] ######## DISTINCT VALUE CHANGE DETECTED : %" PRIu64 " VS %" PRIu64 " ########",
         ULL(inDistinctValue), ULL(targetDistinctValue_[inTarget]));
     targetDistinctValue_[inTarget] = inDistinctValue;
     // The process of remote target must have undergone a quit and restart, the remote sequenceId will start from zero.
@@ -311,8 +311,8 @@ int CommunicatorLinker::TriggerLabelExchangeEvent(const std::string &toTarget)
             waitAckSeq_[toTarget] = sequenceId;
         } else if (waitAckSeq_[toTarget] > sequenceId) {
             // New LabelExchangeEvent had been trigger for this target, so this event can be abort
-            LOGI("[Linker][TriggerLabel] Detect newSeqId=%llu than thisSeqId=%llu be triggered for target=%s{private}",
-                ULL(waitAckSeq_[toTarget]), ULL(sequenceId), toTarget.c_str());
+            LOGI("[Linker][TriggerLabel] Detect newSeqId=%" PRIu64 " than thisSeqId=%" PRIu64
+                " be triggered for target=%s{private}", ULL(waitAckSeq_[toTarget]), ULL(sequenceId), toTarget.c_str());
             delete buffer;
             buffer = nullptr;
             return E_OK;
@@ -363,7 +363,7 @@ void CommunicatorLinker::SendLabelExchange(const std::string &toTarget, SerialBu
     uint32_t inRetransmitCount)
 {
     // Check whether have the need to send
-    bool noNeedToSend = ((inRetransmitCount <= RETRANSMIT_LIMIT) ? false : true);
+    bool noNeedToSend = inRetransmitCount > RETRANSMIT_LIMIT;
     {
         std::lock_guard<std::mutex> entireInfoLockGuard(entireInfoMutex_);
         if (remoteOnlineTarget_.count(toTarget) == 0) {
@@ -379,9 +379,10 @@ void CommunicatorLinker::SendLabelExchange(const std::string &toTarget, SerialBu
             noNeedToSend = true;
         }
         if (noNeedToSend) { // ATTENTION: This Log should be inside the protection of entireInfoLockGuard!!!
-            LOGI("[Linker][SendLabel] NoNeedSend:target=%s{private}, thisSeqId=%llu, waitAckSeq=%llu, recvAckSeq=%llu,"
-                "retrans=%u.", toTarget.c_str(), ULL(inSequenceId), ULL(waitAckSeq_[toTarget]),
-                ULL((recvAckSeq_.count(toTarget) != 0) ? recvAckSeq_[toTarget] : ~ULL(0)), inRetransmitCount);
+            LOGI("[Linker][SendLabel] NoNeedSend:target=%s{private}, thisSeqId=%" PRIu64 ", waitAckSeq=%" PRIu64
+                ", recvAckSeq=%" PRIu64 ",retrans=%u.", toTarget.c_str(), ULL(inSequenceId),
+                ULL(waitAckSeq_[toTarget]), ULL((recvAckSeq_.count(toTarget) != 0) ? recvAckSeq_[toTarget] : ~ULL(0)),
+                inRetransmitCount);
         } // ~0 indicate no ack ever recv
     }
     if (noNeedToSend) {
@@ -394,7 +395,7 @@ void CommunicatorLinker::SendLabelExchange(const std::string &toTarget, SerialBu
     int error = E_OK;
     SerialBuffer *cloneBuffer = inBuff->Clone(error);
     TaskConfig config{true, 0, Priority::HIGH};
-    int errCode = aggregator_->CreateSendTask(toTarget, inBuff, FrameType::COMMUNICATION_LABEL_EXCHANGE, config);
+    int errCode = aggregator_->ScheduleSendTask(toTarget, inBuff, FrameType::COMMUNICATION_LABEL_EXCHANGE, config);
     if (errCode == E_OK) {
         // Send ok, go on to wait ack, and maybe resend
         if (error == E_OK) {
@@ -403,7 +404,8 @@ void CommunicatorLinker::SendLabelExchange(const std::string &toTarget, SerialBu
                 SendLabelExchange(toTarget, cloneBuffer, inSequenceId, inRetransmitCount + 1); // Do retransmission
             }, GetDynamicTimeLapseForWaitingAck(inRetransmitCount));
         } else {
-            LOGE("[Linker][SendLabel] CloneFail: target=%s{private}, SeqId=%llu.", toTarget.c_str(), ULL(inSequenceId));
+            LOGE("[Linker][SendLabel] CloneFail: target=%s{private}, SeqId=%" PRIu64 ".",
+            toTarget.c_str(), ULL(inSequenceId));
         }
     } else {
         // Send fail, go on to retry send
@@ -436,8 +438,9 @@ void CommunicatorLinker::SendLabelExchangeAck(const std::string &toTarget, Seria
             noNeedToSend = true;
         }
         if (noNeedToSend) { // ATTENTION: This Log should be inside the protection of entireInfoLockGuard!!!
-            LOGI("[Linker][SendAck] NoNeedSend:target=%s{private}, thisSeqId=%llu, topRecLabelSeq=%llu, thisAckId=%llu,"
-                "ackTriggerId=%llu.", toTarget.c_str(), ULL(inSequenceId), // ~0 indacate no label ever recv
+            LOGI("[Linker][SendAck] NoNeedSend:target=%s{private}, thisSeqId=%" PRIu64 ", topRecLabelSeq=%" PRIu64
+                ", thisAckId=%" PRIu64 ",ackTriggerId=%" PRIu64 ".",
+                toTarget.c_str(), ULL(inSequenceId), // ~0 indacate no label ever recv
                 ULL((topRecvLabelSeq_.count(toTarget) != 0) ? topRecvLabelSeq_[toTarget] : ~ULL(0)),
                 ULL(inAckTriggerId), ULL(ackTriggerId_[toTarget]));
         }
@@ -450,7 +453,7 @@ void CommunicatorLinker::SendLabelExchangeAck(const std::string &toTarget, Seria
     }
 
     TaskConfig config{true, 0, Priority::HIGH};
-    int errCode = aggregator_->CreateSendTask(toTarget, inBuff, FrameType::COMMUNICATION_LABEL_EXCHANGE_ACK, config);
+    int errCode = aggregator_->ScheduleSendTask(toTarget, inBuff, FrameType::COMMUNICATION_LABEL_EXCHANGE_ACK, config);
     if (errCode == E_OK) {
         // Send ok, finish event
         RefObject::DecObjRef(this); // ATTENTION: The DecObjRef should be outside entireInfoLockGuard!!!
diff --git a/frameworks/libs/distributeddb/communicator/src/communicator_linker.h b/frameworks/libs/distributeddb/communicator/src/communicator_linker.h
index d8d0740f5b14b2f63b0192b7cf587a2cb092d6a2..3d0d701d312d5fa897df033891394057b0d5432c 100644
--- a/frameworks/libs/distributeddb/communicator/src/communicator_linker.h
+++ b/frameworks/libs/distributeddb/communicator/src/communicator_linker.h
@@ -16,17 +16,17 @@
 #ifndef COMMUNICATOR_LINKER_H
 #define COMMUNICATOR_LINKER_H
 
-#include <set>
+#include <atomic>
+#include <cstdlib>
+#include <functional>
 #include <map>
 #include <mutex>
-#include <atomic>
+#include <set>
 #include <string>
 #include <vector>
-#include <cstdlib>
-#include <functional>
+#include "communicator_type_define.h"
 #include "ref_object.h"
 #include "serial_buffer.h"
-#include "communicator_type_define.h"
 
 namespace DistributedDB {
 class CommunicatorAggregator; // Forward Declaration
@@ -46,7 +46,7 @@ public:
 
     // Clear all labels related to this target. Let no longer waiting for ack of this target.
     // The caller should notify all related communicator about this target offline.
-    int TargetOffline(const std::string &inTarget, std::set<LabelType> &outRelatedLabels);
+    void TargetOffline(const std::string &inTarget, std::set<LabelType> &outRelatedLabels);
 
     // Add local label. Create async task to send out label_exchange and waiting for label_exchange_ack.
     // If waiting timeout, pass the send&wait task to overrall timing retry task.
diff --git a/frameworks/libs/distributeddb/communicator/src/frame_combiner.cpp b/frameworks/libs/distributeddb/communicator/src/frame_combiner.cpp
index bbca2164878b6ae8c06f9edef4b61cfce7d02bda..70ee3d8f1009fde7ef80c8223750feff1f8cf01a 100644
--- a/frameworks/libs/distributeddb/communicator/src/frame_combiner.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/frame_combiner.cpp
@@ -20,7 +20,7 @@
 
 namespace DistributedDB {
 static const uint32_t MAX_WORK_PER_SRC_TARGET = 1; // Only allow 1 CombineWork for each target
-static const int SURVAIL_PERIOD_IN_MILLISECOND = 10000; // Period is 10 s
+static const int COMBINER_SURVAIL_PERIOD_IN_MILLISECOND = 10000; // Period is 10 s
 
 void FrameCombiner::Initialize()
 {
@@ -32,7 +32,7 @@ void FrameCombiner::Initialize()
     TimerFinalizer finalizer = [this]() {
         timerRemovedIndicator_.SendSemaphore();
     };
-    int errCode = context->SetTimer(SURVAIL_PERIOD_IN_MILLISECOND, action, finalizer, timerId_);
+    int errCode = context->SetTimer(COMBINER_SURVAIL_PERIOD_IN_MILLISECOND, action, finalizer, timerId_);
     if (errCode != E_OK) {
         LOGE("[Combiner][Init] Set timer fail, errCode=%d.", errCode);
         return;
@@ -75,7 +75,7 @@ SerialBuffer *FrameCombiner::AssembleFrameFragment(const uint8_t *bytes, uint32_
 
         if (combineWorkPool_[sourceId][frameId].status.IsCombineDone()) {
             // We can parse the combined frame here, or outside this class.
-            LOGI("[Combiner][Assemble] Combine done, sourceId=%llu, frameId=%u.", ULL(sourceId), frameId);
+            LOGI("[Combiner][Assemble] Combine done, sourceId=%" PRIu64 ", frameId=%" PRIu32, ULL(sourceId), frameId);
             SerialBuffer *outFrame = combineWorkPool_[sourceId][frameId].buffer;
             outFrameInfo = combineWorkPool_[sourceId][frameId].frameInfo;
             outErrorNo = E_OK;
@@ -107,8 +107,8 @@ void FrameCombiner::PeriodicalSurveillance()
         std::set<uint32_t> frameToAbort;
         for (auto &eachFrame : eachSource.second) {
             if (!eachFrame.second.status.CheckProgress()) {
-                LOGW("[Combiner][Surveil] Source=%llu, frame=%u has no progress, this combine work will be aborted.",
-                    ULL(eachSource.first), eachFrame.first);
+                LOGW("[Combiner][Surveil] Source=%" PRIu64 ", frame=%" PRIu32
+                    " has no progress, this combine work will be aborted.", ULL(eachSource.first), eachFrame.first);
                 // Free this combine work first
                 delete eachFrame.second.buffer;
                 eachFrame.second.buffer = nullptr;
@@ -193,7 +193,7 @@ int FrameCombiner::CreateNewCombineWork(const uint8_t *bytes, uint32_t length, c
 
 void FrameCombiner::AbortCombineWorkBySource(uint64_t inSourceId)
 {
-    if (combineWorkPool_[inSourceId].size() == 0) {
+    if (combineWorkPool_[inSourceId].empty()) {
         return;
     }
     uint32_t toBeAbortFrameId = 0;
@@ -205,7 +205,7 @@ void FrameCombiner::AbortCombineWorkBySource(uint64_t inSourceId)
         }
     }
     // Do Abort!
-    LOGW("[Combiner][AbortWork] Abort Incomplete CombineWork, sourceId=%llu, frameId=%u.",
+    LOGW("[Combiner][AbortWork] Abort Incomplete CombineWork, sourceId=%" PRIu64 ", frameId=%" PRIu32 ".",
         ULL(inSourceId), toBeAbortFrameId);
     delete combineWorkPool_[inSourceId][toBeAbortFrameId].buffer;
     combineWorkPool_[inSourceId][toBeAbortFrameId].buffer = nullptr;
@@ -215,22 +215,22 @@ void FrameCombiner::AbortCombineWorkBySource(uint64_t inSourceId)
 bool FrameCombiner::CheckPacketWithOriWork(const ParseResult &inPacketInfo, const CombineWork &inWork)
 {
     if (inPacketInfo.GetFrameLen() != inWork.frameInfo.GetFrameLen()) {
-        LOGE("[Combiner][CheckPacket] FrameLen mismatch %u vs %u.", inPacketInfo.GetFrameLen(),
+        LOGE("[Combiner][CheckPacket] FrameLen mismatch %" PRIu32 " vs %" PRIu32 ".", inPacketInfo.GetFrameLen(),
             inWork.frameInfo.GetFrameLen());
         return false;
     }
     if (inPacketInfo.GetFragCount() != inWork.frameInfo.GetFragCount()) {
-        LOGE("[Combiner][CheckPacket] FragCount mismatch %u vs %u.", inPacketInfo.GetFragCount(),
+        LOGE("[Combiner][CheckPacket] FragCount mismatch %" PRIu32 " vs %" PRIu32 ".", inPacketInfo.GetFragCount(),
             inWork.frameInfo.GetFragCount());
         return false;
     }
     if (inPacketInfo.GetFragNo() >= inPacketInfo.GetFragCount()) {
-        LOGE("[Combiner][CheckPacket] FragNo=%u illegal vs FragCount=%u.", inPacketInfo.GetFragNo(),
+        LOGE("[Combiner][CheckPacket] FragNo=%" PRIu32 " illegal vs FragCount=%" PRIu32 ".", inPacketInfo.GetFragNo(),
             inPacketInfo.GetFragCount());
         return false;
     }
     if (inWork.status.IsFragNoAlreadyExist(inPacketInfo.GetFragNo())) {
-        LOGE("[Combiner][CheckPacket] FragNo=%u already exist.", inPacketInfo.GetFragNo());
+        LOGE("[Combiner][CheckPacket] FragNo=%" PRIu32 " already exist.", inPacketInfo.GetFragNo());
         return false;
     }
     return true;
diff --git a/frameworks/libs/distributeddb/communicator/src/frame_retainer.cpp b/frameworks/libs/distributeddb/communicator/src/frame_retainer.cpp
index e8d6db64e777b6ca350026d25513b5562afe6702..d364bfcd9e0f7c9b4250d008d064590f5cae0027 100644
--- a/frameworks/libs/distributeddb/communicator/src/frame_retainer.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/frame_retainer.cpp
@@ -20,16 +20,16 @@
 
 namespace DistributedDB {
 namespace {
-const uint32_t MAX_CAPACITY = 67108864; // 64 M bytes
+const uint32_t MAX_RETAIN_CAPACITY = 67108864; // 64 M bytes
 const uint32_t MAX_RETAIN_TIME = 10; // 10 s
 const uint32_t MAX_RETAIN_FRAME_SIZE = 33554432; // 32 M bytes
 const uint32_t MAX_RETAIN_FRAME_PER_LABEL_PER_TARGET = 5; // Allow 5 frame per communicator per source target
-const int SURVAIL_PERIOD_IN_MILLISECOND = 1000; // Period is 1 s
+const int RETAIN_SURVAIL_PERIOD_IN_MILLISECOND = 1000; // Period is 1 s
 inline void LogRetainInfo(const std::string &logPrefix, const LabelType &label, const std::string &target,
     uint64_t order, const RetainWork &work)
 {
-    LOGI("%s : Label=%s, target=%s{private}, retainOrder=%llu, frameId=%u, remainTime=%u, frameSize=%u.",
-        logPrefix.c_str(), VEC_TO_STR(label), target.c_str(), ULL(order),
+    LOGI("%s : Label=%s, target=%s{private}, retainOrder=%" PRIu64 ", frameId=%" PRIu32 ", remainTime=%" PRIu32
+        ", frameSize=%" PRIu32 ".", logPrefix.c_str(), VEC_TO_STR(label), target.c_str(), ULL(order),
         work.frameId, work.remainTime, work.buffer->GetSize());
 }
 }
@@ -44,7 +44,7 @@ void FrameRetainer::Initialize()
         PeriodicalSurveillance();
         return E_OK;
     };
-    int errCode = context->SetTimer(SURVAIL_PERIOD_IN_MILLISECOND, action, nullptr, timerId_);
+    int errCode = context->SetTimer(RETAIN_SURVAIL_PERIOD_IN_MILLISECOND, action, nullptr, timerId_);
     if (errCode != E_OK) {
         LOGE("[Retainer][Init] Set timer fail, errCode=%d.", errCode);
         return;
@@ -119,8 +119,8 @@ void FrameRetainer::RetainFrame(const FrameInfo &inFrame)
     // Discard obsolete frames until totalSize under capacity.
     DiscardObsoleteFramesIfNeed();
     // Display the final statistics
-    LOGI("[Retainer][Retain] Order=%llu. Statistics: TOTAL_BYTE=%u, TOTAL_FRAME=%u.", ULL(incRetainOrder_ - 1),
-        totalSizeByByte_, totalRetainFrames_);
+    LOGI("[Retainer][Retain] Order=%" PRIu64 ". Statistics: TOTAL_BYTE=%" PRIu32 ", TOTAL_FRAME=%" PRIu32 ".",
+        ULL(incRetainOrder_ - 1), totalSizeByByte_, totalRetainFrames_);
 }
 
 std::list<FrameInfo> FrameRetainer::FetchFramesForSpecificCommunicator(const LabelType &inCommLabel)
@@ -183,7 +183,7 @@ void FrameRetainer::PeriodicalSurveillance()
 
 void FrameRetainer::DiscardObsoleteFramesIfNeed()
 {
-    if (totalSizeByByte_ <= MAX_CAPACITY) {
+    if (totalSizeByByte_ <= MAX_RETAIN_CAPACITY) {
         return;
     }
     std::map<uint64_t, std::pair<LabelType, std::string>> discardOrder;
@@ -196,9 +196,10 @@ void FrameRetainer::DiscardObsoleteFramesIfNeed()
         }
     }
     // Discard obsolete frames until totalSize under capacity.
-    while (totalSizeByByte_ > MAX_CAPACITY) {
+    while (totalSizeByByte_ > MAX_RETAIN_CAPACITY) {
         if (discardOrder.empty()) { // Unlikely to happen
-            LOGE("[Retainer][Discard] Internal Error: Byte=%u, Frames=%u.", totalSizeByByte_, totalRetainFrames_);
+            LOGE("[Retainer][Discard] Internal Error: Byte=%" PRIu32 ", Frames=%" PRIu32 ".",
+                totalSizeByByte_, totalRetainFrames_);
             return;
         }
         auto iter = discardOrder.begin();
diff --git a/frameworks/libs/distributeddb/communicator/src/network_adapter.cpp b/frameworks/libs/distributeddb/communicator/src/network_adapter.cpp
index 061fe1a521df216e676e2d7e36ef3adf60680d82..e22fe896388e4dca7d66ca63ec96e54e27078026 100644
--- a/frameworks/libs/distributeddb/communicator/src/network_adapter.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/network_adapter.cpp
@@ -15,6 +15,7 @@
 
 #include "network_adapter.h"
 #include "db_constant.h"
+#include "db_common.h"
 #include "db_errno.h"
 #include "log_print.h"
 #include "runtime_context.h"
@@ -47,7 +48,7 @@ NetworkAdapter::~NetworkAdapter()
 
 int NetworkAdapter::StartAdapter()
 {
-    LOGI("[NAdapt][Start] Enter, ProcessLabel=%s.", processLabel_.c_str());
+    LOGI("[NAdapt][Start] Enter, ProcessLabel=%s.", STR_MASK(DBCommon::TransferStringToHex(processLabel_)));
     if (processLabel_.empty()) {
         return -E_INVALID_ARGS;
     }
@@ -146,7 +147,7 @@ uint32_t NetworkAdapter::GetMtuSize()
     std::lock_guard<std::mutex> mtuSizeLockGuard(mtuSizeMutex_);
     if (!isMtuSizeValid_) {
         mtuSize_ = processCommunicator_->GetMtuSize();
-        LOGI("[NAdapt][GetMtu] mtuSize=%u.", mtuSize_);
+        LOGD("[NAdapt][GetMtu] mtuSize=%" PRIu32 ".", mtuSize_);
         mtuSize_ = CheckAndAdjustMtuSize(mtuSize_);
         isMtuSizeValid_ = true;
     }
@@ -166,7 +167,7 @@ uint32_t NetworkAdapter::GetMtuSize(const std::string &target)
         DeviceInfos devInfo;
         devInfo.identifier = target;
         uint32_t oriMtuSize = processCommunicator_->GetMtuSize(devInfo);
-        LOGI("[NAdapt][GetMtu] mtuSize=%u of target=%s{private}.", oriMtuSize, target.c_str());
+        LOGD("[NAdapt][GetMtu] mtuSize=%" PRIu32 " of target=%s{private}.", oriMtuSize, target.c_str());
         devMapMtuSize_[target] = CheckAndAdjustMtuSize(oriMtuSize);
     }
     return devMapMtuSize_[target];
@@ -176,7 +177,7 @@ uint32_t NetworkAdapter::GetMtuSize(const std::string &target)
 uint32_t NetworkAdapter::GetTimeout()
 {
     uint32_t timeout = processCommunicator_->GetTimeout();
-    LOGI("[NAdapt][GetTimeout] timeout_=%u ms.", timeout);
+    LOGD("[NAdapt][GetTimeout] timeout_=%" PRIu32 " ms.", timeout);
     return CheckAndAdjustTimeout(timeout);
 }
 
@@ -185,7 +186,7 @@ uint32_t NetworkAdapter::GetTimeout(const std::string &target)
     DeviceInfos devInfos;
     devInfos.identifier = target;
     uint32_t timeout = processCommunicator_->GetTimeout(devInfos);
-    LOGI("[NAdapt][GetTimeout] timeout=%u ms of target=%s{private}.", timeout, target.c_str());
+    LOGD("[NAdapt][GetTimeout] timeout=%" PRIu32 " ms of target=%s{private}.", timeout, target.c_str());
     return CheckAndAdjustTimeout(timeout);
 }
 
diff --git a/frameworks/libs/distributeddb/communicator/src/protocol_proto.cpp b/frameworks/libs/distributeddb/communicator/src/protocol_proto.cpp
index ed79435483bfbe96752a0bb02d25ee8308a6dfed..ba232df42533b1f1be6ab61285f140836d013c30 100644
--- a/frameworks/libs/distributeddb/communicator/src/protocol_proto.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/protocol_proto.cpp
@@ -14,16 +14,16 @@
  */
 
 #include "protocol_proto.h"
-#include <new>
 #include <iterator>
-#include "hash.h"
-#include "securec.h"
-#include "version.h"
+#include <new>
 #include "db_common.h"
-#include "log_print.h"
-#include "macro_utils.h"
 #include "endian_convert.h"
+#include "hash.h"
 #include "header_converter.h"
+#include "log_print.h"
+#include "macro_utils.h"
+#include "securec.h"
+#include "version.h"
 
 namespace DistributedDB {
 namespace {
@@ -44,9 +44,9 @@ const uint32_t SEQUENCE_ID_LEN = sizeof(uint64_t);
 // Note: COMM_LABEL_LENGTH is defined in communicator_type_define.h
 const uint32_t COMM_LABEL_COUNT_LEN = sizeof(uint64_t);
 // Local func to set and get frame Type from packet Type field
-void SetFrameType(uint8_t &inPacketType, FrameType inFrameType)
+void SetFrameType(FrameType inFrameType, uint8_t &inPacketType)
 {
-    inPacketType &= 0x0F; // Use 0x0F to clear high for bits
+    inPacketType &= 0x0F; // Use 0x0F to clear high four bits
     inPacketType |= (static_cast<uint8_t>(inFrameType) << 4); // frame type is on high 4 bits
 }
 FrameType GetFrameType(uint8_t inPacketType)
@@ -79,8 +79,8 @@ uint32_t ProtocolProto::GetCommLayerFrameHeaderLength()
     return length;
 }
 
-SerialBuffer *ProtocolProto::ToSerialBuffer(const Message *inMsg, int &outErrorNo,
-    std::shared_ptr<ExtendHeaderHandle> &extendHandle, bool onlyMsgHeader)
+SerialBuffer *ProtocolProto::ToSerialBuffer(const Message *inMsg,
+    std::shared_ptr<ExtendHeaderHandle> &extendHandle, bool onlyMsgHeader, int &outErrorNo)
 {
     if (inMsg == nullptr) {
         outErrorNo = -E_INVALID_ARGS;
@@ -186,7 +186,7 @@ SerialBuffer *ProtocolProto::BuildFeedbackMessageFrame(const Message *inMsg, con
     int &outErrorNo)
 {
     std::shared_ptr<ExtendHeaderHandle> extendHandle = nullptr;
-    SerialBuffer *buffer = ToSerialBuffer(inMsg, outErrorNo, extendHandle, true);
+    SerialBuffer *buffer = ToSerialBuffer(inMsg, extendHandle, true, outErrorNo);
     if (buffer == nullptr) {
         // outErrorNo had already been set in ToSerialBuffer
         return nullptr;
@@ -231,10 +231,14 @@ SerialBuffer *ProtocolProto::BuildLabelExchange(uint64_t inDistinctValue, uint64
 
     auto payloadByteLen = buffer->GetWritableBytesForPayload();
     auto fieldPtr = reinterpret_cast<uint64_t *>(payloadByteLen.first);
-    *fieldPtr++ = HostToNet(static_cast<uint64_t>(PROTOCOL_VERSION));
-    *fieldPtr++ = HostToNet(inDistinctValue);
-    *fieldPtr++ = HostToNet(inSequenceId);
-    *fieldPtr++ = HostToNet(static_cast<uint64_t>(inLabels.size()));
+    *fieldPtr = HostToNet(static_cast<uint64_t>(PROTOCOL_VERSION));
+    fieldPtr++;
+    *fieldPtr = HostToNet(inDistinctValue);
+    fieldPtr++;
+    *fieldPtr = HostToNet(inSequenceId);
+    fieldPtr++;
+    *fieldPtr = HostToNet(static_cast<uint64_t>(inLabels.size()));
+    fieldPtr++;
     // Note: don't worry, memory length had been carefully calculated above
     auto bytePtr = reinterpret_cast<uint8_t *>(fieldPtr);
     for (auto &eachLabel : inLabels) {
@@ -265,9 +269,12 @@ SerialBuffer *ProtocolProto::BuildLabelExchangeAck(uint64_t inDistinctValue, uin
 
     auto payloadByteLen = buffer->GetWritableBytesForPayload();
     auto fieldPtr = reinterpret_cast<uint64_t *>(payloadByteLen.first);
-    *fieldPtr++ = HostToNet(static_cast<uint64_t>(PROTOCOL_VERSION));
-    *fieldPtr++ = HostToNet(inDistinctValue);
-    *fieldPtr++ = HostToNet(inSequenceId);
+    *fieldPtr = HostToNet(static_cast<uint64_t>(PROTOCOL_VERSION));
+    fieldPtr++;
+    *fieldPtr = HostToNet(inDistinctValue);
+    fieldPtr++;
+    *fieldPtr = HostToNet(inSequenceId);
+    fieldPtr++;
     outErrorNo = E_OK;
     return buffer;
 }
@@ -305,14 +312,14 @@ int ProtocolProto::AnalyzeSplitStructure(const ParseResult &inResult, uint32_t &
 
     // Firstly: Check frameLen
     if (frameLen <= sizeof(CommPhyHeader) || frameLen > MAX_FRAME_LEN) {
-        LOGE("[Proto][ParsePhyOpt] FrameLen=%u illegal.", frameLen);
+        LOGE("[Proto][ParsePhyOpt] FrameLen=%" PRIu32 " illegal.", frameLen);
         return -E_PARSE_FAIL;
     }
 
     // Secondly: Check fragCount and fragNo
     uint32_t lengthBeSplit = frameLen - sizeof(CommPhyHeader);
     if (fragCount == 0 || fragCount < MIN_FRAGMENT_COUNT || fragCount > lengthBeSplit || fragNo >= fragCount) {
-        LOGE("[Proto][ParsePhyOpt] FragCount=%u or fragNo=%u illegal.", fragCount, fragNo);
+        LOGE("[Proto][ParsePhyOpt] FragCount=%" PRIu32 " or fragNo=%" PRIu32 " illegal.", fragCount, fragNo);
         return -E_PARSE_FAIL;
     }
 
@@ -322,10 +329,11 @@ int ProtocolProto::AnalyzeSplitStructure(const ParseResult &inResult, uint32_t &
     outFragLen = quotient;
     outLastFragLen = quotient + remainder;
     uint32_t thisFragLen = ((fragNo != fragCount - 1) ? outFragLen : outLastFragLen); // subtract by 1 for index
-    if (sizeof(CommPhyHeader) + sizeof(CommPhyOptHeader) + thisFragLen +
-        inResult.GetPaddingLen() != inResult.GetPacketLen()) {
-        LOGE("[Proto][ParsePhyOpt] Length Error: FrameLen=%u, FragCount=%u, fragNo=%u, PaddingLen=%u, PacketLen=%u",
-            frameLen, fragCount, fragNo, inResult.GetPaddingLen(), inResult.GetPacketLen());
+    if ((sizeof(CommPhyHeader) + sizeof(CommPhyOptHeader) + thisFragLen +
+        inResult.GetPaddingLen()) != inResult.GetPacketLen()) {
+        LOGE("[Proto][ParsePhyOpt] Length Error: FrameLen=%" PRIu32 ", FragCount=%" PRIu32 ", fragNo=%" PRIu32
+            ", PaddingLen=%" PRIu32 ", PacketLen=%" PRIu32, frameLen, fragCount, fragNo, inResult.GetPaddingLen(),
+            inResult.GetPacketLen());
         return -E_PARSE_FAIL;
     }
 
@@ -405,7 +413,7 @@ int ProtocolProto::SetDivergeHeader(SerialBuffer *inBuff, const LabelType &inCom
 }
 
 namespace {
-void FillPhyHeaderLenInfo(CommPhyHeader &header, uint32_t packetLen, uint64_t sum, uint8_t type, uint8_t paddingLen)
+void FillPhyHeaderLenInfo(uint32_t packetLen, uint64_t sum, uint8_t type, uint8_t paddingLen, CommPhyHeader &header)
 {
     header.packetLen = packetLen;
     header.checkSum = sum;
@@ -430,7 +438,7 @@ int ProtocolProto::SetPhyHeader(SerialBuffer *inBuff, const PhyHeaderInfo &inInf
     uint8_t paddingLen = static_cast<uint8_t>(bufferByteLen.second - frameByteLen.second);
     uint8_t packetType = PACKET_TYPE_NOT_FRAGMENTED;
     if (inInfo.frameType != FrameType::INVALID_MAX_FRAME_TYPE) {
-        SetFrameType(packetType, inInfo.frameType);
+        SetFrameType(inInfo.frameType, packetType);
     } else {
         return -E_INVALID_ARGS;
     }
@@ -442,7 +450,7 @@ int ProtocolProto::SetPhyHeader(SerialBuffer *inBuff, const PhyHeaderInfo &inInf
     phyHeader.frameId = inInfo.frameId;
     phyHeader.packetType = 0;
     phyHeader.dbIntVer = DB_GLOBAL_VERSION;
-    FillPhyHeaderLenInfo(phyHeader, packetLen, 0, packetType, paddingLen); // Sum is calculated afterwards
+    FillPhyHeaderLenInfo(packetLen, 0, packetType, paddingLen, phyHeader); // Sum is calculated afterwards
     HeaderConverter::ConvertHostToNet(phyHeader, phyHeader);
 
     errno_t retCode = memcpy_s(headerByteLen.first, headerByteLen.second, &phyHeader, sizeof(CommPhyHeader));
@@ -483,22 +491,19 @@ int ProtocolProto::CheckAndParsePacket(const std::string &srcTarget, const uint8
         errCode = ParseCommPhyOptHeader(bytes, length, outResult);
         if (errCode != E_OK) {
             LOGE("[Proto][ParsePacket] Parse CommPhyOptHeader Fail, errCode=%d.", errCode);
-            return errCode;
         }
     } else if (outResult.GetFrameTypeInfo() != FrameType::APPLICATION_MESSAGE) {
         errCode = ParseCommLayerPayload(bytes, length, outResult);
         if (errCode != E_OK) {
             LOGE("[Proto][ParsePacket] Parse CommLayerPayload Fail, errCode=%d.", errCode);
-            return errCode;
         }
     } else {
         errCode = ParseCommDivergeHeader(bytes, length, outResult);
         if (errCode != E_OK) {
             LOGE("[Proto][ParsePacket] Parse DivergeHeader Fail, errCode=%d.", errCode);
-            return errCode;
         }
     }
-    return E_OK;
+    return errCode;
 }
 
 int ProtocolProto::CheckAndParseFrame(const SerialBuffer *inBuff, ParseResult &outResult)
@@ -525,11 +530,12 @@ int ProtocolProto::CheckAndParseFrame(const SerialBuffer *inBuff, ParseResult &o
 
 void ProtocolProto::DisplayPacketInformation(const uint8_t *bytes, uint32_t length)
 {
-    static std::map<FrameType, std::string> frameTypeStr{
-        {FrameType::EMPTY, "EmptyFrame"},
-        {FrameType::APPLICATION_MESSAGE, "AppLayerFrame"},
-        {FrameType::COMMUNICATION_LABEL_EXCHANGE, "CommLayerFrame_LabelExchange"},
-        {FrameType::COMMUNICATION_LABEL_EXCHANGE_ACK, "CommLayerFrame_LabelExchangeAck"}};
+    static const char *frameTypeStr[] = {
+        "EmptyFrame",
+        "AppLayerFrame",
+        "CommLayerFrame_LabelExchange",
+        "CommLayerFrame_LabelExchangeAck"
+    };
 
     if (length < sizeof(CommPhyHeader)) {
         return;
@@ -539,7 +545,7 @@ void ProtocolProto::DisplayPacketInformation(const uint8_t *bytes, uint32_t leng
     uint8_t pktType = NetToHost(phyHeader->packetType);
     bool isFragment = ((pktType & PACKET_TYPE_FRAGMENTED) != 0);
     FrameType frameType = GetFrameType(pktType);
-    if (frameType == FrameType::INVALID_MAX_FRAME_TYPE) {
+    if (frameType >= FrameType::INVALID_MAX_FRAME_TYPE) {
         LOGW("[Proto][Display] This is unrecognized frame, pktType=%" PRIu8 ".", pktType);
         return;
     }
@@ -548,18 +554,20 @@ void ProtocolProto::DisplayPacketInformation(const uint8_t *bytes, uint32_t leng
             return;
         }
         auto phyOpt = reinterpret_cast<const CommPhyOptHeader *>(bytes + sizeof(CommPhyHeader));
-        LOGI("[Proto][Display] This is %s, frameId=%u, frameLen=%u, fragCount=%u, fragNo=%u.",
-            frameTypeStr[frameType].c_str(), frameId, NetToHost(phyOpt->frameLen),
+        LOGI("[Proto][Display] This is %s, frameId=%" PRIu32 ", frameLen=%" PRIu32 ", fragCount=%" PRIu32
+            ", fragNo=%" PRIu32 ".", frameTypeStr[static_cast<int32_t>(frameType)],
+            frameId, NetToHost(phyOpt->frameLen),
             NetToHost(phyOpt->fragCount), NetToHost(phyOpt->fragNo));
     } else {
-        LOGI("[Proto][Display] This is %s, frameId=%u.", frameTypeStr[frameType].c_str(), frameId);
+        LOGI("[Proto][Display] This is %s, frameId=%" PRIu32 ".",
+            frameTypeStr[static_cast<int32_t>(frameType)], frameId);
     }
 }
 
 int ProtocolProto::CalculateXorSum(const uint8_t *bytes, uint32_t length, uint64_t &outSum)
 {
-    if (length % sizeof(uint64_t) != 0) {
-        LOGE("[Proto][CalcuXorSum] Length=%d not multiple of eight.", length);
+    if ((length > INT32_MAX) || (length % sizeof(uint64_t) != 0)) {
+        LOGE("[Proto][CalcuXorSum] Length=%d not multiple of eight or larget than int32_max.", length);
         return -E_LENGTH_ERROR;
     }
     int count = length / sizeof(uint64_t);
@@ -575,7 +583,7 @@ int ProtocolProto::CalculateDataSerializeLength(const Message *inMsg, uint32_t &
 {
     uint32_t messageId = inMsg->GetMessageId();
     if (msgIdMapFunc_.count(messageId) == 0) {
-        LOGE("[Proto][CalcuDataSerialLen] Not registered for messageId=%u.", messageId);
+        LOGE("[Proto][CalcuDataSerialLen] Not registered for messageId=%" PRIu32 ".", messageId);
         return -E_NOT_REGISTER;
     }
 
@@ -584,8 +592,8 @@ int ProtocolProto::CalculateDataSerializeLength(const Message *inMsg, uint32_t &
     uint32_t alignedLen = BYTE_8_ALIGN(serializeLen);
     // Currently not allowed the upper module to send a message without data. Regard serializeLen zero as abnormal.
     if (serializeLen == 0 || alignedLen > MAX_FRAME_LEN - GetLengthBeforeSerializedData()) {
-        LOGE("[Proto][CalcuDataSerialLen] Length too large, msgId=%u, serializeLen=%u, alignedLen=%u.",
-            messageId, serializeLen, alignedLen);
+        LOGE("[Proto][CalcuDataSerialLen] Length too large, msgId=%" PRIu32 ", serializeLen=%" PRIu32
+            ", alignedLen=%" PRIu32 ".", messageId, serializeLen, alignedLen);
         return -E_LENGTH_ERROR;
     }
     // Attention: return the serializeLen nor the alignedLen. Let SerialBuffer to deal with the padding
@@ -597,7 +605,7 @@ int ProtocolProto::SerializeMessage(SerialBuffer *inBuff, const Message *inMsg)
 {
     auto payloadByteLen = inBuff->GetWritableBytesForPayload();
     if (payloadByteLen.second < sizeof(MessageHeader)) { // For equal, only msgHeader case
-        LOGE("[Proto][Serialize] Length error, payload length=%u.", payloadByteLen.second);
+        LOGE("[Proto][Serialize] Length error, payload length=%" PRIu32 ".", payloadByteLen.second);
         return -E_LENGTH_ERROR;
     }
     uint32_t dataLen = payloadByteLen.second - sizeof(MessageHeader);
@@ -636,12 +644,12 @@ int ProtocolProto::DeSerializeMessage(const SerialBuffer *inBuff, Message *inMsg
     }
     uint16_t version = NetToHost(*(reinterpret_cast<const uint16_t *>(payloadByteLen.first)));
     if (!IsSupportMessageVersion(version)) {
-        LOGE("[Proto][DeSerialize] Version=%u not support.", version);
+        LOGE("[Proto][DeSerialize] Version=%" PRIu32 " not support.", version);
         return -E_VERSION_NOT_SUPPORT;
     }
 
     if (payloadByteLen.second < sizeof(MessageHeader)) {
-        LOGE("[Proto][DeSerialize] Length error, payload length=%u.", payloadByteLen.second);
+        LOGE("[Proto][DeSerialize] Length error, payload length=%" PRIu32 ".", payloadByteLen.second);
         return -E_LENGTH_ERROR;
     }
     auto oriMsgHeader = reinterpret_cast<const MessageHeader *>(payloadByteLen.first);
@@ -655,12 +663,12 @@ int ProtocolProto::DeSerializeMessage(const SerialBuffer *inBuff, Message *inMsg
     inMsg->SetErrorNo(messageHdr.errorNo);
     uint32_t dataLen = payloadByteLen.second - sizeof(MessageHeader);
     if (dataLen != messageHdr.dataLen) {
-        LOGE("[Proto][DeSerialize] dataLen=%u, msgDataLen=%u.", dataLen, messageHdr.dataLen);
+        LOGE("[Proto][DeSerialize] dataLen=%" PRIu32 ", msgDataLen=%" PRIu32 ".", dataLen, messageHdr.dataLen);
         return -E_LENGTH_ERROR;
     }
     // It is better to check FeedbackMessage first and check onlyMsgHeader flag later
     if (IsFeedbackErrorMessage(messageHdr.errorNo)) {
-        LOGI("[Proto][DeSerialize] Feedback Message with errorNo=%u.", messageHdr.errorNo);
+        LOGI("[Proto][DeSerialize] Feedback Message with errorNo=%" PRIu32 ".", messageHdr.errorNo);
         return E_OK;
     }
     if (onlyMsgHeader || dataLen == 0) { // Do not need to deserialize data
@@ -668,7 +676,7 @@ int ProtocolProto::DeSerializeMessage(const SerialBuffer *inBuff, Message *inMsg
     }
     uint32_t messageId = inMsg->GetMessageId();
     if (msgIdMapFunc_.count(messageId) == 0) {
-        LOGE("[Proto][DeSerialize] Not register, messageId=%u.", messageId);
+        LOGE("[Proto][DeSerialize] Not register, messageId=%" PRIu32 ".", messageId);
         return -E_NOT_REGISTER;
     }
     TransformFunc function = msgIdMapFunc_[messageId];
@@ -702,11 +710,11 @@ int ProtocolProto::ParseCommPhyHeaderCheckMagicAndVersion(const uint8_t *bytes,
     uint16_t version = NetToHost(*fieldPtr++);
 
     if (magic != MAGIC_CODE) {
-        LOGE("[Proto][ParsePhyCheckVer] MagicCode=%u Error.", magic);
+        LOGE("[Proto][ParsePhyCheckVer] MagicCode=%" PRIu32 " Error.", magic);
         return -E_PARSE_FAIL;
     }
     if (version != PROTOCOL_VERSION) {
-        LOGE("[Proto][ParsePhyCheckVer] Version=%u Error.", version);
+        LOGE("[Proto][ParsePhyCheckVer] Version=%" PRIu32 " Error.", version);
         return -E_VERSION_NOT_SUPPORT;
     }
     return E_OK;
@@ -716,16 +724,16 @@ int ProtocolProto::ParseCommPhyHeaderCheckField(const std::string &srcTarget, co
     const uint8_t *bytes, uint32_t length)
 {
     if (phyHeader.sourceId != Hash::HashFunc(srcTarget)) {
-        LOGE("[Proto][ParsePhyCheck] SourceId Error: inSourceId=%llu, srcTarget=%s{private}, hashId=%llu.",
+        LOGE("[Proto][ParsePhyCheck] SourceId Error: inSourceId=%" PRIu64 ", srcTarget=%s{private}, hashId=%" PRIu64,
             ULL(phyHeader.sourceId), srcTarget.c_str(), ULL(Hash::HashFunc(srcTarget)));
         return -E_PARSE_FAIL;
     }
     if (phyHeader.packetLen != length) {
-        LOGE("[Proto][ParsePhyCheck] PacketLen=%u Mismatch length=%u.", phyHeader.packetLen, length);
+        LOGE("[Proto][ParsePhyCheck] PacketLen=%" PRIu32 " Mismatch length=%" PRIu32 ".", phyHeader.packetLen, length);
         return -E_PARSE_FAIL;
     }
     if (phyHeader.paddingLen > MAX_PADDING_LEN) {
-        LOGE("[Proto][ParsePhyCheck] PaddingLen=%u Error.", phyHeader.paddingLen);
+        LOGE("[Proto][ParsePhyCheck] PaddingLen=%" PRIu32 " Error.", phyHeader.paddingLen);
         return -E_PARSE_FAIL;
     }
     if (sizeof(CommPhyHeader) + phyHeader.paddingLen > phyHeader.packetLen) {
@@ -739,7 +747,7 @@ int ProtocolProto::ParseCommPhyHeaderCheckField(const std::string &srcTarget, co
         return -E_SUM_CALCULATE_FAIL;
     }
     if (phyHeader.checkSum != sumResult) {
-        LOGE("[Proto][ParsePhyCheck] Sum Mismatch, checkSum=%llu, sumResult=%llu.",
+        LOGE("[Proto][ParsePhyCheck] Sum Mismatch, checkSum=%" PRIu64 ", sumResult=%" PRIu64 ".",
             ULL(phyHeader.checkSum), ULL(sumResult));
         return -E_SUM_MISMATCH;
     }
@@ -778,7 +786,7 @@ int ProtocolProto::ParseCommPhyHeader(const std::string &srcTarget, const uint8_
     } // FragmentFlag default is false
     FrameType frameType = GetFrameType(phyHeader.packetType);
     if (frameType == FrameType::INVALID_MAX_FRAME_TYPE) {
-        LOGW("[Proto][ParsePhy] Unrecognized frame, pktType=%u.", phyHeader.packetType);
+        LOGW("[Proto][ParsePhy] Unrecognized frame, pktType=%" PRIu32 ".", phyHeader.packetType);
         return -E_FRAME_TYPE_NOT_SUPPORT;
     }
     inResult.SetFrameTypeInfo(frameType);
@@ -858,7 +866,7 @@ int ProtocolProto::ParseLabelExchange(const uint8_t *bytes, uint32_t length, Par
     auto fieldPtr = reinterpret_cast<const uint64_t *>(bytes + sizeof(CommPhyHeader));
     uint64_t version = NetToHost(*fieldPtr++);
     if (version != PROTOCOL_VERSION) {
-        LOGE("[Proto][ParseLabel] Version=%llu not support.", ULL(version));
+        LOGE("[Proto][ParseLabel] Version=%" PRIu64 " not support.", ULL(version));
         return -E_VERSION_NOT_SUPPORT;
     }
 
@@ -873,13 +881,13 @@ int ProtocolProto::ParseLabelExchange(const uint8_t *bytes, uint32_t length, Par
     inResult.SetLabelExchangeSequenceId(sequenceId);
     uint64_t commLabelCount = NetToHost(*fieldPtr++);
     if (length < commLabelCount || (UINT32_MAX / COMM_LABEL_LENGTH) < commLabelCount) {
-        LOGE("[Proto][ParseLabel] commLabelCount=%llu invalid.", ULL(commLabelCount));
+        LOGE("[Proto][ParseLabel] commLabelCount=%" PRIu64 " invalid.", ULL(commLabelCount));
         return -E_PARSE_FAIL;
     }
     // commLabelCount is expected to be not very large
     if (length < sizeof(CommPhyHeader) + LABEL_VER_LEN + DISTINCT_VALUE_LEN + SEQUENCE_ID_LEN + COMM_LABEL_COUNT_LEN +
         commLabelCount * COMM_LABEL_LENGTH) {
-        LOGE("[Proto][ParseLabel] Length of Bytes Error, commLabelCount=%llu", ULL(commLabelCount));
+        LOGE("[Proto][ParseLabel] Length of Bytes Error, commLabelCount=%" PRIu64, ULL(commLabelCount));
         return -E_LENGTH_ERROR;
     }
 
@@ -908,7 +916,7 @@ int ProtocolProto::ParseLabelExchangeAck(const uint8_t *bytes, uint32_t length,
     auto fieldPtr = reinterpret_cast<const uint64_t *>(bytes + sizeof(CommPhyHeader));
     uint64_t version = NetToHost(*fieldPtr++);
     if (version != PROTOCOL_VERSION) {
-        LOGE("[Proto][ParseLabelAck] Version=%llu not support.", ULL(version));
+        LOGE("[Proto][ParseLabelAck] Version=%" PRIu64 " not support.", ULL(version));
         return -E_VERSION_NOT_SUPPORT;
     }
 
@@ -947,7 +955,7 @@ int ProtocolProto::FrameFragmentation(const uint8_t *splitStartBytes, const Fram
         // Since exception is disabled, we have to check the vector size to assure that memory is truly allocated
         entry.first.resize(pieceTotalLen + fragmentInfo.extendHeadSize); // Note: should use resize other than reserve
         if (entry.first.size() != (pieceTotalLen + fragmentInfo.extendHeadSize)) {
-            LOGE("[Proto][FrameFrag] Resize failed for length=%u", pieceTotalLen);
+            LOGE("[Proto][FrameFrag] Resize failed for length=%" PRIu32, pieceTotalLen);
             return -E_OUT_OF_MEMORY;
         }
 
@@ -956,7 +964,7 @@ int ProtocolProto::FrameFragmentation(const uint8_t *splitStartBytes, const Fram
 
         // The sum value need to be recalculated, and the packet is fragmented.
         // The alignedFragLen is always larger than pieceFragLen
-        FillPhyHeaderLenInfo(pktPhyHeader, pieceTotalLen, 0, PACKET_TYPE_FRAGMENTED, alignedFragLen - pieceFragLen);
+        FillPhyHeaderLenInfo(pieceTotalLen, 0, PACKET_TYPE_FRAGMENTED, alignedFragLen - pieceFragLen, pktPhyHeader);
         HeaderConverter::ConvertHostToNet(pktPhyHeader, pktPhyHeader);
 
         CommPhyOptHeader pktPhyOptHeader = {static_cast<uint32_t>(fragmentInfo.splitLength + sizeof(CommPhyHeader)),
@@ -1081,7 +1089,6 @@ int ProtocolProto::FillExtendHeadDataIfNeed(std::shared_ptr<ExtendHeaderHandle>
             LOGI("[Proto][ToSerial] fill head data failed");
             return -E_FEEDBACK_COMMUNICATOR_NOT_FOUND;
         }
-        return E_OK;
     }
     return E_OK;
 }
diff --git a/frameworks/libs/distributeddb/communicator/src/protocol_proto.h b/frameworks/libs/distributeddb/communicator/src/protocol_proto.h
index 64ce126c1df57619749ab24e02457941731bc365..c5f7e0918c1703daf5207438a40dfce3934e231f 100644
--- a/frameworks/libs/distributeddb/communicator/src/protocol_proto.h
+++ b/frameworks/libs/distributeddb/communicator/src/protocol_proto.h
@@ -18,31 +18,31 @@
 
 #include <cstdint>
 #include <memory>
-#include "message.h"
+#include "communicator_type_define.h"
 #include "frame_header.h"
+#include "iprocess_communicator.h"
+#include "message.h"
+#include "message_transform.h"
 #include "parse_result.h"
 #include "serial_buffer.h"
-#include "message_transform.h"
-#include "communicator_type_define.h"
-#include "iprocess_communicator.h"
 
 namespace DistributedDB {
 struct PhyHeaderInfo {
-    uint64_t sourceId;
-    uint32_t frameId;
-    FrameType frameType;
+    uint64_t sourceId = 0u;
+    uint32_t frameId = 0u;
+    FrameType frameType = FrameType::EMPTY;
 };
 
 struct FrameFragmentInfo {
-    uint8_t *oringinalBytesAddr;
-    uint32_t extendHeadSize;
-    uint32_t splitLength;
-    uint16_t fragCount;
+    uint8_t *oringinalBytesAddr = nullptr;
+    uint32_t extendHeadSize = 0u;
+    uint32_t splitLength = 0u;
+    uint16_t fragCount = 0u;
 };
 
 struct FragmentPacket {
-    uint8_t *ptrPacket;
-    uint32_t leftLength;
+    uint8_t *ptrPacket = nullptr;
+    uint32_t leftLength = 0u;
 };
 
 class ProtocolProto {
@@ -55,8 +55,8 @@ public:
     static uint32_t GetCommLayerFrameHeaderLength();
 
     // For handling application layer message. Return a heap object.
-    static SerialBuffer *ToSerialBuffer(const Message *inMsg, int &outErrorNo,
-        std::shared_ptr<ExtendHeaderHandle> &extendHandle, bool onlyMsgHeader = false);
+    static SerialBuffer *ToSerialBuffer(const Message *inMsg,
+        std::shared_ptr<ExtendHeaderHandle> &extendHandle, bool onlyMsgHeader, int &outErrorNo);
     static Message *ToMessage(const SerialBuffer *inBuff, int &outErrorNo, bool onlyMsgHeader = false);
 
     // For handling communication layer frame. Return a heap object.
diff --git a/frameworks/libs/distributeddb/communicator/src/serial_buffer.cpp b/frameworks/libs/distributeddb/communicator/src/serial_buffer.cpp
index ae75a154a460acf8101e34ff8fee865944ee8871..1c2a423ff4e173b42b2b7d29732178bf887f220b 100644
--- a/frameworks/libs/distributeddb/communicator/src/serial_buffer.cpp
+++ b/frameworks/libs/distributeddb/communicator/src/serial_buffer.cpp
@@ -15,10 +15,10 @@
 
 #include "serial_buffer.h"
 #include <new>
-#include "securec.h"
-#include "db_errno.h"
 #include "communicator_type_define.h"
+#include "db_errno.h"
 #include "log_print.h"
+#include "securec.h"
 
 namespace DistributedDB {
 SerialBuffer::~SerialBuffer()
@@ -107,6 +107,10 @@ int SerialBuffer::SetExternalBuff(const uint8_t *buff, uint32_t inTotalLen, uint
 
 SerialBuffer *SerialBuffer::Clone(int &outErrorNo)
 {
+    if (totalLen_ == 0) {
+        outErrorNo = -E_INVALID_ARGS;
+        return nullptr;
+    }
     SerialBuffer *twinBuffer = new (std::nothrow) SerialBuffer();
     if (twinBuffer == nullptr) {
         outErrorNo = -E_OUT_OF_MEMORY;
@@ -144,6 +148,9 @@ SerialBuffer *SerialBuffer::Clone(int &outErrorNo)
 
 int SerialBuffer::ConvertForCrossThread()
 {
+    if (totalLen_ == 0) {
+        return -E_INVALID_ARGS;
+    }
     if (externalBytes_ == nullptr) {
         // No associated external stack memory. Do nothing and return E_OK.
         return E_OK;
diff --git a/frameworks/libs/distributeddb/include/query_expression.h b/frameworks/libs/distributeddb/include/query_expression.h
index 5c931d45035c94531737b748f026903a755734d6..2467ab6920d9a52b6ce523eedb849e18228bf367 100644
--- a/frameworks/libs/distributeddb/include/query_expression.h
+++ b/frameworks/libs/distributeddb/include/query_expression.h
@@ -16,10 +16,10 @@
 #ifndef DISTRIBUTEDDB_QUERY_EXPRESSION_H
 #define DISTRIBUTEDDB_QUERY_EXPRESSION_H
 
-#include <string>
-#include <vector>
 #include <list>
 #include <set>
+#include <string>
+#include <vector>
 
 #include "types_export.h"
 
diff --git a/frameworks/libs/distributeddb/interfaces/include/iprocess_communicator.h b/frameworks/libs/distributeddb/interfaces/include/iprocess_communicator.h
index 5abbd3069daf8782c99b85503198462c26fda049..e500a78fac0dce5e39f0ed6b8afde3d2d03ee1ed 100644
--- a/frameworks/libs/distributeddb/interfaces/include/iprocess_communicator.h
+++ b/frameworks/libs/distributeddb/interfaces/include/iprocess_communicator.h
@@ -16,11 +16,11 @@
 #ifndef IPROCESSCOMMUNICATOR_H
 #define IPROCESSCOMMUNICATOR_H
 
-#include <string>
-#include <vector>
 #include <cstdint>
 #include <functional>
 #include <memory>
+#include <string>
+#include <vector>
 #include "store_types.h"
 
 namespace DistributedDB {
@@ -53,9 +53,6 @@ public:
     // return not OK if fill data failed
     virtual DBStatus FillHeadData(uint8_t *data, uint32_t headSize, uint32_t totalLen)
     {
-        (void)data;
-        (void)headSize;
-        (void)totalLen;
         return OK;
     };
 };
@@ -148,7 +145,6 @@ public:
 
     virtual std::shared_ptr<ExtendHeaderHandle> GetExtendHeaderHandle(const ExtendInfo &paramInfo)
     {
-        (void)paramInfo;
         return nullptr;
     }
     // called after OnDataReceive
@@ -158,9 +154,6 @@ public:
     virtual DBStatus CheckAndGetDataHeadInfo(const uint8_t *data, uint32_t totalLen, uint32_t &headLength,
         std::vector<std::string> &userId)
     {
-        (void)data;
-        (void)totalLen;
-        (void)userId;
         headLength = 0;
         return OK;
     }
diff --git a/frameworks/libs/distributeddb/interfaces/include/kv_store_nb_delegate.h b/frameworks/libs/distributeddb/interfaces/include/kv_store_nb_delegate.h
index 845e962ed24766a4913d852e7fe6daf504be10d6..ef2bcda3938ef26bfa38a37143187c9428d57902 100644
--- a/frameworks/libs/distributeddb/interfaces/include/kv_store_nb_delegate.h
+++ b/frameworks/libs/distributeddb/interfaces/include/kv_store_nb_delegate.h
@@ -218,6 +218,14 @@ public:
 
     // Remove all other device data synced from other remote devices.
     DB_API virtual DBStatus RemoveDeviceData() = 0;
+
+    // Get keys from the public zone of this store by key prefix.
+    // If 'keyPrefix' is empty, It would return all the keys in the zone.
+    DB_API virtual DBStatus GetKeys(const Key &keyPrefix, std::vector<Key> &keys) const = 0;
+
+    // calculate full sync sync data size after Serialize;
+    // return 1M while sync data size is larger than 1M, otherwise return actualy size
+    DB_API virtual size_t GetSyncDataSize(const std::string &device) const = 0;
 };
 } // namespace DistributedDB
 
diff --git a/frameworks/libs/distributeddb/interfaces/include/relational/store_changed_data.h b/frameworks/libs/distributeddb/interfaces/include/store_changed_data.h
similarity index 100%
rename from frameworks/libs/distributeddb/interfaces/include/relational/store_changed_data.h
rename to frameworks/libs/distributeddb/interfaces/include/store_changed_data.h
diff --git a/frameworks/libs/distributeddb/interfaces/include/relational/store_observer.h b/frameworks/libs/distributeddb/interfaces/include/store_observer.h
similarity index 100%
rename from frameworks/libs/distributeddb/interfaces/include/relational/store_observer.h
rename to frameworks/libs/distributeddb/interfaces/include/store_observer.h
diff --git a/frameworks/libs/distributeddb/interfaces/src/kv_store_nb_delegate_impl.cpp b/frameworks/libs/distributeddb/interfaces/src/kv_store_nb_delegate_impl.cpp
index be2763d792ea49a4c603ac7f538c057a0f2dbcbe..1d361fe792e781a079c6f2c53f21bbb7e89d52b7 100644
--- a/frameworks/libs/distributeddb/interfaces/src/kv_store_nb_delegate_impl.cpp
+++ b/frameworks/libs/distributeddb/interfaces/src/kv_store_nb_delegate_impl.cpp
@@ -834,14 +834,9 @@ DBStatus KvStoreNbDelegateImpl::DeleteInner(const IOption &option, const Key &ke
 void KvStoreNbDelegateImpl::OnSyncComplete(const std::map<std::string, int> &statuses,
     const std::function<void(const std::map<std::string, DBStatus> &devicesMap)> &onComplete) const
 {
-    const auto &statusMap = SyncOperation::DBStatusTransMap();
     std::map<std::string, DBStatus> result;
     for (const auto &pair : statuses) {
-        DBStatus status = DB_ERROR;
-        auto iter = statusMap.find(pair.second);
-        if (iter != statusMap.end()) {
-            status = iter->second;
-        }
+        DBStatus status = SyncOperation::DBStatusTrans(pair.second);
         result.insert(std::pair<std::string, DBStatus>(pair.first, status));
     }
     if (onComplete) {
@@ -944,4 +939,39 @@ DBStatus KvStoreNbDelegateImpl::RemoveDeviceData()
     }
     return TransferDBErrno(errCode);
 }
+
+DBStatus KvStoreNbDelegateImpl::GetKeys(const Key &keyPrefix, std::vector<Key> &keys) const
+{
+    if (conn_ == nullptr) {
+        LOGE("%s", INVALID_CONNECTION.c_str());
+        return DB_ERROR;
+    }
+    IOption option;
+    option.dataType = IOption::SYNC_DATA;
+    int errCode = conn_->GetKeys(option, keyPrefix, keys);
+    if (errCode == E_OK) {
+        return OK;
+    }
+    LOGW("[KvStoreNbDelegate] Get the keys failed:%d", errCode);
+    return TransferDBErrno(errCode);
+}
+
+size_t KvStoreNbDelegateImpl::GetSyncDataSize(const std::string &device) const
+{
+    if (conn_ == nullptr) {
+        LOGE("%s", INVALID_CONNECTION.c_str());
+        return 0;
+    }
+    if (device.empty()) {
+        LOGE("device len is invalid");
+        return 0;
+    }
+    size_t size = 0;
+    int errCode = conn_->GetSyncDataSize(device, size);
+    if (errCode != E_OK) {
+        LOGE("[KvStoreNbDelegate] calculate sync data size failed : %d", errCode);
+        return 0;
+    }
+    return size;
+}
 } // namespace DistributedDB
diff --git a/frameworks/libs/distributeddb/interfaces/src/kv_store_nb_delegate_impl.h b/frameworks/libs/distributeddb/interfaces/src/kv_store_nb_delegate_impl.h
index 18f11c5b3c5d91a6732e88035cca297bc0addaae..de5813b0964570c998065ebad8fc5f4b5bbc0d6e 100644
--- a/frameworks/libs/distributeddb/interfaces/src/kv_store_nb_delegate_impl.h
+++ b/frameworks/libs/distributeddb/interfaces/src/kv_store_nb_delegate_impl.h
@@ -152,6 +152,10 @@ public:
 
     DBStatus RemoveDeviceData() override;
 
+    DBStatus GetKeys(const Key &keyPrefix, std::vector<Key> &keys) const override;
+
+    size_t GetSyncDataSize(const std::string &device) const override;
+
 private:
     DBStatus GetInner(const IOption &option, const Key &key, Value &value) const;
     DBStatus PutInner(const IOption &option, const Key &key, const Value &value);
diff --git a/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_changed_data_impl.cpp b/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_changed_data_impl.cpp
index 4afb818b65682b691c7c5cfaa9f48ce5a2d3ba42..3fcba237f70e6fbff8caa2281aa22f1307734f32 100644
--- a/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_changed_data_impl.cpp
+++ b/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_changed_data_impl.cpp
@@ -23,7 +23,6 @@ RelationalStoreChangedDataImpl::~RelationalStoreChangedDataImpl()
 DB_API std::string RelationalStoreChangedDataImpl::GetDataChangeDevice() const
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    // add get changedDevice_ code;
     return changedDevice_;
 }
 
diff --git a/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_delegate_impl.cpp b/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_delegate_impl.cpp
index 216472e0aee3c61d6dd74937450c586da95b6fc3..e5d4c2142a294dddacac1dead6c4b5d12ffbd6de 100644
--- a/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_delegate_impl.cpp
+++ b/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_delegate_impl.cpp
@@ -131,17 +131,12 @@ void RelationalStoreDelegateImpl::SetReleaseFlag(bool flag)
 void RelationalStoreDelegateImpl::OnSyncComplete(const std::map<std::string, std::vector<TableStatus>> &devicesStatus,
     SyncStatusCallback &onComplete)
 {
-    const auto &statusMap = SyncOperation::DBStatusTransMap();
     std::map<std::string, std::vector<TableStatus>> res;
     for (const auto &[device, tablesStatus] : devicesStatus) {
         for (const auto &tableStatus : tablesStatus) {
             TableStatus table;
             table.tableName = tableStatus.tableName;
-            DBStatus status = DB_ERROR;
-            auto iterator = statusMap.find(tableStatus.status);
-            if (iterator != statusMap.end()) {
-                status = iterator->second;
-            }
+            DBStatus status = SyncOperation::DBStatusTrans(tableStatus.status);
             table.status = status;
             res[device].push_back(table);
         }
diff --git a/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_manager.cpp b/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_manager.cpp
index a7f29274377cdefbdf1cd1ce1df2265f70491beb..84ca3ba52802bd3c2105709ddab5e5f3296c397d 100644
--- a/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_manager.cpp
+++ b/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_manager.cpp
@@ -100,9 +100,11 @@ DB_API DBStatus RelationalStoreManager::OpenStore(const std::string &path, const
         conn->Close();
         return DB_ERROR;
     }
-    conn->RegisterObserverAction([option, storeId, this](const std::string &changedDevice) {
+    const std::string userId = userId_;
+    const std::string appId = appId_;
+    conn->RegisterObserverAction([option, storeId, userId, appId](const std::string &changedDevice) {
         RelationalStoreChangedDataImpl data(changedDevice);
-        data.SetStoreProperty({userId_, appId_, storeId});
+        data.SetStoreProperty({userId, appId, storeId});
         if (option.observer) {
             LOGD("begin to observer on changed, changedDevice=%s", STR_MASK(changedDevice));
             option.observer->OnChange(data);
diff --git a/frameworks/libs/distributeddb/interfaces/src/relational/relational_sync_able_storage.h b/frameworks/libs/distributeddb/interfaces/src/relational/relational_sync_able_storage.h
index 82968e5e3c4635ef5d7e8dffbde75a19d0b1e5c4..9d0d0fd979d16fbce85504ea0e08f4feea2b6a22 100644
--- a/frameworks/libs/distributeddb/interfaces/src/relational/relational_sync_able_storage.h
+++ b/frameworks/libs/distributeddb/interfaces/src/relational/relational_sync_able_storage.h
@@ -27,7 +27,7 @@ namespace DistributedDB {
 using RelationalObserverAction = std::function<void(const std::string &device)>;
 class RelationalSyncAbleStorage : public RelationalDBSyncInterface, public virtual RefObject {
 public:
-    explicit RelationalSyncAbleStorage(StorageEngine *engine);
+    explicit RelationalSyncAbleStorage(std::shared_ptr<SQLiteSingleRelationalStorageEngine> engine);
     ~RelationalSyncAbleStorage() override;
 
     // Get interface type of this kvdb.
@@ -143,7 +143,7 @@ private:
     int SaveSyncDataItems(const QueryObject &object, std::vector<DataItem> &dataItems, const std::string &deviceName);
 
     // data
-    SQLiteSingleRelationalStorageEngine *storageEngine_ = nullptr;
+    std::shared_ptr<SQLiteSingleRelationalStorageEngine> storageEngine_ = nullptr;
     std::function<void()> onSchemaChanged_;
     mutable std::mutex onSchemaChangedMutex_;
     std::mutex dataChangeDeviceMutex_;
diff --git a/frameworks/libs/distributeddb/storage/include/ikvdb_connection.h b/frameworks/libs/distributeddb/storage/include/ikvdb_connection.h
index b051f95bd2a3972fc9e657a8f6ff606e7be97d4d..8cfebe8f0402977c7f02edb0a5536968de4350d0 100644
--- a/frameworks/libs/distributeddb/storage/include/ikvdb_connection.h
+++ b/frameworks/libs/distributeddb/storage/include/ikvdb_connection.h
@@ -127,6 +127,10 @@ public:
     virtual int GetSecurityOption(int &securityLabel, int &securityFlag) const = 0;
 
     virtual int CheckIntegrity() const = 0;
+
+    virtual int GetKeys(const IOption &option, const Key &keyPrefix, std::vector<Key> &keys) const = 0;
+
+    virtual int GetSyncDataSize(const std::string &device, size_t &size) const = 0;
 };
 } // namespace DistributedDB
 
diff --git a/frameworks/libs/distributeddb/storage/include/single_ver_kvdb_sync_interface.h b/frameworks/libs/distributeddb/storage/include/single_ver_kvdb_sync_interface.h
index dc9cdf29894a96c0a8c05bb66455b7df3518b1f2..17da22c3edfbfebd87149833a8c6251a96c9b51b 100644
--- a/frameworks/libs/distributeddb/storage/include/single_ver_kvdb_sync_interface.h
+++ b/frameworks/libs/distributeddb/storage/include/single_ver_kvdb_sync_interface.h
@@ -24,8 +24,6 @@
 
 namespace DistributedDB {
 using MulDevTimeRanges = std::map<DeviceID, std::pair<Timestamp, Timestamp>>;
-using MulDevSinVerKvEntry = std::map<DeviceID, std::vector<SingleVerKvEntry *>>;
-using MulDevDataItems = std::map<DeviceID, std::vector<DataItem>>;
 
 class SingleVerKvDBSyncInterface : public IKvDBSyncInterface {
 public:
diff --git a/frameworks/libs/distributeddb/storage/src/data_transformer.cpp b/frameworks/libs/distributeddb/storage/src/data_transformer.cpp
index 264609c8ca53d4a8a6a8e6c94866326e0281f9cd..29249103f8dde80701929f967f880549b3cc26ea 100644
--- a/frameworks/libs/distributeddb/storage/src/data_transformer.cpp
+++ b/frameworks/libs/distributeddb/storage/src/data_transformer.cpp
@@ -99,13 +99,15 @@ int DataTransformer::DeSerializeDataItem(const DataItem &dataItem, OptRowDataWit
 
 uint32_t DataTransformer::CalDataValueLength(const DataValue &dataValue)
 {
-    static std::map<StorageType, uint32_t> lengthMap = {
-        { StorageType::STORAGE_TYPE_NULL, Parcel::GetUInt32Len()},
-        { StorageType::STORAGE_TYPE_INTEGER, Parcel::GetInt64Len()},
-        { StorageType::STORAGE_TYPE_REAL, Parcel::GetDoubleLen()}
-    };
-    if (lengthMap.find(dataValue.GetType()) != lengthMap.end()) {
-        return lengthMap[dataValue.GetType()];
+    switch (dataValue.GetType()) {
+        case StorageType::STORAGE_TYPE_NULL:
+            return Parcel::GetUInt32Len();
+        case StorageType::STORAGE_TYPE_INTEGER:
+            return Parcel::GetInt64Len();
+        case StorageType::STORAGE_TYPE_REAL:
+            return Parcel::GetDoubleLen();
+        default:
+            break;
     }
     if (dataValue.GetType() != StorageType::STORAGE_TYPE_BLOB &&
         dataValue.GetType() != StorageType::STORAGE_TYPE_TEXT) {
diff --git a/frameworks/libs/distributeddb/storage/src/generic_kvdb_connection.cpp b/frameworks/libs/distributeddb/storage/src/generic_kvdb_connection.cpp
index 464d9850aec86cacb01de5ac0d122bb3a17c8d9d..ed23d3087bde94d3144e63b795e8df1b1014954e 100644
--- a/frameworks/libs/distributeddb/storage/src/generic_kvdb_connection.cpp
+++ b/frameworks/libs/distributeddb/storage/src/generic_kvdb_connection.cpp
@@ -346,4 +346,14 @@ int GenericKvDBConnection::CheckIntegrity() const
 {
     return E_OK;
 }
+
+int GenericKvDBConnection::GetKeys(const IOption &option, const Key &keyPrefix, std::vector<Key> &keys) const
+{
+    return -E_NOT_SUPPORT;
+}
+
+int GenericKvDBConnection::GetSyncDataSize(const std::string &device, size_t &size) const
+{
+    return -E_NOT_SUPPORT;
+}
 }
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/storage/src/generic_kvdb_connection.h b/frameworks/libs/distributeddb/storage/src/generic_kvdb_connection.h
index e5e2378e1683cdf0f7a924d60f6d5a41043d2d51..d99aa4d6d42bd741dd246bc3a7a639fc90ac38e4 100644
--- a/frameworks/libs/distributeddb/storage/src/generic_kvdb_connection.h
+++ b/frameworks/libs/distributeddb/storage/src/generic_kvdb_connection.h
@@ -74,6 +74,10 @@ public:
     int GetSecurityOption(int &securityLabel, int &securityFlag) const override;
 
     int CheckIntegrity() const override;
+
+    int GetKeys(const IOption &option, const Key &keyPrefix, std::vector<Key> &keys) const override;
+
+    int GetSyncDataSize(const std::string &device, size_t &size) const override;
 protected:
     // Get the stashed 'KvDB_ pointer' without ref.
     template<typename DerivedDBType>
diff --git a/frameworks/libs/distributeddb/storage/src/generic_single_ver_kv_entry.cpp b/frameworks/libs/distributeddb/storage/src/generic_single_ver_kv_entry.cpp
index 48ec008934e0b6a9a5f4e67b87ccf0817d1bd0e7..66b243c5c4d31daf72dc1df5a6dc9e355cef58ad 100644
--- a/frameworks/libs/distributeddb/storage/src/generic_single_ver_kv_entry.cpp
+++ b/frameworks/libs/distributeddb/storage/src/generic_single_ver_kv_entry.cpp
@@ -131,6 +131,9 @@ int GenericSingleVerKvEntry::SerializeDatas(const std::vector<SingleVerKvEntry *
         return errCode;
     }
     parcel.EightByteAlign();
+    if (parcel.IsError()) {
+        return -E_PARSE_FAIL;
+    }
     for (const auto &kvEntry : kvEntries) {
         if (kvEntry == nullptr) {
             continue;
@@ -193,26 +196,27 @@ int GenericSingleVerKvEntry::DeSerializeDatas(std::vector<SingleVerKvEntry *> &k
     uint32_t size = 0;
     uint64_t len = parcel.ReadUInt32(size);
     if (size > DBConstant::MAX_NORMAL_PACK_ITEM_SIZE) {
-        len = 0;
-    } else {
-        parcel.EightByteAlign();
-        len = BYTE_8_ALIGN(len);
-        for (uint32_t i = 0; i < size; i++) {
-            auto kvEntry = new (std::nothrow) GenericSingleVerKvEntry();
-            if (kvEntry == nullptr) {
-                LOGE("Create kvEntry failed.");
-                len = 0;
-                break;
-            }
-            len += kvEntry->DeSerializeData(parcel);
-            kvEntries.push_back(kvEntry);
-            if (len > INT32_MAX || parcel.IsError()) {
-                len = 0;
-                break;
-            }
+        return 0;
+    }
+    parcel.EightByteAlign();
+    if (parcel.IsError()) {
+        return 0;
+    }
+    len = BYTE_8_ALIGN(len);
+    for (uint32_t i = 0; i < size; i++) {
+        auto kvEntry = new (std::nothrow) GenericSingleVerKvEntry();
+        if (kvEntry == nullptr) {
+            LOGE("Create kvEntry failed.");
+            len = 0;
+            break;
+        }
+        len += kvEntry->DeSerializeData(parcel);
+        kvEntries.push_back(kvEntry);
+        if (len > INT32_MAX || parcel.IsError()) {
+            len = 0;
+            break;
         }
     }
-
     if (len == 0) {
         for (auto &kvEntry : kvEntries) {
             delete kvEntry;
diff --git a/frameworks/libs/distributeddb/storage/src/kvdb_manager.cpp b/frameworks/libs/distributeddb/storage/src/kvdb_manager.cpp
index 4c7c46867f02d20d86008471a3726ae89ff4eb67..52f6e76b7cb2c3e99b17d4ce0557c654428df5ae 100644
--- a/frameworks/libs/distributeddb/storage/src/kvdb_manager.cpp
+++ b/frameworks/libs/distributeddb/storage/src/kvdb_manager.cpp
@@ -238,13 +238,13 @@ int KvDBManager::UnlockDB(const KvDBProperties &kvDBProp)
         return E_OK;
     }
     int errCode = OS::FileUnlock(locks_[identifierDir]);
-    LOGI("DB unlocked! errCode = [%d]", errCode);
     if (errCode != E_OK) {
+        LOGE("DB unlocked! errCode = [%d]", errCode);
         return errCode;
     }
     errCode = OS::CloseFile(locks_[identifierDir]);
-    LOGI("DB closed! errCode = [%d]", errCode);
     if (errCode != E_OK) {
+        LOGE("DB closed! errCode = [%d]", errCode);
         return errCode;
     }
     locks_.erase(identifierDir);
diff --git a/frameworks/libs/distributeddb/storage/src/multiver/multi_ver_commit.cpp b/frameworks/libs/distributeddb/storage/src/multiver/multi_ver_commit.cpp
index 56e4c35e320346c0a951be98cbae7c2a61e3a28f..00b98f7838dd877034feab723855334b1d4f1573 100644
--- a/frameworks/libs/distributeddb/storage/src/multiver/multi_ver_commit.cpp
+++ b/frameworks/libs/distributeddb/storage/src/multiver/multi_ver_commit.cpp
@@ -106,7 +106,7 @@ void MultiVerCommit::SetDeviceInfo(const DeviceID &deviceInfo)
 
 bool MultiVerCommit::CheckCommit() const
 {
-    if (commitID_.size() == 0 || commitID_.size() > MAX_COMMIT_ID_LENGTH ||
+    if (commitID_.empty() || commitID_.size() > MAX_COMMIT_ID_LENGTH ||
         leftParentID_.size() > MAX_COMMIT_ID_LENGTH || rightParentID_.size() > MAX_COMMIT_ID_LENGTH ||
         deviceInfo_.size() > MAX_COMMIT_DEV_LENGTH) {
         LOGE("Check commit failed! Error length of commit ID.");
diff --git a/frameworks/libs/distributeddb/storage/src/relational_row_data_impl.cpp b/frameworks/libs/distributeddb/storage/src/relational_row_data_impl.cpp
index 9dc0de73c3ab7ee080ae5cf832e01330f3b42822..2c3edf050b4e400483bf5e8076dc0200a6c32d10 100644
--- a/frameworks/libs/distributeddb/storage/src/relational_row_data_impl.cpp
+++ b/frameworks/libs/distributeddb/storage/src/relational_row_data_impl.cpp
@@ -43,6 +43,9 @@ int RelationalRowDataImpl::Serialize(Parcel &parcel) const
         }
     }
     parcel.EightByteAlign();
+    if (parcel.IsError()) {
+        return -E_PARSE_FAIL;
+    }
     return E_OK;
 }
 
@@ -62,6 +65,9 @@ int RelationalRowDataImpl::DeSerialize(Parcel &parcel)
         data_.emplace_back(std::move(value));
     }
     parcel.EightByteAlign();
+    if (parcel.IsError()) {
+        return -E_PARSE_FAIL;
+    }
     return E_OK;
 }
 
diff --git a/frameworks/libs/distributeddb/storage/src/relational_sync_able_storage.cpp b/frameworks/libs/distributeddb/storage/src/relational_sync_able_storage.cpp
index c9b5f3eb1844387508c9433e3f40f13751ab2b5c..c2b487ae86ee670ba57c5b5e7d010febd02ab889 100644
--- a/frameworks/libs/distributeddb/storage/src/relational_sync_able_storage.cpp
+++ b/frameworks/libs/distributeddb/storage/src/relational_sync_able_storage.cpp
@@ -15,6 +15,8 @@
 #ifdef RELATIONAL_STORE
 #include "relational_sync_able_storage.h"
 
+#include <utility>
+
 #include "data_compression.h"
 #include "db_common.h"
 #include "db_dfx_adapter.h"
@@ -42,8 +44,8 @@ void TriggerCloseAutoLaunchConn(const RelationalDBProperties &properties)
     } \
 } while (0)
 
-RelationalSyncAbleStorage::RelationalSyncAbleStorage(StorageEngine *engine)
-    : storageEngine_(static_cast<SQLiteSingleRelationalStorageEngine *>(engine)),
+RelationalSyncAbleStorage::RelationalSyncAbleStorage(std::shared_ptr<SQLiteSingleRelationalStorageEngine> engine)
+    : storageEngine_(std::move(engine)),
       isCachedOption_(false)
 {}
 
@@ -94,7 +96,7 @@ void RelationalSyncAbleStorage::GetMaxTimestamp(Timestamp &timestamp) const
         return;
     }
     timestamp = 0;
-    errCode = handle->GetMaxTimestamp(storageEngine_->GetSchemaRef().GetTableNames(), timestamp);
+    errCode = handle->GetMaxTimestamp(storageEngine_->GetSchema().GetTableNames(), timestamp);
     if (errCode != E_OK) {
         LOGE("GetMaxTimestamp failed, errCode:%d", errCode);
         TriggerCloseAutoLaunchConn(storageEngine_->GetProperties());
@@ -346,7 +348,7 @@ int RelationalSyncAbleStorage::GetSyncDataForQuerySync(std::vector<DataItem> &da
             dataSizeInfo,
             std::bind(&SQLiteSingleVerRelationalContinueToken::GetStatement, *token,
                 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4),
-            storageEngine_->GetSchemaRef().GetTable(token->GetQuery().GetTableName()));
+            storageEngine_->GetSchema().GetTable(token->GetQuery().GetTableName()));
         if (errCode == -E_FINISHED) {
             token->FinishGetData();
             errCode = token->IsGetAllDataFinished() ? E_OK : -E_UNFINISHED;
@@ -371,7 +373,7 @@ int RelationalSyncAbleStorage::GetSyncData(QueryObject &query, const SyncTimeRan
     if (!timeRange.IsValid()) {
         return -E_INVALID_ARGS;
     }
-    query.SetSchema(storageEngine_->GetSchemaRef());
+    query.SetSchema(storageEngine_->GetSchema());
     auto token = new (std::nothrow) SQLiteSingleVerRelationalContinueToken(timeRange, query);
     if (token == nullptr) {
         LOGE("[SingleVerNStore] Allocate continue token failed.");
@@ -389,7 +391,8 @@ int RelationalSyncAbleStorage::GetSyncDataNext(std::vector<SingleVerKvEntry *> &
     if (!token->CheckValid()) {
         return -E_INVALID_ARGS;
     }
-    const auto fieldInfos = storageEngine_->GetSchemaRef().GetTable(token->GetQuery().GetTableName()).GetFieldInfos();
+    RelationalSchemaObject schema = storageEngine_->GetSchema();
+    const auto fieldInfos = schema.GetTable(token->GetQuery().GetTableName()).GetFieldInfos();
     std::vector<std::string> fieldNames;
     for (const auto &fieldInfo : fieldInfos) {
         fieldNames.push_back(fieldInfo.GetFieldName());
@@ -443,7 +446,7 @@ int RelationalSyncAbleStorage::PutSyncDataWithQuery(const QueryObject &object,
 }
 
 namespace {
-inline bool IsCollaborationMode(const SQLiteSingleRelationalStorageEngine *engine)
+inline bool IsCollaborationMode(const std::shared_ptr<SQLiteSingleRelationalStorageEngine> &engine)
 {
     return engine->GetProperties().GetIntProp(RelationalDBProperties::DISTRIBUTED_TABLE_MODE,
         DistributedTableMode::SPLIT_BY_DEVICE) == DistributedTableMode::COLLABORATION;
@@ -460,9 +463,9 @@ int RelationalSyncAbleStorage::SaveSyncDataItems(const QueryObject &object, std:
         return errCode;
     }
     QueryObject query = object;
-    query.SetSchema(storageEngine_->GetSchemaRef());
+    query.SetSchema(storageEngine_->GetSchema());
 
-    TableInfo table = storageEngine_->GetSchemaRef().GetTable(object.GetTableName());
+    TableInfo table = storageEngine_->GetSchema().GetTable(object.GetTableName());
     if (!IsCollaborationMode(storageEngine_)) {
         // Set table name for SPLIT_BY_DEVICE mode
         table.SetTableName(DBCommon::GetDistributedTableName(deviceName, object.GetTableName()));
@@ -506,7 +509,7 @@ int RelationalSyncAbleStorage::RemoveDeviceData(const std::string &deviceName, b
 
 RelationalSchemaObject RelationalSyncAbleStorage::GetSchemaInfo() const
 {
-    return storageEngine_->GetSchemaRef();
+    return storageEngine_->GetSchema();
 }
 
 int RelationalSyncAbleStorage::GetSecurityOption(SecurityOption &option) const
@@ -588,7 +591,7 @@ int RelationalSyncAbleStorage::CreateDistributedDeviceTable(const std::string &d
             continue;
         }
 
-        errCode = handle->CreateDistributedDeviceTable(device, storageEngine_->GetSchemaRef().GetTable(table));
+        errCode = handle->CreateDistributedDeviceTable(device, storageEngine_->GetSchema().GetTable(table));
         if (errCode != E_OK) {
             LOGE("Create distributed device table failed. %d", errCode);
             break;
@@ -663,7 +666,7 @@ void RelationalSyncAbleStorage::RegisterHeartBeatListener(const std::function<vo
 
 int RelationalSyncAbleStorage::CheckAndInitQueryCondition(QueryObject &query) const
 {
-    RelationalSchemaObject schema = storageEngine_->GetSchemaRef();
+    RelationalSchemaObject schema = storageEngine_->GetSchema();
     TableInfo table = schema.GetTable(query.GetTableName());
     if (table.GetTableName() != query.GetTableName()) {
         LOGE("Query table is not a distributed table.");
@@ -696,7 +699,7 @@ bool RelationalSyncAbleStorage::CheckCompatible(const std::string &schema, uint8
 int RelationalSyncAbleStorage::GetRemoteQueryData(const PreparedStmt &prepStmt, size_t packetSize,
     std::vector<std::string> &colNames, std::vector<RelationalRowData *> &data) const
 {
-    if (IsCollaborationMode(storageEngine_) || !storageEngine_->GetSchemaRef().IsSchemaValid()) {
+    if (IsCollaborationMode(storageEngine_) || !storageEngine_->GetSchema().IsSchemaValid()) {
         return -E_NOT_SUPPORT;
     }
     if (prepStmt.GetOpCode() != PreparedStmt::ExecutorOperation::QUERY || !prepStmt.IsValid()) {
diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/collaboration_log_table_manager.cpp b/frameworks/libs/distributeddb/storage/src/sqlite/collaboration_log_table_manager.cpp
index 09beed32c883839e4f4f5248dea232dbb31cea7f..f959d47c74771686f233358e0224cc97960bffde 100644
--- a/frameworks/libs/distributeddb/storage/src/sqlite/collaboration_log_table_manager.cpp
+++ b/frameworks/libs/distributeddb/storage/src/sqlite/collaboration_log_table_manager.cpp
@@ -30,11 +30,11 @@ std::string CollaborationLogTableManager::CalcPrimaryKeyHash(const std::string &
         sql = "calc_hash('" + identity + "'||calc_hash(" + references + "rowid))";
     } else {
         if (table.GetIdentifyKey().size() == 1) {
-            sql = "calc_hash(" + references + table.GetIdentifyKey().at(0) + ")";
+            sql = "calc_hash(" + references + "'" + table.GetIdentifyKey().at(0) + "')";
         } else {
             sql = "calc_hash(";
             for (const auto &it : table.GetIdentifyKey()) {
-                sql += "calc_hash(" + references + it + ")||";
+                sql += "calc_hash(" + references + "'" + it + "')||";
             }
             sql.pop_back();
             sql.pop_back();
@@ -49,7 +49,7 @@ std::string CollaborationLogTableManager::GetInsertTrigger(const TableInfo &tabl
     std::string logTblName = DBConstant::RELATIONAL_PREFIX + table.GetTableName() + "_log";
     std::string insertTrigger = "CREATE TRIGGER IF NOT EXISTS ";
     insertTrigger += "naturalbase_rdb_" + table.GetTableName() + "_ON_INSERT AFTER INSERT \n";
-    insertTrigger += "ON " + table.GetTableName() + "\n";
+    insertTrigger += "ON '" + table.GetTableName() + "'\n";
     insertTrigger += "WHEN (SELECT count(*) from " + DBConstant::RELATIONAL_PREFIX + "metadata ";
     insertTrigger += "WHERE key = 'log_trigger_switch' AND value = 'true')\n";
     insertTrigger += "BEGIN\n";
@@ -69,7 +69,7 @@ std::string CollaborationLogTableManager::GetUpdateTrigger(const TableInfo &tabl
     std::string logTblName = DBConstant::RELATIONAL_PREFIX + table.GetTableName() + "_log";
     std::string updateTrigger = "CREATE TRIGGER IF NOT EXISTS ";
     updateTrigger += "naturalbase_rdb_" + table.GetTableName() + "_ON_UPDATE AFTER UPDATE \n";
-    updateTrigger += "ON " + table.GetTableName() + "\n";
+    updateTrigger += "ON '" + table.GetTableName() + "'\n";
     updateTrigger += "WHEN (SELECT count(*) from " + DBConstant::RELATIONAL_PREFIX + "metadata ";
     updateTrigger += "WHERE key = 'log_trigger_switch' AND value = 'true')\n";
     updateTrigger += "BEGIN\n";
@@ -95,7 +95,7 @@ std::string CollaborationLogTableManager::GetDeleteTrigger(const TableInfo &tabl
     (void)identity;
     std::string deleteTrigger = "CREATE TRIGGER IF NOT EXISTS ";
     deleteTrigger += "naturalbase_rdb_" + table.GetTableName() + "_ON_DELETE BEFORE DELETE \n";
-    deleteTrigger += "ON " + table.GetTableName() + "\n";
+    deleteTrigger += "ON '" + table.GetTableName() + "'\n";
     deleteTrigger += "WHEN (SELECT count(*) from " + DBConstant::RELATIONAL_PREFIX + "metadata ";
     deleteTrigger += "WHERE key = 'log_trigger_switch' AND VALUE = 'true')\n";
     deleteTrigger += "BEGIN\n";
diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/query_sync_object.cpp b/frameworks/libs/distributeddb/storage/src/sqlite/query_sync_object.cpp
index c42d8c42218b9cd2929a30d0adee372cba9b03d5..35e9ba6e0ce7702dce76a030e6ba3f0945aac6dd 100644
--- a/frameworks/libs/distributeddb/storage/src/sqlite/query_sync_object.cpp
+++ b/frameworks/libs/distributeddb/storage/src/sqlite/query_sync_object.cpp
@@ -198,9 +198,10 @@ int QuerySyncObject::SerializeData(Parcel &parcel, uint32_t softWareVersion)
     (void)parcel.WriteVectorChar(context.prefixKey);
     (void)parcel.WriteString(context.suggestIndex);
     (void)parcel.WriteUInt32(context.queryObjNodes.size());
-
     parcel.EightByteAlign();
-
+    if (parcel.IsError()) {
+        return -E_INVALID_ARGS;
+    }
     for (const QueryObjNode &node : context.queryObjNodes) {
         errCode = SerializeDataObjNode(parcel, node);
         if (errCode != E_OK) {
@@ -219,11 +220,10 @@ int QuerySyncObject::SerializeData(Parcel &parcel, uint32_t softWareVersion)
             (void)parcel.WriteVectorChar(key);
         }
     }  // QUERY_SYNC_OBJECT_VERSION_1 end.
-
+    parcel.EightByteAlign();
     if (parcel.IsError()) { // parcel almost success
         return -E_INVALID_ARGS;
     }
-    parcel.EightByteAlign();
     return E_OK;
 }
 
@@ -271,10 +271,10 @@ int QuerySyncObject::DeSerializeData(Parcel &parcel, QuerySyncObject &queryObj)
 
     uint32_t nodesSize = 0;
     (void)parcel.ReadUInt32(nodesSize);
+    parcel.EightByteAlign();
     if (parcel.IsError()) { // almost success
         return -E_INVALID_ARGS;
     }
-    parcel.EightByteAlign();
     for (size_t i = 0; i < nodesSize; i++) {
         QueryObjNode node;
         int errCode = DeSerializeDataObjNode(parcel, node);
diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_store.cpp b/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_store.cpp
index 5ce33573053937ae44f0bd4974863ac51a84aa2f..cbd1996c62aa899a08e428f71832bf7a5f91b49f 100644
--- a/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_store.cpp
+++ b/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_store.cpp
@@ -32,7 +32,6 @@ namespace {
 
 SQLiteRelationalStore::~SQLiteRelationalStore()
 {
-    delete sqliteStorageEngine_;
     sqliteStorageEngine_ = nullptr;
 }
 
@@ -87,7 +86,7 @@ void SQLiteRelationalStore::ReleaseResources()
 {
     if (sqliteStorageEngine_ != nullptr) {
         sqliteStorageEngine_->ClearEnginePasswd();
-        (void)StorageEngineManager::ReleaseStorageEngine(sqliteStorageEngine_);
+        sqliteStorageEngine_ = nullptr;
     }
     RefObject::DecObjRef(storageEngine_);
 }
@@ -194,7 +193,7 @@ int SQLiteRelationalStore::SaveSchemaToMeta()
     Key schemaKey;
     DBCommon::StringToVector(DBConstant::RELATIONAL_SCHEMA_KEY, schemaKey);
     Value schemaVal;
-    DBCommon::StringToVector(sqliteStorageEngine_->GetSchemaRef().ToSchemaString(), schemaVal);
+    DBCommon::StringToVector(sqliteStorageEngine_->GetSchema().ToSchemaString(), schemaVal);
     int errCode = storageEngine_->PutMetaData(schemaKey, schemaVal);
     if (errCode != E_OK) {
         LOGE("Save relational schema to meta table failed. %d", errCode);
@@ -255,7 +254,7 @@ int SQLiteRelationalStore::Open(const RelationalDBProperties &properties)
         return E_OK;
     }
 
-    sqliteStorageEngine_ = new (std::nothrow) SQLiteSingleRelationalStorageEngine(properties);
+    sqliteStorageEngine_ = std::make_shared<SQLiteSingleRelationalStorageEngine>(properties);
     if (sqliteStorageEngine_ == nullptr) {
         LOGE("[RelationalStore][Open] Create storage engine failed");
         return -E_OUT_OF_MEMORY;
@@ -370,9 +369,16 @@ void SQLiteRelationalStore::DecreaseConnectionCounter()
     syncAbleEngine_->Close();
 
     if (sqliteStorageEngine_ != nullptr) {
-        delete sqliteStorageEngine_;
         sqliteStorageEngine_ = nullptr;
     }
+    {
+        if (storageEngine_ != nullptr) {
+            storageEngine_->RegisterHeartBeatListener(nullptr);
+        }
+        std::lock_guard<std::mutex> lock(lifeCycleMutex_);
+        StopLifeCycleTimer();
+        lifeCycleNotifier_ = nullptr;
+    }
     // close will dec sync ref of storageEngine_
     DecObjRef(storageEngine_);
 }
@@ -435,7 +441,7 @@ int SQLiteRelationalStore::RemoveDeviceData(const std::string &device, const std
         return -E_NOT_SUPPORT;
     }
 
-    std::map<std::string, TableInfo> tables = sqliteStorageEngine_->GetSchemaRef().GetTables();
+    std::map<std::string, TableInfo> tables = sqliteStorageEngine_->GetSchema().GetTables();
     if (!tableName.empty() && tables.find(tableName) == tables.end()) {
         LOGW("Remove device data with table name which is not a distributed table or not exist.");
         return E_OK;
@@ -456,6 +462,21 @@ int SQLiteRelationalStore::RemoveDeviceData(const std::string &device, const std
     errCode = handle->DeleteDistributedDeviceTable(device, tableName);
     if (errCode != E_OK) {
         LOGE("delete device data failed. %d", errCode);
+        goto END;
+    }
+
+    for (const auto &it : tables) {
+        if (tableName.empty() || it.second.GetTableName() == tableName) {
+            errCode = handle->DeleteDistributedDeviceTableLog(device, it.second.GetTableName());
+            if (errCode != E_OK) {
+                LOGE("delete device data failed. %d", errCode);
+                break;
+            }
+        }
+    }
+
+END:
+    if (errCode != E_OK) {
         (void)handle->Rollback();
         ReleaseHandle(handle);
         return errCode;
@@ -622,8 +643,12 @@ int SQLiteRelationalStore::RemoteQuery(const std::string &device, const RemoteCo
     if (sqliteStorageEngine_ == nullptr) {
         return -E_INVALID_DB;
     }
+    if (condition.sql.size() > DBConstant::REMOTE_QUERY_MAX_SQL_LEN) {
+        LOGE("remote query sql len is larger than %" PRIu32, DBConstant::REMOTE_QUERY_MAX_SQL_LEN);
+        return -E_MAX_LIMITS;
+    }
 
-    if (!sqliteStorageEngine_->GetSchemaRef().IsSchemaValid()) {
+    if (!sqliteStorageEngine_->GetSchema().IsSchemaValid()) {
         LOGW("not a distributed relational store.");
         return -E_NOT_SUPPORT;
     }
diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_store.h b/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_store.h
index 2ebfd8462b1ba878712ead877d3b1f0acfcaa777..37c26bc83a1fd80da618f839577fd8e4df2c4f78 100644
--- a/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_store.h
+++ b/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_store.h
@@ -99,7 +99,7 @@ private:
     std::unique_ptr<SyncAbleEngine> syncAbleEngine_ = nullptr; // For storage operate sync function
     // use ref obj same as kv
     RelationalSyncAbleStorage *storageEngine_ = nullptr; // For storage operate data
-    SQLiteSingleRelationalStorageEngine *sqliteStorageEngine_ = nullptr;
+    std::shared_ptr<SQLiteSingleRelationalStorageEngine> sqliteStorageEngine_;
 
     std::mutex connectMutex_;
     std::atomic<int> connectionCount_ = 0;
diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_relational_storage_engine.cpp b/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_relational_storage_engine.cpp
index d02485d53197f5eaceb8c5232eed792e8008d425..a63f9936498181f124d3771ea0c321ce2095e2eb 100644
--- a/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_relational_storage_engine.cpp
+++ b/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_relational_storage_engine.cpp
@@ -114,7 +114,7 @@ void SQLiteSingleRelationalStorageEngine::SetSchema(const RelationalSchemaObject
     schema_ = schema;
 }
 
-const RelationalSchemaObject &SQLiteSingleRelationalStorageEngine::GetSchemaRef() const
+RelationalSchemaObject SQLiteSingleRelationalStorageEngine::GetSchema() const
 {
     std::lock_guard lock(schemaMutex_);
     return schema_;
diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_relational_storage_engine.h b/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_relational_storage_engine.h
index 3b3370c68675b6c1c7e29e7cef96d1d6ba032600..41cb2fe6bba795c12eb39339863cddfe564bad2d 100644
--- a/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_relational_storage_engine.h
+++ b/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_relational_storage_engine.h
@@ -32,7 +32,7 @@ public:
 
     void SetSchema(const RelationalSchemaObject &schema);
 
-    const RelationalSchemaObject &GetSchemaRef() const;
+    RelationalSchemaObject GetSchema() const;
 
     int CreateDistributedTable(const std::string &tableName, const std::string &identity, bool &schemaChanged);
 
diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/split_device_log_table_manager.cpp b/frameworks/libs/distributeddb/storage/src/sqlite/split_device_log_table_manager.cpp
index 7828d4a6f3c6f5d2d0788bc37815d7b0c9076959..55d2cdc1b8b88eefb2922ecbd893528f43cf15c6 100644
--- a/frameworks/libs/distributeddb/storage/src/sqlite/split_device_log_table_manager.cpp
+++ b/frameworks/libs/distributeddb/storage/src/sqlite/split_device_log_table_manager.cpp
@@ -22,11 +22,11 @@ std::string SplitDeviceLogTableManager::CalcPrimaryKeyHash(const std::string &re
     (void)identity;
     std::string sql;
     if (table.GetPrimaryKey().size() == 1) {
-        sql = "calc_hash(" + references + table.GetPrimaryKey().at(0)  + ")";
+        sql = "calc_hash(" + references + "'" + table.GetPrimaryKey().at(0)  + "')";
     }  else {
         sql = "calc_hash(";
         for (const auto &it : table.GetPrimaryKey()) {
-            sql += "calc_hash(" + references + it.second + ")||";
+            sql += "calc_hash(" + references + "'" + it.second + "')||";
         }
         sql.pop_back();
         sql.pop_back();
@@ -40,7 +40,7 @@ std::string SplitDeviceLogTableManager::GetInsertTrigger(const TableInfo &table,
     std::string logTblName = DBConstant::RELATIONAL_PREFIX + table.GetTableName() + "_log";
     std::string insertTrigger = "CREATE TRIGGER IF NOT EXISTS ";
     insertTrigger += "naturalbase_rdb_" + table.GetTableName() + "_ON_INSERT AFTER INSERT \n";
-    insertTrigger += "ON " + table.GetTableName() + "\n";
+    insertTrigger += "ON '" + table.GetTableName() + "'\n";
     insertTrigger += "BEGIN\n";
     insertTrigger += "\t INSERT OR REPLACE INTO " + logTblName;
     insertTrigger += " (data_key, device, ori_device, timestamp, wtimestamp, flag, hash_key)";
@@ -58,7 +58,7 @@ std::string SplitDeviceLogTableManager::GetUpdateTrigger(const TableInfo &table,
     std::string logTblName = DBConstant::RELATIONAL_PREFIX + table.GetTableName() + "_log";
     std::string updateTrigger = "CREATE TRIGGER IF NOT EXISTS ";
     updateTrigger += "naturalbase_rdb_" + table.GetTableName() + "_ON_UPDATE AFTER UPDATE \n";
-    updateTrigger += "ON " + table.GetTableName() + "\n";
+    updateTrigger += "ON '" + table.GetTableName() + "'\n";
     updateTrigger += "BEGIN\n";
     if (table.GetPrimaryKey().size() == 1 && table.GetPrimaryKey().at(0) == "rowid") {
         updateTrigger += "\t UPDATE " + DBConstant::RELATIONAL_PREFIX + table.GetTableName() + "_log";
@@ -82,7 +82,7 @@ std::string SplitDeviceLogTableManager::GetDeleteTrigger(const TableInfo &table,
 {
     std::string deleteTrigger = "CREATE TRIGGER IF NOT EXISTS ";
     deleteTrigger += "naturalbase_rdb_" + table.GetTableName() + "_ON_DELETE BEFORE DELETE \n";
-    deleteTrigger += "ON " + table.GetTableName() + "\n";
+    deleteTrigger += "ON '" + table.GetTableName() + "'\n";
     deleteTrigger += "BEGIN\n";
     deleteTrigger += "\t UPDATE " + DBConstant::RELATIONAL_PREFIX + table.GetTableName() + "_log";
     deleteTrigger += " SET data_key=-1,flag=0x03,timestamp=get_sys_time(0)";
diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_query_helper.cpp b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_query_helper.cpp
index b1f04273611cbaef556d64d3f16683ff9fd45a94..d8ccd105b1b8efda7b3007419e7e6346f70e480d 100644
--- a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_query_helper.cpp
+++ b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_query_helper.cpp
@@ -97,11 +97,11 @@ std::string GetSelectAndFromClauseForRDB(const std::string &tableName, const std
         sql += "a.*";
     } else {
         for (const auto &fieldName : fieldNames) {  // For query data.
-            sql += "a." + fieldName + ",";
+            sql += "a.'" + fieldName + "',";
         }
         sql.pop_back();
     }
-    sql += " FROM " + tableName + " AS a INNER JOIN " + DBConstant::RELATIONAL_PREFIX + tableName + "_log AS b "
+    sql += " FROM '" + tableName + "' AS a INNER JOIN " + DBConstant::RELATIONAL_PREFIX + tableName + "_log AS b "
         "ON a.rowid=b.data_key ";
     return sql;
 }
@@ -770,7 +770,7 @@ std::string SqliteQueryHelper::GetFieldShape(const QueryObjNode &queryNode, cons
 {
     if (isRelationalQuery_) {
         // For relational query, $. prefix is not permitted, so need not extract json. Return directly will be OK.
-        return "a." + queryNode.fieldName + " ";
+        return "a.'" + queryNode.fieldName + "' ";
     }
     return MapCastFuncSql(queryNode, accessStr);
 }
@@ -848,7 +848,8 @@ int SqliteQueryHelper::GetSubscribeCondition(const std::string &accessStr, std::
         conditionStr += " (1 = 1) ";
         return E_OK;
     }
-    conditionStr += "(";
+    // json_extract_by_path function will return error when value is empty, check it before
+    conditionStr += "((length(" + accessStr + "value) != 0 AND " + accessStr + "value IS NOT NULL) AND ";
     if (hasPrefixKey_) {
         conditionStr += "(hex(" + accessStr + "key) LIKE '" + DBCommon::VectorToHexString(prefixKey_) + "%')";
     }
diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store.cpp b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store.cpp
index 871f853adce510dddf77509111a5d6641c959697..20c9834f5c904a0618190b9c6bf82367d5b1773d 100644
--- a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store.cpp
+++ b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store.cpp
@@ -405,10 +405,13 @@ int SQLiteSingleVerNaturalStore::CheckDatabaseRecovery(const KvDBProperties &kvD
 int SQLiteSingleVerNaturalStore::GetAndInitStorageEngine(const KvDBProperties &kvDBProp)
 {
     int errCode = E_OK;
-    storageEngine_ =
-        static_cast<SQLiteSingleVerStorageEngine *>(StorageEngineManager::GetStorageEngine(kvDBProp, errCode));
-    if (storageEngine_ == nullptr) {
-        return errCode;
+    {
+        std::unique_lock<std::shared_mutex> lock(engineMutex_);
+        storageEngine_ =
+            static_cast<SQLiteSingleVerStorageEngine *>(StorageEngineManager::GetStorageEngine(kvDBProp, errCode));
+        if (storageEngine_ == nullptr) {
+            return errCode;
+        }
     }
 
     if (storageEngine_->IsEngineCorrupted()) {
@@ -771,6 +774,12 @@ int SQLiteSingleVerNaturalStore::GetSyncDataForQuerySync(std::vector<DataItem> &
         goto ERROR;
     }
 
+    errCode = handle->StartTransaction(TransactType::DEFERRED);
+    if (errCode != E_OK) {
+        LOGE("[SingleVerNStore] Start transaction for get sync data failed. err=%d", errCode);
+        goto ERROR;
+    }
+
     // Get query data.
     if (!continueStmtToken->IsGetQueryDataFinished()) {
         LOGD("[SingleVerNStore] Get query data between %" PRIu64 " and %" PRIu64 ".",
@@ -795,6 +804,7 @@ int SQLiteSingleVerNaturalStore::GetSyncDataForQuerySync(std::vector<DataItem> &
         }
     }
 
+    (void)handle->Rollback(); // roll back query statement
     if (errCode == -E_FINISHED) {
         errCode = E_OK;
     }
@@ -1046,10 +1056,10 @@ int SQLiteSingleVerNaturalStore::RemoveDeviceDataNormally(const std::string &dev
 
     LOGI("Remove device data:%d", isNeedNotify);
     errCode = handle->RemoveDeviceData(deviceName);
+    ReleaseHandle(handle);
     if (errCode == E_OK && isNeedNotify) {
         NotifyRemovedData(entries);
     }
-    ReleaseHandle(handle);
     return errCode;
 }
 
@@ -1097,18 +1107,26 @@ void SQLiteSingleVerNaturalStore::NotifyRemovedData(std::vector<Entry> &entries)
 SQLiteSingleVerStorageExecutor *SQLiteSingleVerNaturalStore::GetHandle(bool isWrite, int &errCode,
     OperatePerm perm) const
 {
+    engineMutex_.lock_shared();
     if (storageEngine_ == nullptr) {
         errCode = -E_INVALID_DB;
+        engineMutex_.unlock_shared(); // unlock when get handle failed.
         return nullptr;
     }
     // Use for check database corrupted in Asynchronous task, like cache data migrate to main database
     if (storageEngine_->IsEngineCorrupted()) {
         CorruptNotify();
         errCode = -E_INVALID_PASSWD_OR_CORRUPTED_DB;
+        engineMutex_.unlock_shared(); // unlock when get handle failed.
         LOGI("Handle is corrupted can not to get! errCode = [%d]", errCode);
         return nullptr;
     }
-    return static_cast<SQLiteSingleVerStorageExecutor *>(storageEngine_->FindExecutor(isWrite, perm, errCode));
+
+    auto handle = storageEngine_->FindExecutor(isWrite, perm, errCode);
+    if (handle == nullptr) {
+        engineMutex_.unlock_shared(); // unlock when get handle failed.
+    }
+    return static_cast<SQLiteSingleVerStorageExecutor *>(handle);
 }
 
 void SQLiteSingleVerNaturalStore::ReleaseHandle(SQLiteSingleVerStorageExecutor *&handle) const
@@ -1126,6 +1144,7 @@ void SQLiteSingleVerNaturalStore::ReleaseHandle(SQLiteSingleVerStorageExecutor *
             CorruptNotify();
         }
     }
+    engineMutex_.unlock_shared(); // unlock after handle used up
 }
 
 int SQLiteSingleVerNaturalStore::RegisterNotification()
@@ -1169,7 +1188,7 @@ void SQLiteSingleVerNaturalStore::ReleaseResources()
         notificationConflictEventsRegistered_ = false;
     }
     {
-        std::lock_guard<std::mutex> lock(syncerMutex_);
+        std::unique_lock<std::shared_mutex> lock(engineMutex_);
         if (storageEngine_ != nullptr) {
             storageEngine_->ClearEnginePasswd();
             (void)StorageEngineManager::ReleaseStorageEngine(storageEngine_);
@@ -1512,7 +1531,10 @@ int SQLiteSingleVerNaturalStore::Import(const std::string &filePath, const Ciphe
 
     // Save create db time.
     storageEngine_->Enable(OperatePerm::IMPORT_MONOPOLIZE_PERM);
-    errCode = SaveCreateDBTime();
+
+    // Get current max timestamp after import and before start syncer, reflash local time offset
+    InitCurrentMaxStamp();
+    errCode = SaveCreateDBTime(); // This step will start syncer
 
 END:
     // restore the storage engine and the syncer.
@@ -2040,8 +2062,8 @@ int SQLiteSingleVerNaturalStore::SaveSyncItemsInCacheMode(SQLiteSingleVerStorage
     }
 END:
     if (errCode == E_OK) {
+        storageEngine_->IncreaseCacheRecordVersion(); // use engine wihtin shard lock by handle
         errCode = handle->Commit();
-        storageEngine_->IncreaseCacheRecordVersion();
     } else {
         (void)handle->Rollback(); // Keep the error code of the first scene
     }
diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store.h b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store.h
index dd81bc7b0fb6fc1ebae237394c4abad470b3af1c..ca7ffe9c56eef9dda2881e03b97b4a52094436db 100644
--- a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store.h
+++ b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store.h
@@ -278,12 +278,14 @@ private:
     DECLARE_OBJECT_TAG(SQLiteSingleVerNaturalStore);
 
     Timestamp currentMaxTimestamp_ = 0;
+
+    mutable std::shared_mutex engineMutex_;
     SQLiteSingleVerStorageEngine *storageEngine_;
+
     bool notificationEventsRegistered_;
     bool notificationConflictEventsRegistered_;
     bool isInitialized_;
     bool isReadOnly_;
-    mutable std::mutex syncerMutex_;
     mutable std::mutex initialMutex_;
     mutable std::mutex maxTimestampMutex_;
     mutable std::mutex lifeCycleMutex_;
diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store_connection.cpp b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store_connection.cpp
index 150e95b68a81b1031355d1feae7693a72238a6fa..1536ed535165cd6bd43807a26d4447cfb7c01613 100644
--- a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store_connection.cpp
+++ b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store_connection.cpp
@@ -147,47 +147,7 @@ int SQLiteSingleVerNaturalStoreConnection::Clear(const IOption &option)
 int SQLiteSingleVerNaturalStoreConnection::GetEntries(const IOption &option, const Key &keyPrefix,
     std::vector<Entry> &entries) const
 {
-    if (keyPrefix.size() > DBConstant::MAX_KEY_SIZE) {
-        return -E_INVALID_ARGS;
-    }
-
-    SingleVerDataType type;
-    if (option.dataType == IOption::LOCAL_DATA) {
-        type = SingleVerDataType::LOCAL_TYPE;
-    } else if (option.dataType == IOption::SYNC_DATA) {
-        type = SingleVerDataType::SYNC_TYPE;
-    } else {
-        return -E_INVALID_ARGS;
-    }
-
-    int errCode = CheckReadDataControlled();
-    if (errCode != E_OK) {
-        LOGE("[GetEntries] Existed cache database can not read data, errCode = [%d]!", errCode);
-        return errCode;
-    }
-
-    DBDfxAdapter::StartTraceSQL();
-    {
-        std::lock_guard<std::mutex> lock(transactionMutex_);
-        if (writeHandle_ != nullptr) {
-            LOGD("Transaction started already.");
-            errCode = writeHandle_->GetEntries(type, keyPrefix, entries);
-            DBDfxAdapter::FinishTraceSQL();
-            return errCode;
-        }
-    }
-
-    SQLiteSingleVerStorageExecutor *handle = GetExecutor(false, errCode);
-    if (handle == nullptr) {
-        LOGE("[Connection]::[GetEntries] Get executor failed, errCode = [%d]", errCode);
-        DBDfxAdapter::FinishTraceSQL();
-        return errCode;
-    }
-
-    errCode = handle->GetEntries(type, keyPrefix, entries);
-    ReleaseExecutor(handle);
-    DBDfxAdapter::FinishTraceSQL();
-    return errCode;
+    return GetEntriesInner(true, option, keyPrefix, entries);
 }
 
 int SQLiteSingleVerNaturalStoreConnection::GetEntries(const IOption &option, const Query &query,
@@ -1805,5 +1765,65 @@ int SQLiteSingleVerNaturalStoreConnection::CalcHashDevID(PragmaDeviceIdentifier
     return E_OK;
 }
 
+int SQLiteSingleVerNaturalStoreConnection::GetKeys(const IOption &option,
+    const Key &keyPrefix, std::vector<Key> &keys) const
+{
+    keys.clear();
+    std::vector<Entry> entries;
+    int errCode = GetEntriesInner(false, option, keyPrefix, entries);
+    if (errCode == E_OK) {
+        for (auto &entry : entries) {
+            keys.push_back(std::move(entry.key));
+        }
+    }
+    keys.shrink_to_fit();
+    return errCode;
+}
+
+int SQLiteSingleVerNaturalStoreConnection::GetEntriesInner(bool isGetValue, const IOption &option,
+    const Key &keyPrefix, std::vector<Entry> &entries) const
+{
+    if (keyPrefix.size() > DBConstant::MAX_KEY_SIZE) {
+        return -E_INVALID_ARGS;
+    }
+
+    SingleVerDataType type;
+    if (option.dataType == IOption::LOCAL_DATA) {
+        type = SingleVerDataType::LOCAL_TYPE;
+    } else if (option.dataType == IOption::SYNC_DATA) {
+        type = SingleVerDataType::SYNC_TYPE;
+    } else {
+        return -E_INVALID_ARGS;
+    }
+
+    int errCode = CheckReadDataControlled();
+    if (errCode != E_OK) {
+        LOGE("[GetEntries] Existed cache database can not read data, errCode = [%d]!", errCode);
+        return errCode;
+    }
+
+    DBDfxAdapter::StartTraceSQL();
+    {
+        std::lock_guard<std::mutex> lock(transactionMutex_);
+        if (writeHandle_ != nullptr) {
+            LOGD("Transaction started already.");
+            errCode = writeHandle_->GetEntries(isGetValue, type, keyPrefix, entries);
+            DBDfxAdapter::FinishTraceSQL();
+            return errCode;
+        }
+    }
+
+    SQLiteSingleVerStorageExecutor *handle = GetExecutor(false, errCode);
+    if (handle == nullptr) {
+        LOGE("[Connection]::[GetEntries] Get executor failed, errCode = [%d]", errCode);
+        DBDfxAdapter::FinishTraceSQL();
+        return errCode;
+    }
+
+    errCode = handle->GetEntries(isGetValue, type, keyPrefix, entries);
+    ReleaseExecutor(handle);
+    DBDfxAdapter::FinishTraceSQL();
+    return errCode;
+}
 DEFINE_OBJECT_TAG_FACILITIES(SQLiteSingleVerNaturalStoreConnection)
 }
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store_connection.h b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store_connection.h
index e8cff0d2adaa1be2b351b06b0846dcd209419a9c..94f4699780bab35fb3808070c54591f1db2db114 100644
--- a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store_connection.h
+++ b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store_connection.h
@@ -105,6 +105,7 @@ public:
 
     int CheckIntegrity() const override;
 
+    int GetKeys(const IOption &option, const Key &keyPrefix, std::vector<Key> &keys) const override;
 private:
     int CheckMonoStatus(OperatePerm perm);
 
@@ -202,6 +203,9 @@ private:
     bool CheckLogOverLimit(SQLiteSingleVerStorageExecutor *executor) const;
     int CalcHashDevID(PragmaDeviceIdentifier &pragmaDev);
 
+    int GetEntriesInner(bool isGetValue, const IOption &option,
+        const Key &keyPrefix, std::vector<Entry> &entries) const;
+
     DECLARE_OBJECT_TAG(SQLiteSingleVerNaturalStoreConnection);
 
     // ResultSet Related Info
diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_relational_storage_executor.cpp b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_relational_storage_executor.cpp
index eb53ab438888ae7dacbc1f791404b1860fc5011a..60939b74c345fa11f3c32272c41419c95503f6be 100644
--- a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_relational_storage_executor.cpp
+++ b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_relational_storage_executor.cpp
@@ -79,7 +79,7 @@ int CheckTableConstraint(const TableInfo &table, DistributedTableMode mode)
 namespace {
 int GetExistedDataTimeOffset(sqlite3 *db, const std::string &tableName, bool isMem, int64_t &timeOffset)
 {
-    std::string sql = "SELECT get_sys_time(0) - max(rowid) - 1 FROM " + tableName;
+    std::string sql = "SELECT get_sys_time(0) - max(rowid) - 1 FROM '" + tableName + "';";
     sqlite3_stmt *stmt = nullptr;
     int errCode = SQLiteUtils::GetStatement(db, sql, stmt);
     if (errCode != E_OK) {
@@ -107,7 +107,7 @@ int SQLiteSingleVerRelationalStorageExecutor::GeneLogInfoForExistedData(sqlite3
     std::string logTable = DBConstant::RELATIONAL_PREFIX + tableName + "_log";
     std::string sql = "INSERT INTO " + logTable +
         " SELECT rowid, '', '', " + timeOffsetStr + " + rowid, " + timeOffsetStr + " + rowid, 0x2, " +
-        calPrimaryKeyHash + " FROM " + tableName + " WHERE 1=1;";
+        calPrimaryKeyHash + " FROM '" + tableName + "' AS a WHERE 1=1;";
     return SQLiteUtils::ExecuteRawSQL(db, sql);
 }
 
@@ -118,21 +118,21 @@ int SQLiteSingleVerRelationalStorageExecutor::CreateDistributedTable(const std::
         return -E_INVALID_DB;
     }
 
+    int errCode = SQLiteUtils::AnalysisSchema(dbHandle_, tableName, table);
+    if (errCode != E_OK) {
+        LOGE("[CreateDistributedTable] analysis table schema failed. %d", errCode);
+        return errCode;
+    }
+
     if (mode == DistributedTableMode::SPLIT_BY_DEVICE && !isUpgraded) {
         bool isEmpty = false;
-        int errCode = SQLiteUtils::CheckTableEmpty(dbHandle_, tableName, isEmpty);
+        errCode = SQLiteUtils::CheckTableEmpty(dbHandle_, tableName, isEmpty);
         if (errCode != E_OK || !isEmpty) {
             LOGE("[CreateDistributedTable] check table empty failed. error=%d, isEmpty=%d", errCode, isEmpty);
             return -E_NOT_SUPPORT;
         }
     }
 
-    int errCode = SQLiteUtils::AnalysisSchema(dbHandle_, tableName, table);
-    if (errCode != E_OK) {
-        LOGE("[CreateDistributedTable] analysis table schema failed. %d", errCode);
-        return errCode;
-    }
-
     errCode = CheckTableConstraint(table, mode);
     if (errCode != E_OK) {
         LOGE("[CreateDistributedTable] check table constraint failed.");
@@ -148,7 +148,7 @@ int SQLiteSingleVerRelationalStorageExecutor::CreateDistributedTable(const std::
     }
 
     if (!isUpgraded) {
-        std::string calPrimaryKeyHash = tableManager->CalcPrimaryKeyHash("", table, identity);
+        std::string calPrimaryKeyHash = tableManager->CalcPrimaryKeyHash("a.", table, identity);
         errCode = GeneLogInfoForExistedData(dbHandle_, tableName, table, calPrimaryKeyHash);
         if (errCode != E_OK) {
             return errCode;
@@ -271,7 +271,8 @@ int UpgradeFields(sqlite3 *db, const std::vector<std::string> &tables, std::vect
     int errCode = E_OK;
     for (const auto &table : tables) {
         for (const auto &field : fields) {
-            std::string alterSql = "ALTER TABLE " + table + " ADD " + field.GetFieldName() + " " + field.GetDataType();
+            std::string alterSql = "ALTER TABLE " + table + " ADD '" + field.GetFieldName() + "' ";
+            alterSql += "'" + field.GetDataType() + "'";
             alterSql += field.IsNotNull() ? " NOT NULL" : "";
             alterSql += field.HasDefaultValue() ? " DEFAULT " + field.GetDefaultValue() : "";
             alterSql += ";";
@@ -695,7 +696,7 @@ int SQLiteSingleVerRelationalStorageExecutor::PrepareForSavingData(const QueryOb
     std::string colName;
     std::string dataFormat;
     for (size_t colId = 0; colId < table_.GetFields().size(); ++colId) {
-        colName += table_.GetFieldName(colId) + ",";
+        colName += "'" + table_.GetFieldName(colId) + "',";
         dataFormat += "?,";
     }
     colName.pop_back();
@@ -765,7 +766,7 @@ int SQLiteSingleVerRelationalStorageExecutor::SaveSyncLog(sqlite3_stmt *statemen
 int SQLiteSingleVerRelationalStorageExecutor::DeleteSyncDataItem(const DataItem &dataItem, sqlite3_stmt *&stmt)
 {
     if (stmt == nullptr) {
-        std::string sql = "DELETE FROM " + table_.GetTableName() + " WHERE rowid IN ("
+        std::string sql = "DELETE FROM '" + table_.GetTableName() + "' WHERE rowid IN ("
             "SELECT data_key FROM " + DBConstant::RELATIONAL_PREFIX + baseTblName_ + "_log ";
         if (mode_ == DistributedTableMode::COLLABORATION) {
             sql += "WHERE hash_key=?);";
@@ -1227,6 +1228,35 @@ int SQLiteSingleVerRelationalStorageExecutor::DeleteDistributedDeviceTable(const
     return errCode;
 }
 
+int SQLiteSingleVerRelationalStorageExecutor::DeleteDistributedDeviceTableLog(const std::string &device,
+    const std::string &tableName)
+{
+    std::string deleteLogSql = "DELETE FROM " + DBConstant::RELATIONAL_PREFIX + tableName + "_log WHERE device = ?";
+    sqlite3_stmt *deleteLogStmt = nullptr;
+    int errCode = SQLiteUtils::GetStatement(dbHandle_, deleteLogSql, deleteLogStmt);
+    if (errCode != E_OK) {
+        LOGE("Get delete device data log statement failed. %d", errCode);
+        return errCode;
+    }
+
+    errCode = SQLiteUtils::BindTextToStatement(deleteLogStmt, 1, device);
+    if (errCode != E_OK) {
+        LOGE("Bind device to delete data log statement failed. %d", errCode);
+        SQLiteUtils::ResetStatement(deleteLogStmt, true, errCode);
+        return errCode;
+    }
+
+    errCode = SQLiteUtils::StepWithRetry(deleteLogStmt);
+    if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
+        errCode = E_OK;
+    } else {
+        LOGE("Delete data log failed. %d", errCode);
+    }
+
+    SQLiteUtils::ResetStatement(deleteLogStmt, true, errCode);
+    return errCode;
+}
+
 int SQLiteSingleVerRelationalStorageExecutor::DeleteDistributedLogTable(const std::string &tableName)
 {
     if (tableName.empty()) {
diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_relational_storage_executor.h b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_relational_storage_executor.h
index 03e22e9ce82543e2ef2b7595d283f32cec953fd0..111d0c1a45e0aec11a039053204f0f41a67ac1a7 100644
--- a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_relational_storage_executor.h
+++ b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_relational_storage_executor.h
@@ -65,6 +65,9 @@ public:
     int CheckDBModeForRelational();
 
     int DeleteDistributedDeviceTable(const std::string &device, const std::string &tableName);
+
+    int DeleteDistributedDeviceTableLog(const std::string &device, const std::string &tableName);
+
     int DeleteDistributedLogTable(const std::string &tableName);
 
     int CheckAndCleanDistributedTable(const std::vector<std::string> &tableNames,
diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_result_set.h b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_result_set.h
index d4c538304c52fe0d981c1edc79f01ffad129298a..ce54c469fd70db956dd89c44df8a08b2aeb2d168 100644
--- a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_result_set.h
+++ b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_result_set.h
@@ -19,8 +19,8 @@
 #include <mutex>
 #include <vector>
 
-#include "kvdb_windowed_result_set.h"
 #include "ikvdb_raw_cursor.h"
+#include "kvdb_windowed_result_set.h"
 #include "query_object.h"
 
 namespace DistributedDB {
diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_engine.cpp b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_engine.cpp
index a5b63634d2c250d8757de4e4b9c7d7718a47058d..ca47cc7c52244fb04a1e3f11494799cd1a5a9ba6 100644
--- a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_engine.cpp
+++ b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_engine.cpp
@@ -37,7 +37,7 @@ namespace {
         return RuntimeContext::GetInstance()->GetSecurityOption(filePath, secOpt);
     }
 
-    enum class DbType {
+    enum class DbType : int32_t {
         MAIN,
         META,
         CACHE
@@ -45,16 +45,17 @@ namespace {
 
     std::string GetDbDir(const std::string &subDir, DbType type)
     {
-        static const std::map<DbType, std::string> dbDirDic {
-            { DbType::MAIN, DBConstant::MAINDB_DIR },
-            { DbType::META, DBConstant::METADB_DIR },
-            { DbType::CACHE, DBConstant::CACHEDB_DIR },
-        }; // for ensure static compilation order
-
-        if (dbDirDic.find(type) == dbDirDic.end()) {
-            return std::string();
+        switch (type) {
+            case DbType::MAIN:
+                return subDir + "/" + DBConstant::MAINDB_DIR;
+            case DbType::META:
+                return subDir + "/" + DBConstant::METADB_DIR;
+            case DbType::CACHE:
+                return subDir + "/" + DBConstant::CACHEDB_DIR;
+            default:
+                break;
         }
-        return subDir + "/" + dbDirDic.at(type);
+        return "";
     }
 } // namespace
 
@@ -163,15 +164,13 @@ int SQLiteSingleVerStorageEngine::MigrateSyncDataByVersion(SQLiteSingleVerStorag
         return errCode;
     }
 
-    CommitNotifyForMigrateCache(syncData);
-
     Timestamp timestamp = 0;
     errCode = handle->GetMaxTimestampDuringMigrating(timestamp);
     if (errCode == E_OK) {
         SetMaxTimestamp(timestamp);
     }
 
-    errCode = ReleaseHandleTransiently(handle, 2ull); // temporary release handle 2ms
+    errCode = ReleaseHandleTransiently(handle, 2ull, syncData); // temporary release handle 2ms
     if (errCode != E_OK) {
         return errCode;
     }
@@ -180,7 +179,8 @@ int SQLiteSingleVerStorageEngine::MigrateSyncDataByVersion(SQLiteSingleVerStorag
 }
 
 // Temporary release handle for idleTime ms, avoid long-term blocking
-int SQLiteSingleVerStorageEngine::ReleaseHandleTransiently(SQLiteSingleVerStorageExecutor *&handle, uint64_t idleTime)
+int SQLiteSingleVerStorageEngine::ReleaseHandleTransiently(SQLiteSingleVerStorageExecutor *&handle, uint64_t idleTime,
+    NotifyMigrateSyncData &syncData)
 {
     int errCode = ReleaseExecutor(handle);
     if (errCode != E_OK) {
@@ -188,6 +188,8 @@ int SQLiteSingleVerStorageEngine::ReleaseHandleTransiently(SQLiteSingleVerStorag
         return errCode;
     }
 
+    CommitNotifyForMigrateCache(syncData); // Trigger sync after release handle
+
     std::this_thread::sleep_for(std::chrono::milliseconds(idleTime)); // Wait 2 ms to free this handle for put data
     handle = static_cast<SQLiteSingleVerStorageExecutor *>(FindExecutor(true, OperatePerm::NORMAL_PERM, errCode));
     if (errCode != E_OK) {
diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_engine.h b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_engine.h
index 1418ae4bdb7d0cbb51321f8a68e2041382b22afc..871081469467f1fbde9c0cea30dadae513adf315 100644
--- a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_engine.h
+++ b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_engine.h
@@ -73,7 +73,8 @@ private:
     int EndCreateExecutor(bool isWrite);
     int ReInit() override;
     int ReleaseExecutor(SQLiteSingleVerStorageExecutor *&handle);
-    int ReleaseHandleTransiently(SQLiteSingleVerStorageExecutor *&handle, uint64_t idleTime);
+    int ReleaseHandleTransiently(SQLiteSingleVerStorageExecutor *&handle, uint64_t idleTime,
+        NotifyMigrateSyncData &syncData);
 
     // For migrate.
     int MigrateLocalData(SQLiteSingleVerStorageExecutor *handle) const;
diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor.cpp b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor.cpp
index 5ceb2dc5a63f6418c13e05062ed9a6acb9bc814c..b26687f0aa5fcc2dfbbe68a5a25ac0d001f498a9 100644
--- a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor.cpp
+++ b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor.cpp
@@ -60,6 +60,24 @@ int ResetOrRegetStmt(sqlite3 *db, sqlite3_stmt *&stmt, const std::string &sql)
     }
     return errCode;
 }
+
+int GetEntryFromStatement(bool isGetValue, sqlite3_stmt *statement, std::vector<Entry> &entries)
+{
+    Entry entry;
+    int errCode = SQLiteUtils::GetColumnBlobValue(statement, 0, entry.key);
+    if (errCode != E_OK) {
+        return errCode;
+    }
+    if (isGetValue) {
+        errCode = SQLiteUtils::GetColumnBlobValue(statement, 1, entry.value);
+        if (errCode != E_OK) {
+            return errCode;
+        }
+    }
+
+    entries.push_back(std::move(entry));
+    return errCode;
+}
 }
 
 SQLiteSingleVerStorageExecutor::SQLiteSingleVerStorageExecutor(sqlite3 *dbHandle, bool writable, bool isMemDb)
@@ -303,14 +321,19 @@ int SQLiteSingleVerStorageExecutor::PutKvData(SingleVerDataType type, const Key
     return E_OK;
 }
 
-int SQLiteSingleVerStorageExecutor::GetEntries(SingleVerDataType type, const Key &keyPrefix,
+int SQLiteSingleVerStorageExecutor::GetEntries(bool isGetValue, SingleVerDataType type, const Key &keyPrefix,
     std::vector<Entry> &entries) const
 {
     if ((type != SingleVerDataType::LOCAL_TYPE) && (type != SingleVerDataType::SYNC_TYPE)) {
         return -E_INVALID_ARGS;
     }
 
-    std::string sql = (type == SingleVerDataType::SYNC_TYPE) ? SELECT_SYNC_PREFIX_SQL : SELECT_LOCAL_PREFIX_SQL;
+    std::string sql;
+    if (type == SingleVerDataType::SYNC_TYPE) {
+        sql = isGetValue ? SELECT_SYNC_PREFIX_SQL : SELECT_SYNC_KEY_PREFIX_SQL;
+    } else {
+        sql = SELECT_LOCAL_PREFIX_SQL;
+    }
     sqlite3_stmt *statement = nullptr;
     int errCode = SQLiteUtils::GetStatement(dbHandle_, sql, statement);
     if (errCode != E_OK) {
@@ -323,7 +346,7 @@ int SQLiteSingleVerStorageExecutor::GetEntries(SingleVerDataType type, const Key
         goto END;
     }
 
-    errCode = StepForResultEntries(statement, entries);
+    errCode = StepForResultEntries(isGetValue, statement, entries);
 
 END:
     SQLiteUtils::ResetStatement(statement, true, errCode);
@@ -341,7 +364,7 @@ int SQLiteSingleVerStorageExecutor::GetEntries(QueryObject &queryObj, std::vecto
     sqlite3_stmt *statement = nullptr;
     errCode = helper.GetQuerySqlStatement(dbHandle_, false, statement);
     if (errCode == E_OK) {
-        errCode = StepForResultEntries(statement, entries);
+        errCode = StepForResultEntries(true, statement, entries);
     }
 
     SQLiteUtils::ResetStatement(statement, true, errCode);
@@ -492,7 +515,6 @@ int SQLiteSingleVerStorageExecutor::GetSyncDataItems(std::vector<DataItem> &data
 {
     int errCode;
     size_t dataTotalSize = 0;
-
     do {
         DataItem dataItem;
         errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
@@ -1799,26 +1821,19 @@ ERROR:
     return CheckCorruptedStatus(errCode);
 }
 
-int SQLiteSingleVerStorageExecutor::StepForResultEntries(sqlite3_stmt *statement, std::vector<Entry> &entries) const
+int SQLiteSingleVerStorageExecutor::StepForResultEntries(bool isGetValue, sqlite3_stmt *statement,
+    std::vector<Entry> &entries) const
 {
     entries.clear();
     entries.shrink_to_fit();
-    Entry entry;
     int errCode = E_OK;
     do {
         errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
         if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
-            errCode = SQLiteUtils::GetColumnBlobValue(statement, 0, entry.key);
+            errCode = GetEntryFromStatement(isGetValue, statement, entries);
             if (errCode != E_OK) {
                 return errCode;
             }
-
-            errCode = SQLiteUtils::GetColumnBlobValue(statement, 1, entry.value);
-            if (errCode != E_OK) {
-                return errCode;
-            }
-
-            entries.push_back(std::move(entry));
         } else if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
             errCode = E_OK;
             break;
@@ -1870,7 +1885,6 @@ size_t SQLiteSingleVerStorageExecutor::GetDataItemSerialSize(const DataItem &ite
     size_t devLength = std::max(maxOrigDevLength, item.origDev.size());
     size_t dataSize = (Parcel::GetUInt64Len() * 3 + Parcel::GetUInt32Len() + Parcel::GetVectorCharLen(item.key) +
         Parcel::GetVectorCharLen(item.value) + devLength + appendLen);
-
     return dataSize;
 }
 
diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor.h b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor.h
index b71f282fbbf4e419c5ecde878815c7dbea324e5a..5b3224eaa922d3865b2ef7707fdb890d4f3b8115 100644
--- a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor.h
+++ b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor.h
@@ -113,7 +113,7 @@ public:
     int PutKvData(SingleVerDataType type, const Key &key, const Value &value,
         Timestamp timestamp, SingleVerNaturalStoreCommitNotifyData *committedData);
 
-    int GetEntries(SingleVerDataType type, const Key &keyPrefix, std::vector<Entry> &entries) const;
+    int GetEntries(bool isGetValue, SingleVerDataType type, const Key &keyPrefix, std::vector<Entry> &entries) const;
 
     int GetEntries(QueryObject &queryObj, std::vector<Entry> &entries) const;
 
@@ -291,7 +291,7 @@ private:
     int PrepareForSyncDataByTime(Timestamp begin, Timestamp end, sqlite3_stmt *&statement, bool getDeletedData = false)
         const;
 
-    int StepForResultEntries(sqlite3_stmt *statement, std::vector<Entry> &entries) const;
+    int StepForResultEntries(bool isGetValue, sqlite3_stmt *statement, std::vector<Entry> &entries) const;
 
     int InitResultSet(const Key &keyPrefix, sqlite3_stmt *&countStmt);
 
diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor_sql.h b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor_sql.h
index b92ea338615416022632a3d4ad1e32b11ffb69be..5fceeaebb415b255acb25d90ebc0c97dd261b5da 100644
--- a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor_sql.h
+++ b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor_sql.h
@@ -140,6 +140,9 @@ namespace DistributedDB {
     const std::string SELECT_SYNC_PREFIX_SQL =
         "SELECT key, value FROM sync_data WHERE key>=? AND key<=? AND (flag&0x01=0) ORDER BY key ASC;";
 
+    const std::string SELECT_SYNC_KEY_PREFIX_SQL =
+        "SELECT key FROM sync_data WHERE key>=? AND key<=? AND (flag&0x01=0) ORDER BY key ASC;";
+
     const std::string SELECT_SYNC_ROWID_PREFIX_SQL =
         "SELECT rowid FROM sync_data WHERE key>=? AND key<=? AND (flag&0x01=0) ORDER BY key ASC;";
 
diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor_subscribe.cpp b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor_subscribe.cpp
index 061d9b89ffacf9ea8cc459e958fd622fc3da60df..b1e4caa9ce9c5c849c831f874935df6e249f0f22 100644
--- a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor_subscribe.cpp
+++ b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor_subscribe.cpp
@@ -139,7 +139,7 @@ std::string FormatSubscribeTriggerSql(const std::string &subscribeId, const std:
     std::string triggerName = DBConstant::SUBSCRIBE_QUERY_PREFIX + subscribeId + "_ON_" + triggerModeString;
     return "CREATE TRIGGER IF NOT EXISTS " + triggerName + " AFTER " + triggerModeString + " \n"
         "ON sync_data\n"
-        "WHEN " + subscribeCondition + "\n"
+        "WHEN ((NEW.flag&0x02=0x02) AND (" + subscribeCondition + "))\n" // filter locally changed data
         "BEGIN\n"
         "    SELECT " + DBConstant::UPDATE_META_FUNC + "(x'" + hexKeyStr + "', NEW.TIMESTAMP);\n"
         "END;";
diff --git a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_utils.cpp b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_utils.cpp
index 08c1d8a77141b004f955b180b585aece026b6c43..6ef5cf57916f5f2ee90469a5d5b6eb8a16b0e5d0 100644
--- a/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_utils.cpp
+++ b/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_utils.cpp
@@ -697,7 +697,7 @@ int AnalysisSchemaSqlAndTrigger(sqlite3 *db, const std::string &tableName, Table
 int GetSchemaIndexList(sqlite3 *db, const std::string &tableName, std::vector<std::string> &indexList,
     std::vector<std::string> &uniqueList)
 {
-    std::string sql = "pragma index_list(" + tableName + ")";
+    std::string sql = "pragma index_list('" + tableName + "')";
     sqlite3_stmt *statement = nullptr;
     int errCode = SQLiteUtils::GetStatement(db, sql, statement);
     if (errCode != E_OK) {
@@ -731,7 +731,7 @@ int GetSchemaIndexList(sqlite3 *db, const std::string &tableName, std::vector<st
 
 int AnalysisSchemaIndexDefine(sqlite3 *db, const std::string &indexName, CompositeFields &indexDefine)
 {
-    auto sql = "pragma index_info(" + indexName + ")";
+    auto sql = "pragma index_info('" + indexName + "')";
     sqlite3_stmt *statement = nullptr;
     int errCode = SQLiteUtils::GetStatement(db, sql, statement);
     if (errCode != E_OK) {
@@ -825,7 +825,7 @@ int SetFieldInfo(sqlite3_stmt *statement, TableInfo &table)
 
 int AnalysisSchemaFieldDefine(sqlite3 *db, const std::string &tableName, TableInfo &table)
 {
-    std::string sql = "pragma table_info(" + tableName + ")";
+    std::string sql = "pragma table_info('" + tableName + "')";
     sqlite3_stmt *statement = nullptr;
     int errCode = SQLiteUtils::GetStatement(db, sql, statement);
     if (errCode != E_OK) {
@@ -1407,11 +1407,11 @@ int SQLiteUtils::CreateRelationalMetaTable(sqlite3 *db)
 
 int SQLiteUtils::CreateSameStuTable(sqlite3 *db, const TableInfo &baseTbl, const std::string &newTableName)
 {
-    std::string sql = "CREATE TABLE IF NOT EXISTS " + newTableName + "(";
+    std::string sql = "CREATE TABLE IF NOT EXISTS '" + newTableName + "' (";
     const std::map<FieldName, FieldInfo> &fields = baseTbl.GetFields();
     for (uint32_t cid = 0; cid < fields.size(); ++cid) {
         std::string fieldName = baseTbl.GetFieldName(cid);
-        sql += fieldName + " " + fields.at(fieldName).GetDataType();
+        sql += "'" + fieldName + "' '" + fields.at(fieldName).GetDataType() + "'";
         if (fields.at(fieldName).IsNotNull()) {
             sql += " NOT NULL";
         }
@@ -1424,7 +1424,7 @@ int SQLiteUtils::CreateSameStuTable(sqlite3 *db, const TableInfo &baseTbl, const
     if (!(baseTbl.GetPrimaryKey().size() == 1 && baseTbl.GetPrimaryKey().at(0) == "rowid")) {
         sql += " PRIMARY KEY (";
         for (const auto &it : baseTbl.GetPrimaryKey()) {
-            sql += it.second + ",";
+            sql += "'" + it.second + "',";
         }
         sql.pop_back();
         sql += "),";
@@ -2144,7 +2144,7 @@ int SQLiteUtils::CheckTableEmpty(sqlite3 *db, const std::string &tableName, bool
         return -E_INVALID_ARGS;
     }
 
-    std::string cntSql = "SELECT min(rowid) FROM " + tableName + ";";
+    std::string cntSql = "SELECT min(rowid) FROM '" + tableName + "';";
     sqlite3_stmt *stmt = nullptr;
     int errCode = SQLiteUtils::GetStatement(db, cntSql, stmt);
     if (errCode != E_OK) {
diff --git a/frameworks/libs/distributeddb/storage/src/sync_able_engine.cpp b/frameworks/libs/distributeddb/storage/src/sync_able_engine.cpp
index fc34669a02d7e82d28ad9c624d9191bb725e5e84..c39fae6a3dc4b329df3ff5b1a4478210ee7d78e5 100644
--- a/frameworks/libs/distributeddb/storage/src/sync_able_engine.cpp
+++ b/frameworks/libs/distributeddb/storage/src/sync_able_engine.cpp
@@ -61,7 +61,7 @@ void SyncAbleEngine::WakeUpSyncer()
 
 void SyncAbleEngine::Close()
 {
-    StopSyncer(true);
+    StopSyncer();
 }
 
 void SyncAbleEngine::EnableAutoSync(bool enable)
@@ -145,10 +145,19 @@ int SyncAbleEngine::StartSyncerWithNoLock(bool isCheckSyncActive, bool isNeedAct
 }
 
 // Stop syncer
-void SyncAbleEngine::StopSyncer(bool isClosedOperation)
+void SyncAbleEngine::StopSyncer()
 {
-    std::unique_lock<std::mutex> lock(syncerOperateLock_);
-    StopSyncerWithNoLock(isClosedOperation);
+    NotificationChain::Listener *userChangeListener = nullptr;
+    {
+        std::unique_lock<std::mutex> lock(syncerOperateLock_);
+        StopSyncerWithNoLock(true);
+        userChangeListener = userChangeListener_;
+        userChangeListener_ = nullptr;
+    }
+    if (userChangeListener != nullptr) {
+        userChangeListener->Drop(true);
+        userChangeListener = nullptr;
+    }
 }
 
 void SyncAbleEngine::StopSyncerWithNoLock(bool isClosedOperation)
@@ -159,7 +168,7 @@ void SyncAbleEngine::StopSyncerWithNoLock(bool isClosedOperation)
         started_ = false;
     }
     closed_ = isClosedOperation;
-    if (userChangeListener_ != nullptr) {
+    if (!isClosedOperation && userChangeListener_ != nullptr) {
         userChangeListener_->Drop(false);
         userChangeListener_ = nullptr;
     }
@@ -228,21 +237,6 @@ void SyncAbleEngine::ReSetSyncModuleActive()
     isSyncNeedActive_ = true;
 }
 
-void SyncAbleEngine::TriggerSync(int notifyEvent)
-{
-    if (!started_) {
-        StartSyncer();
-    }
-    if (started_) {
-        int errCode = RuntimeContext::GetInstance()->ScheduleTask([this, notifyEvent] {
-            syncer_.LocalDataChanged(notifyEvent);
-        });
-        if (errCode != E_OK) {
-            LOGE("[TriggerSync] SyncAbleEngine TriggerSync LocalDataChanged retCode:%d", errCode);
-        }
-    }
-}
-
 int SyncAbleEngine::GetLocalIdentity(std::string &outTarget)
 {
     if (!started_) {
diff --git a/frameworks/libs/distributeddb/storage/src/sync_able_engine.h b/frameworks/libs/distributeddb/storage/src/sync_able_engine.h
index 609a55d4c9d8413166279f2f08caa5b07d8e04bb..0ed49535da975c34c186b0069b20adcb9dda5f29 100644
--- a/frameworks/libs/distributeddb/storage/src/sync_able_engine.h
+++ b/frameworks/libs/distributeddb/storage/src/sync_able_engine.h
@@ -27,7 +27,6 @@ class SyncAbleEngine final {
 public:
     explicit SyncAbleEngine(ISyncInterface *store);
     ~SyncAbleEngine();
-    void TriggerSync(int notifyEvent);
 
     // Start a sync action.
     int Sync(const ISyncer::SyncParma &parm, uint64_t connectionId);
@@ -62,7 +61,7 @@ private:
     int StartSyncerWithNoLock(bool isCheckSyncActive, bool isNeedActive);
 
     // Stop syncer
-    void StopSyncer(bool isClosedOperation = false);
+    void StopSyncer();
 
     void StopSyncerWithNoLock(bool isClosedOperation = false);
 
diff --git a/frameworks/libs/distributeddb/storage/src/sync_able_kvdb.cpp b/frameworks/libs/distributeddb/storage/src/sync_able_kvdb.cpp
index 21edf7885b886d20e895714dee538e2eb1206bea..26c6675e65f9dc64f1fc45079d2ec13ee8e43971 100644
--- a/frameworks/libs/distributeddb/storage/src/sync_able_kvdb.cpp
+++ b/frameworks/libs/distributeddb/storage/src/sync_able_kvdb.cpp
@@ -196,8 +196,17 @@ int SyncAbleKvDB::StartSyncerWithNoLock(bool isCheckSyncActive, bool isNeedActiv
 // Stop syncer
 void SyncAbleKvDB::StopSyncer(bool isClosedOperation)
 {
-    std::unique_lock<std::mutex> lock(syncerOperateLock_);
-    StopSyncerWithNoLock(isClosedOperation);
+    NotificationChain::Listener *userChangeListener = nullptr;
+    {
+        std::unique_lock<std::mutex> lock(syncerOperateLock_);
+        StopSyncerWithNoLock(isClosedOperation);
+        userChangeListener = userChangeListener_;
+        userChangeListener_ = nullptr;
+    }
+    if (userChangeListener != nullptr) {
+        userChangeListener->Drop(true);
+        userChangeListener = nullptr;
+    }
 }
 
 void SyncAbleKvDB::StopSyncerWithNoLock(bool isClosedOperation)
@@ -208,7 +217,7 @@ void SyncAbleKvDB::StopSyncerWithNoLock(bool isClosedOperation)
         started_ = false;
     }
     closed_ = isClosedOperation;
-    if (userChangeListener_ != nullptr) {
+    if (!isClosedOperation && userChangeListener_ != nullptr) {
         userChangeListener_->Drop(false);
         userChangeListener_ = nullptr;
     }
@@ -229,7 +238,7 @@ void SyncAbleKvDB::UserChangeHandle()
         return;
     }
     isNeedActive = RuntimeContext::GetInstance()->IsSyncerNeedActive(syncInterface->GetDbProperties());
-    isNeedChange = (isNeedActive != isSyncNeedActive_) ? true : false;
+    isNeedChange = (isNeedActive != isSyncNeedActive_);
     // non_active to active or active to non_active
     if (isNeedChange) {
         StopSyncerWithNoLock(); // will drop userChangeListener
@@ -387,4 +396,9 @@ void SyncAbleKvDB::Dump(int fd)
         syncer_.Dump(fd);
     }
 }
+
+int SyncAbleKvDB::GetSyncDataSize(const std::string &device, size_t &size) const
+{
+    return syncer_.GetSyncDataSize(device, size);
+}
 }
diff --git a/frameworks/libs/distributeddb/storage/src/sync_able_kvdb.h b/frameworks/libs/distributeddb/storage/src/sync_able_kvdb.h
index 56e1289a99f014ebfa2c31e201c73c733f4b2dfa..7b86ce6cbfa7a7b52d31db1eece5fd821afbd09a 100644
--- a/frameworks/libs/distributeddb/storage/src/sync_able_kvdb.h
+++ b/frameworks/libs/distributeddb/storage/src/sync_able_kvdb.h
@@ -85,6 +85,8 @@ public:
 
     void Dump(int fd) override;
 
+    int GetSyncDataSize(const std::string &device, size_t &size) const;
+
 protected:
     virtual IKvDBSyncInterface *GetSyncInterface() = 0;
 
diff --git a/frameworks/libs/distributeddb/storage/src/sync_able_kvdb_connection.cpp b/frameworks/libs/distributeddb/storage/src/sync_able_kvdb_connection.cpp
index d55ccfb2a4104f522d451b8d0a12cfe4f4ebe0a9..57d6f14438602920e7f351282c356b838f343aac 100644
--- a/frameworks/libs/distributeddb/storage/src/sync_able_kvdb_connection.cpp
+++ b/frameworks/libs/distributeddb/storage/src/sync_able_kvdb_connection.cpp
@@ -323,4 +323,13 @@ int SyncAbleKvDBConnection::SetPushDataInterceptor(const PushDataInterceptor &in
     kvDB->SetDataInterceptor(interceptor);
     return E_OK;
 }
+
+int SyncAbleKvDBConnection::GetSyncDataSize(const std::string &device, size_t &size) const
+{
+    SyncAbleKvDB *kvDB = GetDB<SyncAbleKvDB>();
+    if (kvDB == nullptr) {
+        return -E_INVALID_CONNECTION;
+    }
+    return kvDB->GetSyncDataSize(device, size);
+}
 }
diff --git a/frameworks/libs/distributeddb/storage/src/sync_able_kvdb_connection.h b/frameworks/libs/distributeddb/storage/src/sync_able_kvdb_connection.h
index a640bbe0fd92bd42c31015edcbe0712328287056..07edbb3dc8ef48eee6388f1b45aa315e50305866 100644
--- a/frameworks/libs/distributeddb/storage/src/sync_able_kvdb_connection.h
+++ b/frameworks/libs/distributeddb/storage/src/sync_able_kvdb_connection.h
@@ -35,6 +35,8 @@ public:
     // Pragma interface.
     int Pragma(int cmd, void *parameter) override;
 
+    int GetSyncDataSize(const std::string &device, size_t &size) const override;
+
 protected:
     int DisableManualSync();
 
diff --git a/frameworks/libs/distributeddb/syncer/include/isyncer.h b/frameworks/libs/distributeddb/syncer/include/isyncer.h
index 15ea8ae4c76e9392390fd78488f6efc6fbb717ad..42a3320d9c6badfa0b916eb5440a20c179759143 100644
--- a/frameworks/libs/distributeddb/syncer/include/isyncer.h
+++ b/frameworks/libs/distributeddb/syncer/include/isyncer.h
@@ -32,7 +32,6 @@ namespace DistributedDB {
 struct SyncerBasicInfo {
     bool isSyncActive = false;
     bool isAutoSync = false;
-    bool isClearHistoryData = false;
 };
 class ISyncer {
 public:
@@ -50,10 +49,7 @@ public:
     virtual ~ISyncer() {};
 
     // Init the Syncer modules
-    virtual int Initialize(ISyncInterface *syncInterface, bool isNeedActive)
-    {
-        return -E_NOT_SUPPORT;
-    }
+    virtual int Initialize(ISyncInterface *syncInterface, bool isNeedActive) = 0;
 
     // Close
     virtual int Close(bool isClosedOperation) = 0;
@@ -125,6 +121,8 @@ public:
 
     virtual int RemoteQuery(const std::string &device, const RemoteCondition &condition,
         uint64_t timeout, uint64_t connectionId, std::shared_ptr<ResultSet> &result) = 0;
+
+    virtual int GetSyncDataSize(const std::string &device, size_t &size) const = 0;
 };
 } // namespace DistributedDB
 
diff --git a/frameworks/libs/distributeddb/syncer/include/syncer_proxy.h b/frameworks/libs/distributeddb/syncer/include/syncer_proxy.h
index a9dc1ce660f1babc251750134dc60f9a5fbf7dd6..1d6294af478547c6360d7ea5146d08a438587f15 100644
--- a/frameworks/libs/distributeddb/syncer/include/syncer_proxy.h
+++ b/frameworks/libs/distributeddb/syncer/include/syncer_proxy.h
@@ -105,6 +105,8 @@ public:
     int RemoteQuery(const std::string &device, const RemoteCondition &condition,
         uint64_t timeout, uint64_t connectionId, std::shared_ptr<ResultSet> &result) override;
 
+    int GetSyncDataSize(const std::string &device, size_t &size) const override;
+
 private:
     std::mutex syncerLock_;
     std::shared_ptr<ISyncer> syncer_;
diff --git a/frameworks/libs/distributeddb/syncer/src/ability_sync.cpp b/frameworks/libs/distributeddb/syncer/src/ability_sync.cpp
index 8ce594da1002fa86b69d0819fcdc499ced0e3105..4109de564e0677d02834820d0ffb98b661b2e274 100644
--- a/frameworks/libs/distributeddb/syncer/src/ability_sync.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/ability_sync.cpp
@@ -131,12 +131,12 @@ uint32_t AbilitySyncRequestPacket::CalculateLen() const
     len += Parcel::GetUInt32Len(); // protocolVersion_
     len += Parcel::GetIntLen(); // sendCode_
     len += Parcel::GetUInt32Len(); // softwareVersion_
-    uint32_t schemLen = Parcel::GetStringLen(schema_);
-    if (schemLen == 0) {
-        LOGE("[AbilitySyncRequestPacket][CalculateLen] schemLen err!");
+    uint32_t schemaLen = Parcel::GetStringLen(schema_);
+    if (schemaLen == 0) {
+        LOGE("[AbilitySyncRequestPacket][CalculateLen] schemaLen err!");
         return 0;
     }
-    len += schemLen;
+    len += schemaLen;
     len += Parcel::GetIntLen(); // secLabel_
     len += Parcel::GetIntLen(); // secFlag_
     len += Parcel::GetUInt32Len(); // schemaType_
@@ -145,7 +145,7 @@ uint32_t AbilitySyncRequestPacket::CalculateLen() const
     // the reason why not 8-byte align is that old version is not 8-byte align
     // so it is not possible to set 8-byte align for high version.
     if (len > INT32_MAX) {
-        LOGE("[AbilitySyncRequestPacket][CalculateLen]  err len:%" PRIu64, len);
+        LOGE("[AbilitySyncRequestPacket][CalculateLen] err len:%" PRIu64, len);
         return 0;
     }
     return len;
@@ -284,12 +284,12 @@ uint32_t AbilitySyncAckPacket::CalculateLen() const
     len += Parcel::GetUInt32Len();
     len += Parcel::GetUInt32Len();
     len += Parcel::GetIntLen();
-    uint32_t schemLen = Parcel::GetStringLen(schema_);
-    if (schemLen == 0) {
-        LOGE("[AbilitySyncAckPacket][CalculateLen] schemLen err!");
+    uint32_t schemaLen = Parcel::GetStringLen(schema_);
+    if (schemaLen == 0) {
+        LOGE("[AbilitySyncAckPacket][CalculateLen] schemaLen err!");
         return 0;
     }
-    len += schemLen;
+    len += schemaLen;
     len += Parcel::GetIntLen(); // secLabel_
     len += Parcel::GetIntLen(); // secFlag_
     len += Parcel::GetUInt32Len(); // schemaType_
@@ -299,7 +299,7 @@ uint32_t AbilitySyncAckPacket::CalculateLen() const
     len += DbAbility::CalculateLen(dbAbility_); // dbAbility_
     len += SchemaNegotiate::CalculateParcelLen(relationalSyncOpinion_);
     if (len > INT32_MAX) {
-        LOGE("[AbilitySyncAckPacket][CalculateLen]  err len:%" PRIu64, len);
+        LOGE("[AbilitySyncAckPacket][CalculateLen] err len:%" PRIu64, len);
         return 0;
     }
     return len;
@@ -471,7 +471,6 @@ int AbilitySync::AckNotifyRecv(const Message *message, ISyncTaskContext *context
     LOGI("[AckNotifyRecv] receive dev = %s ack notify, remoteSoftwareVersion = %u, ackCode = %d",
         STR_MASK(deviceId_), remoteSoftwareVersion, errCode);
     if (errCode == E_OK) {
-        (static_cast<SingleVerSyncTaskContext *>(context))->SetIsSchemaSync(true);
         ackCode = AbilitySync::LAST_NOTIFY;
     }
     (void)SendAckWithEmptySchema(message, ackCode, true);
@@ -1145,7 +1144,7 @@ void AbilitySync::HandleKvAckSchemaParam(const AbilitySyncAckPacket *recvPacket,
     SyncOpinion syncOpinion = SchemaNegotiate::MakeLocalSyncOpinion(localSchema, remoteSchema, remoteSchemaType);
     SyncStrategy localStrategy = SchemaNegotiate::ConcludeSyncStrategy(syncOpinion, remoteOpinion);
     SetAbilityAckSyncOpinionInfo(sendPacket, syncOpinion);
-    (static_cast<SingleVerKvSyncTaskContext *>(context))->SetSyncStrategy(localStrategy);
+    (static_cast<SingleVerKvSyncTaskContext *>(context))->SetSyncStrategy(localStrategy, true);
 }
 
 int AbilitySync::HandleRelationAckSchemaParam(const AbilitySyncAckPacket *recvPacket, AbilitySyncAckPacket &sendPacket,
@@ -1157,7 +1156,7 @@ int AbilitySync::HandleRelationAckSchemaParam(const AbilitySyncAckPacket *recvPa
     auto localOpinion = SchemaNegotiate::MakeLocalSyncOpinion(localSchema, remoteSchema, remoteSchemaType);
     auto localStrategy = SchemaNegotiate::ConcludeSyncStrategy(localOpinion,
         recvPacket->GetRelationalSyncOpinion());
-    (static_cast<SingleVerRelationalSyncTaskContext *>(context))->SetRelationalSyncStrategy(localStrategy);
+    (static_cast<SingleVerRelationalSyncTaskContext *>(context))->SetRelationalSyncStrategy(localStrategy, true);
     int errCode = (static_cast<RelationalDBSyncInterface *>(storageInterface_))->
         CreateDistributedDeviceTable(context->GetDeviceId(), localStrategy);
     if (errCode != E_OK) {
@@ -1181,9 +1180,9 @@ int AbilitySync::AckRecvWithHighVersion(const Message *message, ISyncTaskContext
     }
     auto singleVerContext = static_cast<SingleVerSyncTaskContext *>(context);
     auto query = singleVerContext->GetQuery();
-    bool permitSync = (singleVerContext->GetSyncStrategy(query)).permitSync;
-    if (!permitSync) {
-        (static_cast<SingleVerSyncTaskContext *>(context))->SetTaskErrCode(-E_SCHEMA_MISMATCH);
+    std::pair<bool, bool> schemaSyncStatus = (singleVerContext->GetSchemaSyncStatus(query));
+    if (!schemaSyncStatus.first) {
+        singleVerContext->SetTaskErrCode(-E_SCHEMA_MISMATCH);
         LOGE("[AbilitySync][AckRecv] scheme check failed");
         return -E_SCHEMA_MISMATCH;
     }
@@ -1196,9 +1195,8 @@ int AbilitySync::AckRecvWithHighVersion(const Message *message, ISyncTaskContext
         }
     }
     DbAbility remoteDbAbility = packet->GetDbAbility();
-    (static_cast<SingleVerSyncTaskContext *>(context))->SetDbAbility(remoteDbAbility);
+    singleVerContext->SetDbAbility(remoteDbAbility);
     (void)SendAck(message, AbilitySync::CHECK_SUCCESS, true, ackPacket);
-    (static_cast<SingleVerSyncTaskContext *>(context))->SetIsSchemaSync(true);
     return E_OK;
 }
 } // namespace DistributedDB
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/syncer/src/commit_history_sync.cpp b/frameworks/libs/distributeddb/syncer/src/commit_history_sync.cpp
index bc22cff8769e652d8176381b48ce16daa8384a9f..ea62b45e0ceb7b605ccca4d088a6778496cf6e71 100644
--- a/frameworks/libs/distributeddb/syncer/src/commit_history_sync.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/commit_history_sync.cpp
@@ -372,6 +372,9 @@ int CommitHistorySync::RequestPacketSerialization(uint8_t *buffer, uint32_t leng
         return -E_SECUREC_ERROR;
     }
     parcel.EightByteAlign();
+    if (parcel.IsError()) { // almost success
+        return -E_INVALID_ARGS;
+    }
     return errCode;
 }
 
@@ -462,18 +465,14 @@ int CommitHistorySync::AckPacketSerialization(uint8_t *buffer, uint32_t length,
     packet->GetData(commits);
     packet->GetErrorCode(ackErrCode);
     // errCode Serialization
-    int errCode = parcel.WriteInt(ackErrCode);
-    if (errCode != E_OK) {
-        return -E_SECUREC_ERROR;
-    }
-    errCode = parcel.WriteUInt32(packet->GetVersion());
-    if (errCode != E_OK) {
-        return -E_SECUREC_ERROR;
-    }
+    parcel.WriteInt(ackErrCode);
+    parcel.WriteUInt32(packet->GetVersion());
     parcel.EightByteAlign();
-
+    if (parcel.IsError()) { // almost success
+        return -E_INVALID_ARGS;
+    }
     // commits vector Serialization
-    errCode = parcel.WriteMultiVerCommits(commits);
+    int errCode = parcel.WriteMultiVerCommits(commits);
     if (errCode != E_OK) {
         return -E_SECUREC_ERROR;
     }
@@ -482,6 +481,9 @@ int CommitHistorySync::AckPacketSerialization(uint8_t *buffer, uint32_t length,
         return -E_SECUREC_ERROR;
     }
     parcel.EightByteAlign();
+    if (parcel.IsError()) { // almost success
+        return -E_INVALID_ARGS;
+    }
     return errCode;
 }
 
@@ -498,6 +500,9 @@ int CommitHistorySync::AckPacketDeSerialization(const uint8_t *buffer, uint32_t
     packLen += parcel.ReadInt(pktErrCode);
     packLen += parcel.ReadUInt32(version);
     parcel.EightByteAlign();
+    if (parcel.IsError()) {
+        return -E_PARSE_FAIL;
+    }
     packLen = Parcel::GetEightByteAlign(packLen);
     // commits vector DeSerialization
     packLen += parcel.ReadMultiVerCommits(commits);
diff --git a/frameworks/libs/distributeddb/syncer/src/generic_syncer.cpp b/frameworks/libs/distributeddb/syncer/src/generic_syncer.cpp
index f4657850967dc46e19860b273269b1a09356d59d..511a009a2488229a769e9bd84e9be12fa74a8198 100644
--- a/frameworks/libs/distributeddb/syncer/src/generic_syncer.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/generic_syncer.cpp
@@ -30,6 +30,7 @@
 #include "device_manager.h"
 #include "db_constant.h"
 #include "ability_sync.h"
+#include "generic_single_ver_kv_entry.h"
 #include "single_ver_serialize_manager.h"
 
 namespace DistributedDB {
@@ -68,12 +69,8 @@ GenericSyncer::~GenericSyncer()
         }
         syncEngine_ = nullptr;
     }
-    if (timeChangedListener_ != nullptr) {
-        timeChangedListener_->Drop(true);
-        timeChangedListener_ = nullptr;
-    }
-    timeHelper_ = nullptr;
-    metadata_ = nullptr;
+    ReleaseInnerResource();
+    std::lock_guard<std::mutex> lock(syncerLock_);
     syncInterface_ = nullptr;
 }
 
@@ -135,42 +132,18 @@ int GenericSyncer::Initialize(ISyncInterface *syncInterface, bool isNeedActive)
         initialized_ = true;
     }
 
-    // RegConnectCallback may start an auto sync, this function can not in syncerLock_
-    syncEngine_->RegConnectCallback();
+    // StartCommunicator may start an auto sync, this function can not in syncerLock_
+    syncEngine_->StartCommunicator();
     return E_OK;
 }
 
 int GenericSyncer::Close(bool isClosedOperation)
 {
-    {
-        std::lock_guard<std::mutex> lock(syncerLock_);
-        if (!initialized_) {
-            if (isClosedOperation) {
-                timeHelper_ = nullptr;
-                metadata_ = nullptr;
-            }
-            LOGW("[Syncer] Syncer[%s] don't need to close, because it has not been init", label_.c_str());
-            return -E_NOT_INIT;
-        }
-        initialized_ = false;
-        if (closing_) {
-            LOGE("[Syncer] Syncer is closing, return!");
-            return -E_BUSY;
-        }
-        closing_ = true;
-    }
-    ClearSyncOperations(isClosedOperation);
-    if (syncEngine_ != nullptr) {
-        syncEngine_->Close();
-        LOGD("[Syncer] Close SyncEngine!");
-        std::lock_guard<std::mutex> lock(syncerLock_);
-        closing_ = false;
-    }
-    if (isClosedOperation) {
-        timeHelper_ = nullptr;
-        metadata_ = nullptr;
+    int errCode = CloseInner(isClosedOperation);
+    if (errCode != -E_BUSY && isClosedOperation) {
+        ReleaseInnerResource();
     }
-    return E_OK;
+    return errCode;
 }
 
 int GenericSyncer::Sync(const std::vector<std::string> &devices, int mode,
@@ -230,7 +203,6 @@ int GenericSyncer::PrepareSync(const SyncParma &param, uint32_t syncId, uint64_t
         SubQueuedSyncSize();
         return -E_OUT_OF_MEMORY;
     }
-    operation->SetIdentifier(syncInterface_->GetIdentifier());
     {
         std::lock_guard<std::mutex> autoLock(syncerLock_);
         PerformanceAnalysis::GetInstance()->StepTimeRecordStart(PT_TEST_RECORDS::RECORD_SYNC_TOTAL);
@@ -707,18 +679,22 @@ int GenericSyncer::GetLocalIdentity(std::string &outTarget) const
 
 void GenericSyncer::GetOnlineDevices(std::vector<std::string> &devices) const
 {
-    // Get devices from AutoLaunch first.
-    if (syncInterface_ == nullptr) {
-        LOGI("[Syncer] GetOnlineDevices syncInterface_ is nullptr");
-        return;
-    }
-    bool isSyncDualTupleMode = syncInterface_->GetDbProperties().GetBoolProp(KvDBProperties::SYNC_DUAL_TUPLE_MODE,
-        false);
     std::string identifier;
-    if (isSyncDualTupleMode) {
-        identifier = syncInterface_->GetDbProperties().GetStringProp(KvDBProperties::DUAL_TUPLE_IDENTIFIER_DATA, "");
-    } else {
-        identifier = syncInterface_->GetDbProperties().GetStringProp(KvDBProperties::IDENTIFIER_DATA, "");
+    {
+        std::lock_guard<std::mutex> lock(syncerLock_);
+        // Get devices from AutoLaunch first.
+        if (syncInterface_ == nullptr) {
+            LOGI("[Syncer] GetOnlineDevices syncInterface_ is nullptr");
+            return;
+        }
+        bool isSyncDualTupleMode = syncInterface_->GetDbProperties().GetBoolProp(KvDBProperties::SYNC_DUAL_TUPLE_MODE,
+            false);
+        if (isSyncDualTupleMode) {
+            identifier = syncInterface_->GetDbProperties().GetStringProp(KvDBProperties::DUAL_TUPLE_IDENTIFIER_DATA,
+                "");
+        } else {
+            identifier = syncInterface_->GetDbProperties().GetStringProp(KvDBProperties::IDENTIFIER_DATA, "");
+        }
     }
     RuntimeContext::GetInstance()->GetAutoLaunchSyncDevices(identifier, devices);
     if (!devices.empty()) {
@@ -726,7 +702,7 @@ void GenericSyncer::GetOnlineDevices(std::vector<std::string> &devices) const
     }
     std::lock_guard<std::mutex> lock(syncerLock_);
     if (closing_) {
-        LOGE("[Syncer] Syncer is closing, return!");
+        LOGW("[Syncer] Syncer is closing, return!");
         return;
     }
     if (syncEngine_ != nullptr) {
@@ -760,7 +736,7 @@ std::string GenericSyncer::GetSyncDevicesStr(const std::vector<std::string> &dev
 {
     std::string syncDevices;
     for (const auto &dev:devices) {
-        syncDevices += STR_MASK(dev);
+        syncDevices += DBCommon::StringMasking(dev);
         syncDevices += ",";
     }
     return syncDevices.substr(0, syncDevices.size() - 1);
@@ -773,7 +749,7 @@ int GenericSyncer::StatusCheck() const
         return -E_NOT_INIT;
     }
     if (closing_) {
-        LOGE("[Syncer] Syncer is closing, return!");
+        LOGW("[Syncer] Syncer is closing, return!");
         return -E_BUSY;
     }
     return E_OK;
@@ -876,23 +852,7 @@ int GenericSyncer::InitTimeChangedListener()
     }
     timeChangedListener_ = RuntimeContext::GetInstance()->RegisterTimeChangedLister(
         [this](void *changedOffset) {
-            if (changedOffset == nullptr || metadata_ == nullptr || syncInterface_ == nullptr) {
-                return;
-            }
-            TimeOffset changedTimeOffset = *(reinterpret_cast<TimeOffset *>(changedOffset)) *
-                static_cast<TimeOffset>(TimeHelper::TO_100_NS);
-            TimeOffset orgOffset = this->metadata_->GetLocalTimeOffset() - changedTimeOffset;
-            Timestamp currentSysTime = TimeHelper::GetSysCurrentTime();
-            Timestamp maxItemTime = 0;
-            this->syncInterface_->GetMaxTimestamp(maxItemTime);
-            if (static_cast<Timestamp>(orgOffset + currentSysTime) > TimeHelper::BUFFER_VALID_TIME) {
-                orgOffset = static_cast<Timestamp>(TimeHelper::BUFFER_VALID_TIME) -
-                    currentSysTime + TimeHelper::MS_TO_100_NS;
-            }
-            if (static_cast<Timestamp>(currentSysTime + orgOffset) <= maxItemTime) {
-                orgOffset = static_cast<TimeOffset>(maxItemTime - currentSysTime + TimeHelper::MS_TO_100_NS); // 1ms
-            }
-            this->metadata_->SaveLocalTimeOffset(orgOffset);
+            RecordTimeChangeOffset(changedOffset);
         }, errCode);
     if (timeChangedListener_ == nullptr) {
         LOGE("[GenericSyncer] Init RegisterTimeChangedLister failed");
@@ -900,4 +860,123 @@ int GenericSyncer::InitTimeChangedListener()
     }
     return E_OK;
 }
+
+void GenericSyncer::ReleaseInnerResource()
+{
+    NotificationChain::Listener *timeChangedListener = nullptr;
+    {
+        std::lock_guard<std::mutex> lock(syncerLock_);
+        if (timeChangedListener_ != nullptr) {
+            timeChangedListener = timeChangedListener_;
+            timeChangedListener_ = nullptr;
+        }
+        timeHelper_ = nullptr;
+        metadata_ = nullptr;
+    }
+    if (timeChangedListener != nullptr) {
+        timeChangedListener->Drop(true);
+    }
+}
+
+void GenericSyncer::RecordTimeChangeOffset(void *changedOffset)
+{
+    std::shared_ptr<Metadata> metadata = nullptr;
+    ISyncInterface *storage = nullptr;
+    {
+        std::lock_guard<std::mutex> lock(syncerLock_);
+        if (changedOffset == nullptr || metadata_ == nullptr || syncInterface_ == nullptr) {
+            return;
+        }
+        storage = syncInterface_;
+        metadata = metadata_;
+        storage->IncRefCount();
+    }
+    TimeOffset changedTimeOffset = *(reinterpret_cast<TimeOffset *>(changedOffset)) *
+        static_cast<TimeOffset>(TimeHelper::TO_100_NS);
+    TimeOffset orgOffset = metadata->GetLocalTimeOffset() - changedTimeOffset;
+    TimeOffset currentSysTime = static_cast<TimeOffset>(TimeHelper::GetSysCurrentTime());
+    Timestamp maxItemTime = 0;
+    storage->GetMaxTimestamp(maxItemTime);
+    if ((orgOffset + currentSysTime) > TimeHelper::BUFFER_VALID_TIME) {
+        orgOffset = TimeHelper::BUFFER_VALID_TIME -
+            currentSysTime + static_cast<TimeOffset>(TimeHelper::MS_TO_100_NS);
+    }
+    if ((currentSysTime + orgOffset) <= static_cast<TimeOffset>(maxItemTime)) {
+        orgOffset = static_cast<TimeOffset>(maxItemTime) - currentSysTime +
+            static_cast<TimeOffset>(TimeHelper::MS_TO_100_NS); // 1ms
+    }
+    metadata->SaveLocalTimeOffset(orgOffset);
+    storage->DecRefCount();
+}
+
+int GenericSyncer::CloseInner(bool isClosedOperation)
+{
+    {
+        std::lock_guard<std::mutex> lock(syncerLock_);
+        if (!initialized_) {
+            LOGW("[Syncer] Syncer[%s] don't need to close, because it has not been init", label_.c_str());
+            return -E_NOT_INIT;
+        }
+        initialized_ = false;
+        if (closing_) {
+            LOGE("[Syncer] Syncer is closing, return!");
+            return -E_BUSY;
+        }
+        closing_ = true;
+    }
+    ClearSyncOperations(isClosedOperation);
+    if (syncEngine_ != nullptr) {
+        syncEngine_->Close();
+        LOGD("[Syncer] Close SyncEngine!");
+        std::lock_guard<std::mutex> lock(syncerLock_);
+        closing_ = false;
+    }
+    return E_OK;
+}
+
+int GenericSyncer::GetSyncDataSize(const std::string &device, size_t &size) const
+{
+    uint64_t localWaterMark = 0;
+    {
+        std::lock_guard<std::mutex> lock(syncerLock_);
+        if (metadata_ == nullptr || syncInterface_ == nullptr) {
+            return -E_INTERNAL_ERROR;
+        }
+        if (closing_) {
+            LOGE("[Syncer] Syncer is closing, return!");
+            return -E_BUSY;
+        }
+        syncInterface_->IncRefCount();
+        metadata_->GetLocalWaterMark(device, localWaterMark);
+    }
+    uint32_t expectedMtuSize = 1024u * 1024u; // 1M
+    DataSizeSpecInfo syncDataSizeInfo = {expectedMtuSize, static_cast<size_t>(MAX_TIMESTAMP)};
+    std::vector<SendDataItem> outData;
+    ContinueToken token = nullptr;
+    int errCode = static_cast<SyncGenericInterface *>(syncInterface_)->GetSyncData(localWaterMark, MAX_TIMESTAMP,
+        outData, token, syncDataSizeInfo);
+    if (token != nullptr) {
+        static_cast<SyncGenericInterface *>(syncInterface_)->ReleaseContinueToken(token);
+        token = nullptr;
+    }
+    if ((errCode != E_OK) && (errCode != -E_UNFINISHED)) {
+        LOGE("calculate sync data size failed %d", errCode);
+        syncInterface_->DecRefCount();
+        return errCode;
+    }
+    uint32_t totalLen = 0;
+    if (errCode == -E_UNFINISHED) {
+        totalLen = expectedMtuSize;
+    } else {
+        totalLen = GenericSingleVerKvEntry::CalculateLens(outData, SOFTWARE_VERSION_CURRENT);
+    }
+    for (auto &entry : outData) {
+        delete entry;
+        entry = nullptr;
+    }
+    syncInterface_->DecRefCount();
+    // if larger than 1M, return 1M
+    size = (totalLen >= expectedMtuSize) ? expectedMtuSize : totalLen;
+    return E_OK;
+}
 } // namespace DistributedDB
diff --git a/frameworks/libs/distributeddb/syncer/src/generic_syncer.h b/frameworks/libs/distributeddb/syncer/src/generic_syncer.h
index 48e2ecfa67cafcc5287015c0dc88544a6ad7f971..ae233a9d42200c655350670fc4dc762814d1a48c 100644
--- a/frameworks/libs/distributeddb/syncer/src/generic_syncer.h
+++ b/frameworks/libs/distributeddb/syncer/src/generic_syncer.h
@@ -102,6 +102,8 @@ public:
     int RemoteQuery(const std::string &device, const RemoteCondition &condition,
         uint64_t timeout, uint64_t connectionId, std::shared_ptr<ResultSet> &result) override;
 
+    int GetSyncDataSize(const std::string &device, size_t &size) const override;
+
 protected:
 
     // trigger query auto sync or auto subscribe
@@ -178,6 +180,12 @@ protected:
 
     int InitTimeChangedListener();
 
+    void ReleaseInnerResource();
+
+    void RecordTimeChangeOffset(void *changedOffset);
+
+    int CloseInner(bool isClosedOperation);
+
     static int SyncModuleInit();
 
     static int SyncResourceInit();
diff --git a/frameworks/libs/distributeddb/syncer/src/isync_engine.h b/frameworks/libs/distributeddb/syncer/src/isync_engine.h
index a0fc131cec09cd02758a59fec29887647f9ad7f1..eb0622f1e2745a5ed17fcd3368b9a5bae359c7a7 100644
--- a/frameworks/libs/distributeddb/syncer/src/isync_engine.h
+++ b/frameworks/libs/distributeddb/syncer/src/isync_engine.h
@@ -49,8 +49,8 @@ public:
     // Get Online devices
     virtual void GetOnlineDevices(std::vector<std::string> &devices) const = 0;
 
-    // Register the device connect callback, this function must be called after Engine initted
-    virtual void RegConnectCallback() = 0;
+    // Register the device connect callback and active communicator, this function must be called after Engine initted
+    virtual void StartCommunicator() = 0;
 
     // Get the database identifier
     virtual std::string GetLabel() const = 0;
diff --git a/frameworks/libs/distributeddb/syncer/src/multi_ver_data_sync.cpp b/frameworks/libs/distributeddb/syncer/src/multi_ver_data_sync.cpp
index 9bc8c84f7d577b5dd5ba893b3ddcf160662bd547..bb41737f57678a468e749011e2cef7b0e8677f59 100644
--- a/frameworks/libs/distributeddb/syncer/src/multi_ver_data_sync.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/multi_ver_data_sync.cpp
@@ -408,10 +408,10 @@ int MultiVerDataSync::RequestPacketDeSerialization(const uint8_t *buffer, uint32
     Parcel parcel(const_cast<uint8_t *>(buffer), length);
     int32_t pktErrCode;
     uint64_t packLen = parcel.ReadInt(pktErrCode);
+    parcel.EightByteAlign();
     if (parcel.IsError()) {
         return -E_INVALID_ARGS;
     }
-    parcel.EightByteAlign();
     packLen = Parcel::GetEightByteAlign(packLen);
     // commit DeSerialization
     packLen += parcel.ReadMultiVerCommit(commit);
diff --git a/frameworks/libs/distributeddb/syncer/src/query_sync_water_mark_helper.cpp b/frameworks/libs/distributeddb/syncer/src/query_sync_water_mark_helper.cpp
index c81b662eb741a969cbf84cc232cbd2762d129abe..b4ac54b303cd01162f56758316f0919691f9d53e 100644
--- a/frameworks/libs/distributeddb/syncer/src/query_sync_water_mark_helper.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/query_sync_water_mark_helper.cpp
@@ -121,8 +121,7 @@ int QuerySyncWaterMarkHelper::GetQueryWaterMarkInCacheAndDb(const std::string &c
 int QuerySyncWaterMarkHelper::GetQueryWaterMark(const std::string &queryIdentify, const std::string &deviceId,
     QueryWaterMark &queryWaterMark)
 {
-    std::string cacheKey;
-    GetHashQuerySyncDeviceId(deviceId, queryIdentify, cacheKey);
+    std::string cacheKey = GetHashQuerySyncDeviceId(deviceId, queryIdentify);
     std::lock_guard<std::mutex> autoLock(queryWaterMarkLock_);
     return GetQueryWaterMarkInCacheAndDb(cacheKey, queryWaterMark);
 }
@@ -130,8 +129,7 @@ int QuerySyncWaterMarkHelper::GetQueryWaterMark(const std::string &queryIdentify
 int QuerySyncWaterMarkHelper::SetRecvQueryWaterMark(const std::string &queryIdentify,
     const std::string &deviceId, const WaterMark &waterMark)
 {
-    std::string cacheKey;
-    GetHashQuerySyncDeviceId(deviceId, queryIdentify, cacheKey);
+    std::string cacheKey = GetHashQuerySyncDeviceId(deviceId, queryIdentify);
     std::lock_guard<std::mutex> autoLock(queryWaterMarkLock_);
     return SetRecvQueryWaterMarkWithoutLock(cacheKey, waterMark);
 }
@@ -139,8 +137,7 @@ int QuerySyncWaterMarkHelper::SetRecvQueryWaterMark(const std::string &queryIden
 int QuerySyncWaterMarkHelper::SetLastQueryTime(const std::string &queryIdentify,
     const std::string &deviceId, const Timestamp &timestamp)
 {
-    std::string cacheKey;
-    GetHashQuerySyncDeviceId(deviceId, queryIdentify, cacheKey);
+    std::string cacheKey = GetHashQuerySyncDeviceId(deviceId, queryIdentify);
     std::lock_guard<std::mutex> autoLock(queryWaterMarkLock_);
     QueryWaterMark queryWaterMark;
     int errCode = GetQueryWaterMarkInCacheAndDb(cacheKey, queryWaterMark);
@@ -166,8 +163,7 @@ int QuerySyncWaterMarkHelper::SetRecvQueryWaterMarkWithoutLock(const std::string
 int QuerySyncWaterMarkHelper::SetSendQueryWaterMark(const std::string &queryIdentify,
     const std::string &deviceId, const WaterMark &waterMark)
 {
-    std::string cacheKey;
-    GetHashQuerySyncDeviceId(deviceId, queryIdentify, cacheKey);
+    std::string cacheKey = GetHashQuerySyncDeviceId(deviceId, queryIdentify);
     QueryWaterMark queryWaterMark;
     std::lock_guard<std::mutex> autoLock(queryWaterMarkLock_);
     int errCode = GetQueryWaterMarkInCacheAndDb(cacheKey, queryWaterMark);
@@ -288,10 +284,10 @@ uint64_t QuerySyncWaterMarkHelper::CalculateQueryWaterMarkSize(const QueryWaterM
     return length;
 }
 
-void QuerySyncWaterMarkHelper::GetHashQuerySyncDeviceId(const DeviceID &deviceId,
-    const DeviceID &queryId, DeviceID &hashQuerySyncId)
+DeviceID QuerySyncWaterMarkHelper::GetHashQuerySyncDeviceId(const DeviceID &deviceId, const DeviceID &queryId)
 {
     std::lock_guard<std::mutex> autoLock(queryWaterMarkLock_);
+    DeviceID hashQuerySyncId;
     if (deviceIdToHashQuerySyncIdMap_[deviceId].count(queryId) == 0) {
         // do not modify this
         hashQuerySyncId = DBConstant::QUERY_SYNC_PREFIX_KEY + DBCommon::TransferHashString(deviceId) + queryId;
@@ -299,19 +295,18 @@ void QuerySyncWaterMarkHelper::GetHashQuerySyncDeviceId(const DeviceID &deviceId
     } else {
         hashQuerySyncId = deviceIdToHashQuerySyncIdMap_[deviceId][queryId];
     }
+    return hashQuerySyncId;
 }
 
 int QuerySyncWaterMarkHelper::GetDeleteSyncWaterMark(const std::string &deviceId, DeleteWaterMark &deleteWaterMark)
 {
-    std::string hashId;
-    GetHashDeleteSyncDeviceId(deviceId, hashId);
+    std::string hashId = GetHashDeleteSyncDeviceId(deviceId);
     return GetDeleteWaterMarkFromCache(hashId, deleteWaterMark);
 }
 
 int QuerySyncWaterMarkHelper::SetSendDeleteSyncWaterMark(const DeviceID &deviceId, const WaterMark &waterMark)
 {
-    std::string hashId;
-    GetHashDeleteSyncDeviceId(deviceId, hashId);
+    std::string hashId = GetHashDeleteSyncDeviceId(deviceId);
     DeleteWaterMark deleteWaterMark;
     GetDeleteWaterMarkFromCache(hashId, deleteWaterMark);
     deleteWaterMark.sendWaterMark = waterMark;
@@ -321,8 +316,7 @@ int QuerySyncWaterMarkHelper::SetSendDeleteSyncWaterMark(const DeviceID &deviceI
 
 int QuerySyncWaterMarkHelper::SetRecvDeleteSyncWaterMark(const DeviceID &deviceId, const WaterMark &waterMark)
 {
-    std::string hashId;
-    GetHashDeleteSyncDeviceId(deviceId, hashId);
+    std::string hashId = GetHashDeleteSyncDeviceId(deviceId);
     DeleteWaterMark deleteWaterMark;
     GetDeleteWaterMarkFromCache(hashId, deleteWaterMark);
     deleteWaterMark.recvWaterMark = waterMark;
@@ -402,8 +396,9 @@ int QuerySyncWaterMarkHelper::SaveDeleteWaterMarkToDB(const DeviceID &hashDevice
     return errCode;
 }
 
-void QuerySyncWaterMarkHelper::GetHashDeleteSyncDeviceId(const DeviceID &deviceId, DeviceID &hashDeleteSyncId)
+DeviceID QuerySyncWaterMarkHelper::GetHashDeleteSyncDeviceId(const DeviceID &deviceId)
 {
+    DeviceID hashDeleteSyncId;
     std::lock_guard<std::mutex> autoLock(deleteSyncLock_);
     if (deviceIdToHashDeleteSyncIdMap_.count(deviceId) == 0) {
         hashDeleteSyncId = DBConstant::DELETE_SYNC_PREFIX_KEY + DBCommon::TransferHashString(deviceId);
@@ -411,6 +406,7 @@ void QuerySyncWaterMarkHelper::GetHashDeleteSyncDeviceId(const DeviceID &deviceI
     } else {
         hashDeleteSyncId = deviceIdToHashDeleteSyncIdMap_[deviceId];
     }
+    return hashDeleteSyncId;
 }
 
 int QuerySyncWaterMarkHelper::SerializeDeleteWaterMark(const DeleteWaterMark &deleteWaterMark,
@@ -513,26 +509,24 @@ int QuerySyncWaterMarkHelper::RemoveLeastUsedQuerySyncItems(const std::vector<Ke
 int QuerySyncWaterMarkHelper::ResetRecvQueryWaterMark(const DeviceID &deviceId, const std::string &tableName)
 {
     // lock prevent other thread modify queryWaterMark at this moment
-    {
-        std::lock_guard<std::mutex> autoLock(queryWaterMarkLock_);
-        std::string prefixKeyStr = DBConstant::QUERY_SYNC_PREFIX_KEY + DBCommon::TransferHashString(deviceId);
-        if (!tableName.empty()) {
-            std::string hashTableName = DBCommon::TransferHashString(tableName);
-            std::string hexTableName = DBCommon::TransferStringToHex(hashTableName);
-            prefixKeyStr += hexTableName;
-        }
+    std::lock_guard<std::mutex> autoLock(queryWaterMarkLock_);
+    std::string prefixKeyStr = DBConstant::QUERY_SYNC_PREFIX_KEY + DBCommon::TransferHashString(deviceId);
+    if (!tableName.empty()) {
+        std::string hashTableName = DBCommon::TransferHashString(tableName);
+        std::string hexTableName = DBCommon::TransferStringToHex(hashTableName);
+        prefixKeyStr += hexTableName;
+    }
 
-        // remove in db
-        Key prefixKey;
-        DBCommon::StringToVector(prefixKeyStr, prefixKey);
-        int errCode = storage_->DeleteMetaDataByPrefixKey(prefixKey);
-        if (errCode != E_OK) {
-            LOGE("[META]ResetRecvQueryWaterMark fail errCode:%d", errCode);
-            return errCode;
-        }
-        // clean cache
-        querySyncCache_.RemoveWithPrefixKey(prefixKeyStr);
+    // remove in db
+    Key prefixKey;
+    DBCommon::StringToVector(prefixKeyStr, prefixKey);
+    int errCode = storage_->DeleteMetaDataByPrefixKey(prefixKey);
+    if (errCode != E_OK) {
+        LOGE("[META]ResetRecvQueryWaterMark fail errCode:%d", errCode);
+        return errCode;
     }
+    // clean cache
+    querySyncCache_.RemoveWithPrefixKey(prefixKeyStr);
     return E_OK;
 }
 }  // namespace DistributedDB
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/syncer/src/query_sync_water_mark_helper.h b/frameworks/libs/distributeddb/syncer/src/query_sync_water_mark_helper.h
index aef8c9930e6a04a94fce7f8383486fb3df2decdc..ab36f91eee88503a00ad43d30bc4c6488ce85e69 100644
--- a/frameworks/libs/distributeddb/syncer/src/query_sync_water_mark_helper.h
+++ b/frameworks/libs/distributeddb/syncer/src/query_sync_water_mark_helper.h
@@ -107,8 +107,7 @@ private:
 
     // get the querySync hashId in cache_ or generate one and then put it in to cache_
     // the hashId is made up of "QUERY_SYNC_PREFIX_KEY" + hash(deviceId) + queryId
-    void GetHashQuerySyncDeviceId(const DeviceID &deviceId,
-        const DeviceID &queryId, DeviceID &hashQuerySyncId);
+    DeviceID GetHashQuerySyncDeviceId(const DeviceID &deviceId, const DeviceID &queryId);
 
     // put queryWaterMark to lru cache_ and then save to db
     int UpdateCacheAndSave(const std::string &cacheKey, QueryWaterMark &queryWaterMark);
@@ -119,7 +118,7 @@ private:
 
     // get the deleteSync hashId in cache_ or generate one and then put it in to cache_
     // the hashId is made up of "DELETE_SYNC_PREFIX_KEY" + hash(deviceId)
-    void GetHashDeleteSyncDeviceId(const DeviceID &deviceId, DeviceID &hashDeleteSyncId);
+    DeviceID GetHashDeleteSyncDeviceId(const DeviceID &deviceId);
 
     int SaveDeleteWaterMarkToDB(const DeviceID &hashDeviceId, const DeleteWaterMark &deleteWaterMark);
 
diff --git a/frameworks/libs/distributeddb/syncer/src/remote_executor.cpp b/frameworks/libs/distributeddb/syncer/src/remote_executor.cpp
index cac8600fb7b073cd70b4222a55554cf5fcd7c5b1..f9461835a366ca3e2a7fb86804e4217a1827b22a 100644
--- a/frameworks/libs/distributeddb/syncer/src/remote_executor.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/remote_executor.cpp
@@ -175,36 +175,25 @@ int RemoteExecutor::ReceiveRemoteExecutorRequest(const std::string &targetDev, M
         }
         workingThreadsCount_++;
     }
-    RefObject::IncObjRef(this);
-    int errCode = RuntimeContext::GetInstance()->ScheduleTask([this]() {
-        bool empty = true;
-        do {
-            std::pair<std::string, Message *> entry;
-            {
-                std::lock_guard<std::mutex> autoLock(msgQueueLock_);
-                empty = searchMessageQueue_.empty();
-                if (empty) {
-                    workingThreadsCount_--;
-                    continue;
-                }
-                entry = searchMessageQueue_.front();
-                searchMessageQueue_.pop();
+    bool empty = true;
+    do {
+        std::pair<std::string, Message *> entry;
+        {
+            std::lock_guard<std::mutex> autoLock(msgQueueLock_);
+            empty = searchMessageQueue_.empty();
+            if (empty) {
+                workingThreadsCount_--;
+                continue;
             }
-            ParseOneRequestMessage(entry.first, entry.second);
-            delete entry.second;
-            entry.second = nullptr;
-        } while (!empty);
-        clearCV_.notify_one();
-        RefObject::DecObjRef(this);
-    });
-    if (errCode != E_OK) {
-        workingThreadsCount_--;
-        clearCV_.notify_one();
-        RefObject::DecObjRef(this);
-    } else {
-        errCode = -E_NOT_NEED_DELETE_MSG;
-    }
-    return errCode;
+            entry = searchMessageQueue_.front();
+            searchMessageQueue_.pop();
+        }
+        ParseOneRequestMessage(entry.first, entry.second);
+        delete entry.second;
+        entry.second = nullptr;
+    } while (!empty);
+    clearCV_.notify_one();
+    return -E_NOT_NEED_DELETE_MSG;
 }
 
 void RemoteExecutor::ParseOneRequestMessage(const std::string &device, Message *inMsg)
diff --git a/frameworks/libs/distributeddb/syncer/src/remote_executor_packet.cpp b/frameworks/libs/distributeddb/syncer/src/remote_executor_packet.cpp
index bbfda5685f4938af1d85548d75979dbff867d8bc..704ebd53f3f617387f5021fd5e11a64e6f4b3902 100644
--- a/frameworks/libs/distributeddb/syncer/src/remote_executor_packet.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/remote_executor_packet.cpp
@@ -259,7 +259,14 @@ int RemoteExecutorAckPacket::DeSerialization(Parcel &parcel)
     (void) parcel.ReadInt(ackCode_);
     (void) parcel.ReadUInt32(flag_);
     parcel.EightByteAlign();
-    (void) rowDataSet_.DeSerialize(parcel);
+    if (parcel.IsError()) {
+        LOGE("[RemoteExecutorAckPacket] DeSerialization failed");
+        return -E_INVALID_ARGS;
+    }
+    int errCode = rowDataSet_.DeSerialize(parcel);
+    if (errCode != E_OK) {
+        return errCode;
+    }
     if ((flag_ & ACK_FLAG_SECURITY_OPTION) != 0) {
         (void) parcel.ReadInt(secLabel_);
         (void) parcel.ReadInt(secFlag_);
diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync.cpp b/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync.cpp
index 291518d1f412107711b7293b604f5191234c253a..347dd51cf8ba7bb6d3860e387f922b2b0ff155f7 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync.cpp
@@ -187,7 +187,7 @@ int SingleVerDataSync::TryContinueSync(SingleVerSyncTaskContext *context, const
     }
     if (!isAllDataHasSent_) {
         return InnerSyncStart(context);
-    } else if (reSendMap_.size() == 0) {
+    } else if (reSendMap_.empty()) {
         context->SetOperationStatus(SyncOperation::OP_SEND_FINISHED);
         InnerClearSyncStatus();
         return -E_FINISHED;
@@ -320,12 +320,11 @@ int SingleVerDataSync::GetDataWithPerformanceRecord(SingleVerSyncTaskContext *co
 int SingleVerDataSync::GetUnsyncData(SingleVerSyncTaskContext *context, std::vector<SendDataItem> &outData,
     size_t packetSize)
 {
-    int errCode;
     WaterMark startMark = 0;
     SyncType curType = (context->IsQuerySync()) ? SyncType::QUERY_SYNC_TYPE : SyncType::MANUAL_FULL_SYNC_TYPE;
     GetLocalWaterMark(curType, context->GetQuerySyncId(), context, startMark);
     WaterMark endMark = MAX_TIMESTAMP;
-    if ((endMark == 0) || (startMark > endMark)) {
+    if ((startMark > endMark)) {
         return E_OK;
     }
     ContinueToken token = nullptr;
@@ -334,6 +333,7 @@ int SingleVerDataSync::GetUnsyncData(SingleVerSyncTaskContext *context, std::vec
         storage_->ReleaseContinueToken(token);
     }
     DataSizeSpecInfo syncDataSizeInfo = GetDataSizeSpecInfo(packetSize);
+    int errCode;
     if (curType != SyncType::QUERY_SYNC_TYPE) {
         errCode = storage_->GetSyncData(startMark, endMark, outData, token, syncDataSizeInfo);
     } else {
@@ -672,11 +672,11 @@ void SingleVerDataSync::FillDataRequestPacket(DataRequestPacket *packet, SingleV
 
 int SingleVerDataSync::RequestStart(SingleVerSyncTaskContext *context, int mode)
 {
-    if (!SingleVerDataSyncUtils::QuerySyncCheck(context)) {
-        context->SetTaskErrCode(-E_NOT_SUPPORT);
-        return -E_NOT_SUPPORT;
+    int errCode = QuerySyncCheck(context);
+    if (errCode != E_OK) {
+        return errCode;
     }
-    int errCode = RemoveDeviceDataIfNeed(context);
+    errCode = RemoveDeviceDataIfNeed(context);
     if (errCode != E_OK) {
         context->SetTaskErrCode(errCode);
         return errCode;
@@ -746,11 +746,11 @@ int SingleVerDataSync::PullRequestStart(SingleVerSyncTaskContext *context)
     if (context == nullptr) {
         return -E_INVALID_ARGS;
     }
-    if (!SingleVerDataSyncUtils::QuerySyncCheck(context)) {
-        context->SetTaskErrCode(-E_NOT_SUPPORT);
-        return -E_NOT_SUPPORT;
+    int errCode = QuerySyncCheck(context);
+    if (errCode != E_OK) {
+        return errCode;
     }
-    int errCode = RemoveDeviceDataIfNeed(context);
+    errCode = RemoveDeviceDataIfNeed(context);
     if (errCode != E_OK) {
         context->SetTaskErrCode(errCode);
         return errCode;
@@ -833,8 +833,8 @@ int SingleVerDataSync::PullResponseStart(SingleVerSyncTaskContext *context)
     return errCode;
 }
 
-void SingleVerDataSync::UpdateQueryPeerWaterMark(SyncType syncType, const std::string &queryId, SyncTimeRange &dataTime,
-    const SingleVerSyncTaskContext *context, UpdateWaterMark isUpdateWaterMark)
+void SingleVerDataSync::UpdateQueryPeerWaterMark(SyncType syncType, const std::string &queryId,
+    const SyncTimeRange &dataTime, const SingleVerSyncTaskContext *context, UpdateWaterMark isUpdateWaterMark)
 {
     WaterMark tmpPeerWatermark = dataTime.endTime;
     WaterMark tmpPeerDeletedWatermark = dataTime.deleteEndTime;
@@ -1489,14 +1489,14 @@ int SingleVerDataSync::CheckSchemaStrategy(SingleVerSyncTaskContext *context, co
         return -E_INVALID_ARGS;
     }
     auto query = packet->GetQuery();
-    SyncStrategy localStrategy = context->GetSyncStrategy(query);
-    if (!context->GetIsSchemaSync()) {
-        LOGE("[DataSync][CheckSchemaStrategy] isSchemaSync=%d check failed", context->GetIsSchemaSync());
+    std::pair<bool, bool> schemaSyncStatus = context->GetSchemaSyncStatus(query);
+    if (!schemaSyncStatus.second) {
+        LOGE("[DataSync][CheckSchemaStrategy] isSchemaSync=%d check failed", schemaSyncStatus.second);
         (void)SendDataAck(context, message, -E_NEED_ABILITY_SYNC, 0);
         return -E_NEED_ABILITY_SYNC;
     }
-    if (!localStrategy.permitSync) {
-        LOGE("[DataSync][CheckSchemaStrategy] Strategy permitSync=%d check failed", localStrategy.permitSync);
+    if (!schemaSyncStatus.first) {
+        LOGE("[DataSync][CheckSchemaStrategy] Strategy permitSync=%d check failed", schemaSyncStatus.first);
         (void)SendDataAck(context, message, -E_SCHEMA_MISMATCH, 0);
         return -E_SCHEMA_MISMATCH;
     }
@@ -2034,4 +2034,21 @@ void SingleVerDataSync::ClearDataMsg()
 {
     msgSchedule_.ClearMsg();
 }
+
+int SingleVerDataSync::QuerySyncCheck(SingleVerSyncTaskContext *context)
+{
+    if (context == nullptr) {
+        return -E_INVALID_ARGS;
+    }
+    bool isCheckStatus = false;
+    int errCode = SingleVerDataSyncUtils::QuerySyncCheck(context, isCheckStatus);
+    if (errCode != E_OK) {
+        return errCode;
+    }
+    if (!isCheckStatus) {
+        context->SetTaskErrCode(-E_NOT_SUPPORT);
+        return -E_NOT_SUPPORT;
+    }
+    return E_OK;
+}
 } // namespace DistributedDB
diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync.h b/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync.h
index 4e9343aece32f3d8adf78156db81dabb8398b361..d00eaeafe10266d9e6b3df47ffdec5da421253d4 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync.h
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync.h
@@ -180,7 +180,7 @@ protected:
 
     int SendDataPacket(SyncType syncType, const DataRequestPacket *packet, SingleVerSyncTaskContext *context);
 
-    void UpdateQueryPeerWaterMark(SyncType syncType, const std::string &queryId, SyncTimeRange &dataTime,
+    void UpdateQueryPeerWaterMark(SyncType syncType, const std::string &queryId, const SyncTimeRange &dataTime,
         const SingleVerSyncTaskContext *context, UpdateWaterMark isUpdateWaterMark);
 
     void UpdatePeerWaterMark(SyncType syncType, const std::string &queryId, const SingleVerSyncTaskContext *context,
@@ -242,6 +242,7 @@ protected:
     int UnsubscribeRequestRecv(SingleVerSyncTaskContext *context, const Message *message);
     int SendControlAck(SingleVerSyncTaskContext *context, const Message *message, int32_t recvCode,
         uint32_t controlCmdType, const CommErrHandler &handler = nullptr);
+    int QuerySyncCheck(SingleVerSyncTaskContext *context);
 
     uint32_t mtuSize_;
     SyncGenericInterface* storage_;
diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync_utils.cpp b/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync_utils.cpp
index 2827ef3758a52876d8ef91388e83bf89e9f1e98c..64adfc7de7ad40030a2420a72cafff614a80a8fc 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync_utils.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync_utils.cpp
@@ -20,29 +20,38 @@
 #include "log_print.h"
 #include "message.h"
 namespace DistributedDB {
-bool SingleVerDataSyncUtils::QuerySyncCheck(const SingleVerSyncTaskContext *context)
+int SingleVerDataSyncUtils::QuerySyncCheck(const SingleVerSyncTaskContext *context, bool &isCheckStatus)
 {
+    if (context == nullptr) {
+        isCheckStatus = false;
+        return -E_INVALID_ARGS;
+    }
     if (!context->IsQuerySync()) {
-        return true;
+        isCheckStatus = true;
+        return E_OK;
     }
     uint32_t version = std::min(context->GetRemoteSoftwareVersion(), SOFTWARE_VERSION_CURRENT);
     // for 101 version, no need to do abilitySync, just send request to remote
     if (version <= SOFTWARE_VERSION_RELEASE_1_0) {
-        return true;
+        isCheckStatus = true;
+        return E_OK;
     }
     if (version < SOFTWARE_VERSION_RELEASE_4_0) {
         LOGE("[SingleVerDataSync] not support query sync when remote ver lower than 104");
-        return false;
+        isCheckStatus = false;
+        return E_OK;
     }
     if (version < SOFTWARE_VERSION_RELEASE_5_0 && !(context->GetQuery().IsQueryOnlyByKey())) {
         LOGE("[SingleVerDataSync] remote version only support prefix key");
-        return false;
+        isCheckStatus = false;
+        return E_OK;
     }
-    if (context->GetQuery().HasInKeys() &&
-        context->IsNotSupportAbility(SyncConfig::INKEYS_QUERY)) {
-        return false;
+    if (context->GetQuery().HasInKeys() && context->IsNotSupportAbility(SyncConfig::INKEYS_QUERY)) {
+        isCheckStatus = false;
+        return E_OK;
     }
-    return true;
+    isCheckStatus = true;
+    return E_OK;
 }
 
 int SingleVerDataSyncUtils::AckMsgErrnoCheck(const SingleVerSyncTaskContext *context, const Message *message)
@@ -257,7 +266,7 @@ void SingleVerDataSyncUtils::FillControlRequestPacket(ControlRequestPacket *pack
     uint32_t version = std::min(context->GetRemoteSoftwareVersion(), SOFTWARE_VERSION_CURRENT);
     uint32_t flag = 0;
     if (context->GetMode() == SyncModeType::SUBSCRIBE_QUERY && context->IsAutoSubscribe()) {
-        flag = flag | SubscribeRequest::IS_AUTO_SUBSCRIBE;
+        flag = SubscribeRequest::IS_AUTO_SUBSCRIBE;
     }
     packet->SetPacketHead(E_OK, version, GetControlCmdType(context->GetMode()), flag);
     packet->SetQuery(context->GetQuery());
@@ -298,7 +307,7 @@ bool SingleVerDataSyncUtils::IsNeedTriggerQueryAutoSync(Message *inMsg, QuerySyn
     uint32_t controlCmdType = packet->GetcontrolCmdType();
     if (controlCmdType == ControlCmdType::SUBSCRIBE_QUERY_CMD && inMsg->GetMessageType() == TYPE_REQUEST) {
         const SubscribeRequest *subPacket = inMsg->GetObject<SubscribeRequest>();
-        if (packet == nullptr) {
+        if (subPacket == nullptr) {
             return false;
         }
         query = subPacket->GetQuery();
@@ -398,7 +407,7 @@ SyncTimeRange SingleVerDataSyncUtils::GetQuerySyncDataTimeRange(const std::vecto
     return dataTimeRange;
 }
 
-SyncTimeRange SingleVerDataSyncUtils::ReviseLocalMark(SyncType syncType, SyncTimeRange &dataTimeRange,
+SyncTimeRange SingleVerDataSyncUtils::ReviseLocalMark(SyncType syncType, const SyncTimeRange &dataTimeRange,
     UpdateWaterMark updateMark)
 {
     SyncTimeRange tmpDataTime = dataTimeRange;
diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync_utils.h b/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync_utils.h
index 09ff9780c55d029d9d311eb48936e2e84967b5ad..2ca8eee9f6af8ae1e3d0780fd39c98ff3da35252 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync_utils.h
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_data_sync_utils.h
@@ -21,7 +21,7 @@
 namespace DistributedDB {
 class SingleVerDataSyncUtils {
 public:
-    static bool QuerySyncCheck(const SingleVerSyncTaskContext *context);
+    static int QuerySyncCheck(const SingleVerSyncTaskContext *context, bool &isCheckStatus);
 
     static int AckMsgErrnoCheck(const SingleVerSyncTaskContext *context, const Message *message);
 
@@ -79,7 +79,8 @@ public:
     static SyncTimeRange GetQuerySyncDataTimeRange(const std::vector<SendDataItem> &inData, WaterMark localMark,
         WaterMark deleteLocalMark, UpdateWaterMark &isUpdate);
 
-    static SyncTimeRange ReviseLocalMark(SyncType syncType, SyncTimeRange &dataTimeRange, UpdateWaterMark updateMark);
+    static SyncTimeRange ReviseLocalMark(SyncType syncType, const SyncTimeRange &dataTimeRange,
+        UpdateWaterMark updateMark);
 
     static SyncTimeRange GetRecvDataTimeRange(SyncType syncType,
         const std::vector<SendDataItem> &data, UpdateWaterMark &isUpdate);
diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_kv_sync_task_context.cpp b/frameworks/libs/distributeddb/syncer/src/single_ver_kv_sync_task_context.cpp
index fb1f8ba5ff8b426281e2cb0d0a35a33efed1d0fb..5f74bb4efffe4f20a9b5c9cba2ca22d918581e66 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_kv_sync_task_context.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_kv_sync_task_context.cpp
@@ -34,17 +34,20 @@ std::string SingleVerKvSyncTaskContext::GetDeleteSyncId() const
     return GetDeviceId();
 }
 
-void SingleVerKvSyncTaskContext::SetSyncStrategy(const SyncStrategy &strategy)
+void SingleVerKvSyncTaskContext::SetSyncStrategy(const SyncStrategy &strategy, bool isSchemaSync)
 {
+    std::lock_guard<std::mutex> autoLock(syncStrategyMutex_);
     syncStrategy_.permitSync = strategy.permitSync;
     syncStrategy_.convertOnSend = strategy.convertOnSend;
     syncStrategy_.convertOnReceive = strategy.convertOnReceive;
     syncStrategy_.checkOnReceive = strategy.checkOnReceive;
+    isSchemaSync_ = isSchemaSync;
 }
 
-SyncStrategy SingleVerKvSyncTaskContext::GetSyncStrategy(QuerySyncObject &querySyncObject) const
+std::pair<bool, bool> SingleVerKvSyncTaskContext::GetSchemaSyncStatus(QuerySyncObject &querySyncObject) const
 {
+    std::lock_guard<std::mutex> autoLock(syncStrategyMutex_);
     (void) querySyncObject;
-    return syncStrategy_;
+    return {syncStrategy_.permitSync, isSchemaSync_};
 }
 }
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_kv_sync_task_context.h b/frameworks/libs/distributeddb/syncer/src/single_ver_kv_sync_task_context.h
index 5d8b615defdbeb5112b486fc7e3cc40aa762da36..c6f319960eaf4e26964975bc9011d47e529a7c44 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_kv_sync_task_context.h
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_kv_sync_task_context.h
@@ -29,12 +29,14 @@ public:
     std::string GetQuerySyncId() const override;
     std::string GetDeleteSyncId() const override;
 
-    void SetSyncStrategy(const SyncStrategy &strategy);
-    SyncStrategy GetSyncStrategy(QuerySyncObject &querySyncObject) const override;
+    void SetSyncStrategy(const SyncStrategy &strategy, bool isSchemaSync);
+    std::pair<bool, bool> GetSchemaSyncStatus(QuerySyncObject &querySyncObject) const override;
 protected:
     ~SingleVerKvSyncTaskContext() override;
 
+    mutable std::mutex syncStrategyMutex_;
     SyncStrategy syncStrategy_;
+    std::atomic<bool> isSchemaSync_ = false;
 };
 }
 #endif // SINGLE_VER_KV_SYNC_TASK_CONTEXT_H
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.cpp b/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.cpp
index 8164e1ccb0bab29b75452ccf5ba371ef9de03375..d02359ebe118d4503c981dcc427deb62779a606a 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.cpp
@@ -49,7 +49,7 @@ void SingleVerKVSyncer::EnableAutoSync(bool enable)
     }
 
     if (!initialized_) {
-        LOGE("[Syncer] Syncer has not Init");
+        LOGI("[Syncer] Syncer has not Init");
         return;
     }
 
@@ -127,6 +127,7 @@ void SingleVerKVSyncer::RemoteDataChanged(const std::string &device)
     SingleVerSyncer::RemoteDataChanged(device);
     if (autoSyncEnable_) {
         RefObject::IncObjRef(syncEngine_);
+        syncInterface_->IncRefCount();
         int retCode = RuntimeContext::GetInstance()->ScheduleTask([this, device] {
             std::vector<std::string> devices;
             devices.push_back(device);
@@ -135,17 +136,19 @@ void SingleVerKVSyncer::RemoteDataChanged(const std::string &device)
                 LOGE("[SingleVerKVSyncer] sync start by RemoteDataChanged failed err %d", errCode);
             }
             RefObject::DecObjRef(syncEngine_);
+            syncInterface_->DecRefCount();
         });
         if (retCode != E_OK) {
             LOGE("[AutoLaunch] RemoteDataChanged triggler sync retCode:%d", retCode);
             RefObject::DecObjRef(syncEngine_);
+            syncInterface_->DecRefCount();
         }
     }
     // db online again ,trigger subscribe
     // if remote device online, subscribequery num is 0
     std::vector<QuerySyncObject> syncQueries;
     static_cast<SingleVerSyncEngine *>(syncEngine_)->GetLocalSubscribeQueries(device, syncQueries);
-    if (syncQueries.size() == 0) {
+    if (syncQueries.empty()) {
         LOGI("no need to trigger auto subscribe");
         return;
     }
@@ -153,7 +156,7 @@ void SingleVerKVSyncer::RemoteDataChanged(const std::string &device)
     for (const auto &query : syncQueries) {
         TriggerSubscribe(device, query);
     }
-    static_cast<SingleVerSyncEngine *>(syncEngine_)->PutUnfiniedSubQueries(device, syncQueries);
+    static_cast<SingleVerSyncEngine *>(syncEngine_)->PutUnfinishedSubQueries(device, syncQueries);
 }
 
 void SingleVerKVSyncer::QueryAutoSync(const InternalSyncParma &param)
@@ -262,9 +265,16 @@ void SingleVerKVSyncer::TriggerSubQuerySync(const std::vector<std::string> &devi
         static_cast<SingleVerSyncEngine *>(syncEngine_)->GetRemoteSubscribeQueries(device, queries);
         for (auto &query : queries) {
             std::string queryId = query.GetIdentify();
-            uint64_t lastTimestamp = metadata_->GetQueryLastTimestamp(device, queryId);
             WaterMark queryWaterMark = 0;
-            errCode = metadata_->GetSendQueryWaterMark(queryId, device, queryWaterMark, false);
+            uint64_t lastTimestamp = 0;
+            {
+                std::lock_guard<std::mutex> lock(syncerLock_);
+                if (metadata_ == nullptr) {
+                    return;
+                }
+                lastTimestamp = metadata_->GetQueryLastTimestamp(device, queryId);
+                errCode = metadata_->GetSendQueryWaterMark(queryId, device, queryWaterMark, false);
+            }
             if (errCode != E_OK) {
                 LOGE("[Syncer] get queryId=%s,dev=%s watermark failed", STR_MASK(queryId), STR_MASK(device));
                 continue;
diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.h b/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.h
index c291acf2df98879ad0bab619bdfc191cb2bf7e56..cb14450fa952baac9a0e50c0a2980cc6e0b70741 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.h
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_kv_syncer.h
@@ -19,7 +19,7 @@
 #include "single_ver_syncer.h"
 
 namespace DistributedDB {
-class SingleVerKVSyncer final : public SingleVerSyncer {
+class SingleVerKVSyncer : public SingleVerSyncer {
 public:
     SingleVerKVSyncer();
     ~SingleVerKVSyncer() override;
diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_relational_sync_task_context.cpp b/frameworks/libs/distributeddb/syncer/src/single_ver_relational_sync_task_context.cpp
index ef556385f0ccca1947d16daaa1097bcf9745eb62..ed04c23a4721678bc584945b6212102f1271c1f9 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_relational_sync_task_context.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_relational_sync_task_context.cpp
@@ -52,35 +52,28 @@ void SingleVerRelationalSyncTaskContext::CopyTargetData(const ISyncTarget *targe
     deleteSyncId_ = GetDeviceId() + hexTableName; // save as deviceId + hexTableName
 }
 
-void SingleVerRelationalSyncTaskContext::SetRelationalSyncStrategy(RelationalSyncStrategy strategy)
+void SingleVerRelationalSyncTaskContext::SetRelationalSyncStrategy(RelationalSyncStrategy &strategy, bool isSchemaSync)
 {
     std::lock_guard<std::mutex> autoLock(syncStrategyMutex_);
     relationalSyncStrategy_ = strategy;
+    isSchemaSync_ = isSchemaSync;
 }
 
-SyncStrategy SingleVerRelationalSyncTaskContext::GetSyncStrategy(QuerySyncObject &querySyncObject) const
+std::pair<bool, bool> SingleVerRelationalSyncTaskContext::GetSchemaSyncStatus(QuerySyncObject &querySyncObject) const
 {
     std::lock_guard<std::mutex> autoLock(syncStrategyMutex_);
     auto it = relationalSyncStrategy_.find(querySyncObject.GetRelationTableName());
     if (it == relationalSyncStrategy_.end()) {
-        return {};
-    }
-    return it->second;
-}
-
-void SingleVerRelationalSyncTaskContext::SetIsNeedResetAbilitySync(bool isNeedReset)
-{
-    isNeedResetAbilitySync_ = isNeedReset;
-    if (isNeedResetAbilitySync_) {
-        SetIsSchemaSync(false);
+        return {false, isSchemaSync_};
     }
+    return {it->second.permitSync, isSchemaSync_};
 }
 
 void SingleVerRelationalSyncTaskContext::SchemaChange()
 {
     SetIsNeedResetAbilitySync(true);
-    std::lock_guard<std::mutex> autoLock(syncStrategyMutex_);
-    relationalSyncStrategy_ = {};
+    RelationalSyncStrategy strategy;
+    SetRelationalSyncStrategy(strategy, false);
 }
 }
 #endif
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_relational_sync_task_context.h b/frameworks/libs/distributeddb/syncer/src/single_ver_relational_sync_task_context.h
index 0146c42bf84c14b5f841439c644bbea02e805d9d..3e7de5aa6c27f85d2c091ec5e78e7062e90e09c1 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_relational_sync_task_context.h
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_relational_sync_task_context.h
@@ -31,10 +31,8 @@ public:
     std::string GetQuerySyncId() const override;
     std::string GetDeleteSyncId() const override;
 
-    void SetRelationalSyncStrategy(RelationalSyncStrategy strategy);
-    SyncStrategy GetSyncStrategy(QuerySyncObject &querySyncObject) const override;
-
-    void SetIsNeedResetAbilitySync(bool isNeedReset) override;
+    void SetRelationalSyncStrategy(RelationalSyncStrategy &strategy, bool isSchemaSync);
+    std::pair<bool, bool> GetSchemaSyncStatus(QuerySyncObject &querySyncObject) const override;
 
     void SchemaChange() override;
 protected:
@@ -47,6 +45,7 @@ protected:
     // for relational syncStrategy
     mutable std::mutex syncStrategyMutex_;
     RelationalSyncStrategy relationalSyncStrategy_;
+    std::atomic<bool> isSchemaSync_ = false;
 };
 }
 #endif // RELATIONAL_STORE
diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_serialize_manager.cpp b/frameworks/libs/distributeddb/syncer/src/single_ver_serialize_manager.cpp
index 4f8d8912943060be53202da0dee98a7145f72609..36e65ffb463e0724a5b3b09cd5758b9695afb537 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_serialize_manager.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_serialize_manager.cpp
@@ -213,11 +213,11 @@ int SingleVerSerializeManager::DataPacketSyncerPartSerialization(Parcel &parcel,
     }
     if (packet->GetVersion() > SOFTWARE_VERSION_RELEASE_2_0) {
         parcel.WriteUInt32(packet->GetFlag());
-        if (parcel.IsError()) {
-            return -E_PARSE_FAIL;
-        }
     }
     parcel.EightByteAlign();
+    if (parcel.IsError()) {
+        return -E_PARSE_FAIL;
+    }
     return E_OK;
 }
 
@@ -351,10 +351,10 @@ int SingleVerSerializeManager::AckPacketSyncerPartSerializationV1(Parcel &parcel
     parcel.WriteUInt64(packet->GetData());
     parcel.WriteInt(packet->GetRecvCode());
     parcel.WriteVector<uint64_t>(packet->GetReserved());
+    parcel.EightByteAlign();
     if (parcel.IsError()) {
         return -E_PARSE_FAIL;
     }
-    parcel.EightByteAlign();
     return E_OK;
 }
 
@@ -480,13 +480,13 @@ int SingleVerSerializeManager::DataPacketSyncerPartDeSerialization(Parcel &parce
         packLen += parcel.ReadUInt32(flag);
         packet->SetFlag(flag);
     }
+    parcel.EightByteAlign();
     packLen = Parcel::GetEightByteAlign(packLen);
     if (parcel.IsError()) {
         LOGE("[DataSync][DataPacketDeSerialization] deserialize failed! input len=%" PRIu32 ",packLen=%" PRIu32,
             length, packLen);
         return -E_LENGTH_ERROR;
     }
-    parcel.EightByteAlign();
     packet->SetEndWaterMark(waterMark);
     packet->SetLocalWaterMark(localWaterMark);
     packet->SetPeerWaterMark(peerWaterMark);
@@ -654,11 +654,11 @@ int SingleVerSerializeManager::ControlRequestSerialization(Parcel &parcel, const
     parcel.WriteInt(packet->GetSendCode());
     parcel.WriteUInt32(packet->GetcontrolCmdType());
     parcel.WriteUInt32(packet->GetFlag());
+    parcel.EightByteAlign();
     if (parcel.IsError()) {
         LOGE("[ControlRequestSerialization] Serialization failed");
         return -E_INVALID_ARGS;
     }
-    parcel.EightByteAlign();
     return E_OK;
 }
 
diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_sync_engine.cpp b/frameworks/libs/distributeddb/syncer/src/single_ver_sync_engine.cpp
index 3f85cb9edbbdca1ad7eeee131b960483d6013b98..d2ec4b930da16e0606983e43f1fe188ebe45b1fa 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_sync_engine.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_sync_engine.cpp
@@ -99,12 +99,12 @@ int SingleVerSyncEngine::SubscribeTimeOut(TimerId id)
     std::map<std::string, std::vector<QuerySyncObject>> allSyncQueries;
     GetAllUnFinishSubQueries(allSyncQueries);
     LOGI("[SingleVerSyncEngine] SubscribeTimeOut,size=%zu", allSyncQueries.size());
-    if (allSyncQueries.size() == 0) {
+    if (allSyncQueries.empty()) {
         LOGI("no need to trigger auto subscribe");
         return E_OK;
     }
-    for (auto &item : allSyncQueries) {
-        for (auto &query : item.second) {
+    for (const auto &item : allSyncQueries) {
+        for (const auto &query : item.second) {
             InternalSyncParma param;
             GetSubscribeSyncParam(item.first, query, param);
             queryAutoSyncCallback_(param);
diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_sync_state_machine.cpp b/frameworks/libs/distributeddb/syncer/src/single_ver_sync_state_machine.cpp
index da1b99a2408ac024edd620853fa06659ed3cfdbd..54de721d881ddce6864ba84538cfdca4c0f1c4bb 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_sync_state_machine.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_sync_state_machine.cpp
@@ -179,6 +179,7 @@ int SingleVerSyncStateMachine::ReceiveMessageCallback(Message *inMsg)
 {
     int errCode = MessageCallbackPre(inMsg);
     if (errCode != E_OK) {
+        LOGE("[StateMachine] message pre check failed");
         return errCode;
     }
     switch (inMsg->GetMessageId()) {
@@ -298,7 +299,7 @@ void SingleVerSyncStateMachine::CommErrAbort(uint32_t sessionId)
 {
     std::lock_guard<std::mutex> lock(stateMachineLock_);
     uint32_t requestSessionId = context_->GetRequestSessionId();
-    if ((sessionId != 0) && ((sessionId != requestSessionId) || (requestSessionId == 0))) {
+    if ((sessionId != 0) && ((requestSessionId == 0) || (sessionId != requestSessionId))) {
         return;
     }
     context_->SetCommNormal(false);
@@ -363,7 +364,7 @@ void SingleVerSyncStateMachine::InitStateMapping()
     stateMapping_[SYNC_CONTROL_CMD] = std::bind(&SingleVerSyncStateMachine::DoInitiactiveControlSync, this);
 }
 
-Event SingleVerSyncStateMachine::DoInitiactiveDataSyncWithSlidingWindow()
+Event SingleVerSyncStateMachine::DoInitiactiveDataSyncWithSlidingWindow() const
 {
     LOGD("[StateMachine][activeDataSync] mode=%d,label=%s,dev=%s", context_->GetMode(),
         dataSync_->GetLabel().c_str(), STR_MASK(context_->GetDeviceId()));
@@ -424,7 +425,7 @@ Event SingleVerSyncStateMachine::DoPassiveDataSyncWithSlidingWindow()
     return Event::WAIT_ACK_EVENT;
 }
 
-Event SingleVerSyncStateMachine::DoInitiactiveControlSync()
+Event SingleVerSyncStateMachine::DoInitiactiveControlSync() const
 {
     LOGD("[StateMachine][activeControlSync] mode=%d,label=%s,dev=%s", context_->GetMode(),
         dataSync_->GetLabel().c_str(), STR_MASK(context_->GetDeviceId()));
@@ -465,7 +466,7 @@ Event SingleVerSyncStateMachine::DoWaitForDataRecv() const
     return Event::WAIT_ACK_EVENT;
 }
 
-Event SingleVerSyncStateMachine::DoTimeSync()
+Event SingleVerSyncStateMachine::DoTimeSync() const
 {
     if (timeSync_->IsNeedSync()) {
         CommErrHandler handler = nullptr;
@@ -485,7 +486,7 @@ Event SingleVerSyncStateMachine::DoTimeSync()
     return Event::TIME_SYNC_FINISHED_EVENT;
 }
 
-Event SingleVerSyncStateMachine::DoAbilitySync()
+Event SingleVerSyncStateMachine::DoAbilitySync() const
 {
     uint16_t remoteCommunicatorVersion = 0;
     int errCode = communicator_->GetRemoteCommunicatorVersion(context_->GetDeviceId(), remoteCommunicatorVersion);
@@ -615,7 +616,6 @@ int SingleVerSyncStateMachine::AbilitySyncRecv(const Message *inMsg)
                 LOGI("[StateMachine][AbilitySyncRecv] ability sync finished,label=%s,dev=%s",
                     dataSync_->GetLabel().c_str(), STR_MASK(context_->GetDeviceId()));
                 currentRemoteVersionId_ = context_->GetRemoteSoftwareVersionId();
-                (static_cast<SingleVerSyncTaskContext *>(context_))->SetIsSchemaSync(true);
                 std::lock_guard<std::mutex> lock(stateMachineLock_);
                 (void)ResetWatchDog();
                 JumpStatusAfterAbilitySync(context_->GetMode());
@@ -846,9 +846,15 @@ void SingleVerSyncStateMachine::StepToTimeout(TimerId timerId)
     SwitchStateAndStep(Event::TIME_OUT_EVENT);
 }
 
+namespace {
+struct StateNode {
+    int errCode = 0;
+    SyncOperation::Status status = SyncOperation::OP_WAITING;
+};
+}
 int SingleVerSyncStateMachine::GetSyncOperationStatus(int errCode) const
 {
-    static const std::map<int, int> statusMap = {
+    static const StateNode stateNodes[] = {
         { -E_SCHEMA_MISMATCH,                 SyncOperation::OP_SCHEMA_INCOMPATIBLE },
         { -E_EKEYREVOKED,                     SyncOperation::OP_EKEYREVOKED_FAILURE },
         { -E_SECURITY_OPTION_CHECK_ERROR,     SyncOperation::OP_SECURITY_OPTION_CHECK_FAILURE },
@@ -866,11 +872,12 @@ int SingleVerSyncStateMachine::GetSyncOperationStatus(int errCode) const
         { -E_NOT_REGISTER,                    SyncOperation::OP_NOT_SUPPORT },
         { -E_DENIED_SQL,                      SyncOperation::OP_DENIED_SQL },
         { -E_REMOTE_OVER_SIZE,                SyncOperation::OP_MAX_LIMITS },
-        { -E_INVALID_PASSWD_OR_CORRUPTED_DB,  SyncOperation::OP_NOTADB_OR_CORRUPTED },
+        { -E_INVALID_PASSWD_OR_CORRUPTED_DB,  SyncOperation::OP_NOTADB_OR_CORRUPTED }
     };
-    auto iter = statusMap.find(errCode);
-    if (iter != statusMap.end()) {
-        return iter->second;
+    for (const auto &node : stateNodes) {
+        if (node.errCode == errCode) {
+            return static_cast<int>(node.status);
+        }
     }
     return SyncOperation::OP_FAILED;
 }
diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_sync_state_machine.h b/frameworks/libs/distributeddb/syncer/src/single_ver_sync_state_machine.h
index 378d488f9f03cb1b91b37816e03c7c2b4e2ba43a..9daa16218a1bade070068c3e99e69a929cec7683 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_sync_state_machine.h
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_sync_state_machine.h
@@ -142,10 +142,10 @@ private:
     void InitStateMapping();
 
     // Do TimeSync, for first sync
-    Event DoTimeSync();
+    Event DoTimeSync() const;
 
     // Do AbilitySync, for first sync
-    Event DoAbilitySync();
+    Event DoAbilitySync() const;
 
     // Waiting for pull data revice finish, if coming a pull request, should goto START_PASSIVE_DATA_SYNC state
     Event DoWaitForDataRecv() const;
@@ -159,11 +159,11 @@ private:
     // Do something when sync get some err.
     Event DoInnerErr();
 
-    Event DoInitiactiveDataSyncWithSlidingWindow();
+    Event DoInitiactiveDataSyncWithSlidingWindow() const;
 
     Event DoPassiveDataSyncWithSlidingWindow();
 
-    Event DoInitiactiveControlSync();
+    Event DoInitiactiveControlSync() const;
 
     Event GetEventAfterTimeSync(int mode) const;
 
diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_sync_task_context.cpp b/frameworks/libs/distributeddb/syncer/src/single_ver_sync_task_context.cpp
index fd7f3f71b0dca7ca498303620e2e9fba729c8961..2151cb74aa29f2974a788ea1cbb577a37c975446 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_sync_task_context.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_sync_task_context.cpp
@@ -248,22 +248,22 @@ void SingleVerSyncTaskContext::ClearAllSyncTask()
         LOGI("[SingleVerSyncTaskContext] request taskcount=%zu, responsecount=%zu", requestTargetQueue_.size(),
             responseTargetQueue_.size());
         while (!requestTargetQueue_.empty()) {
-            ISyncTarget *tmpTarget = nullptr;
-            tmpTarget = requestTargetQueue_.front();
+            ISyncTarget *tmpTarget = requestTargetQueue_.front();
+            SyncOperation *tmpInfOperation = nullptr;
+            tmpTarget->GetSyncOperation(tmpInfOperation);
+            RefObject::IncObjRef(tmpInfOperation);
             requestTargetQueue_.pop_front();
             targetQueue.push_back(tmpTarget);
         }
         while (!responseTargetQueue_.empty()) {
-            ISyncTarget *tmpTarget = nullptr;
-            tmpTarget = responseTargetQueue_.front();
+            ISyncTarget *tmpTarget = responseTargetQueue_.front();
             responseTargetQueue_.pop_front();
             delete tmpTarget;
             tmpTarget = nullptr;
         }
     }
     while (!targetQueue.empty()) {
-        ISyncTarget *target = nullptr;
-        target = targetQueue.front();
+        ISyncTarget *target = targetQueue.front();
         targetQueue.pop_front();
         SyncOperation *tmpOperation = nullptr;
         target->GetSyncOperation(tmpOperation);
@@ -282,6 +282,7 @@ void SingleVerSyncTaskContext::ClearAllSyncTask()
         }
         delete target;
         target = nullptr;
+        RefObject::DecObjRef(tmpOperation);
     }
     if (GetTaskExecStatus() == SyncTaskContext::RUNNING) {
         // clear syncing task.
@@ -356,16 +357,6 @@ bool SingleVerSyncTaskContext::GetSendPermitCheck() const
     return isSendPermitChecked_;
 }
 
-void SingleVerSyncTaskContext::SetIsSchemaSync(bool isSchemaSync)
-{
-    isSchemaSync_ = isSchemaSync;
-}
-
-bool SingleVerSyncTaskContext::GetIsSchemaSync() const
-{
-    return isSchemaSync_;
-}
-
 bool SingleVerSyncTaskContext::IsSkipTimeoutError(int errCode) const
 {
     if (errCode == -E_TIMEOUT && IsSyncTaskNeedRetry() && (GetRetryTime() < GetSyncRetryTimes())) {
@@ -425,7 +416,7 @@ std::string SingleVerSyncTaskContext::GetRemoteCompressAlgoStr() const
 {
     static std::map<CompressAlgorithm, std::string> algoMap = {{CompressAlgorithm::ZLIB, "zlib"}};
     std::set<CompressAlgorithm> remoteCompressAlgoSet = GetRemoteCompressAlgo();
-    if (remoteCompressAlgoSet.size() == 0) {
+    if (remoteCompressAlgoSet.empty()) {
         return "none";
     }
     std::string currentAlgoStr;
@@ -455,7 +446,7 @@ void SingleVerSyncTaskContext::SetDbAbility(DbAbility &remoteDbAbility)
 CompressAlgorithm SingleVerSyncTaskContext::ChooseCompressAlgo() const
 {
     std::set<CompressAlgorithm> remoteAlgo = GetRemoteCompressAlgo();
-    if (remoteAlgo.size() == 0) {
+    if (remoteAlgo.empty()) {
         return CompressAlgorithm::NONE;
     }
     std::set<CompressAlgorithm> localAlgorithmSet;
@@ -463,7 +454,7 @@ CompressAlgorithm SingleVerSyncTaskContext::ChooseCompressAlgo() const
     std::set<CompressAlgorithm> algoIntersection;
     set_intersection(remoteAlgo.begin(), remoteAlgo.end(), localAlgorithmSet.begin(), localAlgorithmSet.end(),
         inserter(algoIntersection, algoIntersection.begin()));
-    if (algoIntersection.size() == 0) {
+    if (algoIntersection.empty()) {
         return CompressAlgorithm::NONE;
     }
     return *(algoIntersection.begin());
diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_sync_task_context.h b/frameworks/libs/distributeddb/syncer/src/single_ver_sync_task_context.h
index 6528c11a7275618a8742c819b863b01c53f1c0b6..b5dcf47388b367c5ee14754cf82e0728b236d66d 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_sync_task_context.h
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_sync_task_context.h
@@ -108,12 +108,8 @@ public:
     void SetSendPermitCheck(bool isChecked);
 
     bool GetSendPermitCheck() const;
-
-    virtual SyncStrategy GetSyncStrategy(QuerySyncObject &querySyncObject) const = 0;
-
-    void SetIsSchemaSync(bool isSchemaSync);
-
-    bool GetIsSchemaSync() const;
+    // pair<bool, bool>: first:SyncStrategy.permitSync, second: isSchemaSync_
+    virtual std::pair<bool, bool> GetSchemaSyncStatus(QuerySyncObject &querySyncObject) const = 0;
 
     bool IsSkipTimeoutError(int errCode) const;
 
@@ -164,16 +160,15 @@ private:
 
     ContinueToken token_;
     WaterMark endMark_;
-    uint32_t responseSessionId_ = 0;
+    volatile uint32_t responseSessionId_ = 0;
 
     bool needClearRemoteStaleData_;
     SecurityOption remoteSecOption_ = {0, 0}; // remote targe can handle secOption data or not.
-    bool isReceivcPermitChecked_ = false;
-    bool isSendPermitChecked_ = false;
-    std::atomic<bool> isSchemaSync_ = false;
+    volatile bool isReceivcPermitChecked_ = false;
+    volatile bool isSendPermitChecked_ = false;
 
     // is receive waterMark err, peerWaterMark bigger than remote localWaterMark
-    bool isReceiveWaterMarkErr_ = false;
+    volatile bool isReceiveWaterMarkErr_ = false;
 
     // For db ability
     mutable std::mutex remoteDbAbilityLock_;
diff --git a/frameworks/libs/distributeddb/syncer/src/single_ver_syncer.cpp b/frameworks/libs/distributeddb/syncer/src/single_ver_syncer.cpp
index c923405f322db07832c29af46ec92bce6a9b8117..c64e641169504f0c37b13d936d05a4b2e756450b 100644
--- a/frameworks/libs/distributeddb/syncer/src/single_ver_syncer.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/single_ver_syncer.cpp
@@ -45,6 +45,7 @@ int SingleVerSyncer::EraseDeviceWaterMark(const std::string &deviceId, bool isNe
 int SingleVerSyncer::EraseDeviceWaterMark(const std::string &deviceId, bool isNeedHash,
     const std::string &tableName)
 {
+    std::lock_guard<std::mutex> lock(syncerLock_);
     if (metadata_ == nullptr) {
         return -E_NOT_INIT;
     }
@@ -55,7 +56,7 @@ int SingleVerSyncer::SetStaleDataWipePolicy(WipePolicy policy)
 {
     std::lock_guard<std::mutex> lock(syncerLock_);
     if (closing_) {
-        LOGE("[Syncer] Syncer is closing, return!");
+        LOGI("[Syncer] Syncer is closing, return!");
         return -E_BUSY;
     }
     if (syncEngine_ == nullptr) {
diff --git a/frameworks/libs/distributeddb/syncer/src/subscribe_manager.cpp b/frameworks/libs/distributeddb/syncer/src/subscribe_manager.cpp
index f0facc99739be521fef358a6589ad2432946009b..42d14b4b0e51025113221a7f20364d8df04be94c 100644
--- a/frameworks/libs/distributeddb/syncer/src/subscribe_manager.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/subscribe_manager.cpp
@@ -96,12 +96,12 @@ void SubscribeManager::DeleteRemoteSubscribeQuery(const std::string &device, con
     DeleteSubscribeQuery(device, queryId, remoteSubscribedMap_, remoteSubscribedTotalMap_);
 }
 
-void SubscribeManager::PutLocalUnFiniedSubQueries(const std::string &device,
-    std::vector<QuerySyncObject> &subscribeQueries)
+void SubscribeManager::PutLocalUnFinishedSubQueries(const std::string &device,
+    const std::vector<QuerySyncObject> &subscribeQueries)
 {
     LOGI("[SubscribeManager] put local unfinished subscribe queries, nums=%zu", subscribeQueries.size());
     std::unique_lock<std::shared_mutex> lockGuard(localSubscribeMapLock_);
-    if (subscribeQueries.size() == 0) {
+    if (subscribeQueries.empty()) {
         unFinishedLocalAutoSubMap_.erase(device);
         return;
     }
@@ -117,7 +117,7 @@ void SubscribeManager::GetAllUnFinishSubQueries(
 {
     std::shared_lock<std::shared_mutex> lock(localSubscribeMapLock_);
     for (auto &item : unFinishedLocalAutoSubMap_) {
-        if (item.second.size() == 0) {
+        if (item.second.empty()) {
             continue;
         }
         allSyncQueries[item.first] = {};
@@ -149,7 +149,7 @@ void SubscribeManager::RemoveLocalSubscribeQuery(const std::string &device, cons
         unFinishedLocalAutoSubMap_[device].find(queryId) != unFinishedLocalAutoSubMap_[device].end()) {
         unFinishedLocalAutoSubMap_[device].erase(queryId);
         LOGI("[SubscribeManager] dev=%s,queryId=%s delete from UnFinishedMap", STR_MASK(device), STR_MASK(queryId));
-        if (unFinishedLocalAutoSubMap_[device].size() == 0) {
+        if (unFinishedLocalAutoSubMap_[device].empty()) {
             LOGI("[SubscribeManager] dev=%s delete from unFinish map", STR_MASK(device));
             unFinishedLocalAutoSubMap_.erase(device);
         }
diff --git a/frameworks/libs/distributeddb/syncer/src/subscribe_manager.h b/frameworks/libs/distributeddb/syncer/src/subscribe_manager.h
index 42ca070c54b65850421b2d62c5ce5bc16d6283c4..fd87619b7a29f89f6c2e4f704cf61fb8d7505896 100644
--- a/frameworks/libs/distributeddb/syncer/src/subscribe_manager.h
+++ b/frameworks/libs/distributeddb/syncer/src/subscribe_manager.h
@@ -63,7 +63,7 @@ public:
     void DeleteRemoteSubscribeQuery(const std::string &device, const QuerySyncObject &query);
 
     // put subscribe queries into unfinished map when remote db online
-    void PutLocalUnFiniedSubQueries(const std::string &device, std::vector<QuerySyncObject> &subscribeQueries);
+    void PutLocalUnFinishedSubQueries(const std::string &device, const std::vector<QuerySyncObject> &subscribeQueries);
 
     // get all device unFinished subscribe queries which triggered by auto subscribe and need retry subscribe
     void GetAllUnFinishSubQueries(std::map<std::string, std::vector<QuerySyncObject>> &allSyncQueries) const;
diff --git a/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp b/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
index 221dcbca9c5b0f10a7414b4bb26985f33de5643c..a740fd3aee5b5ed897d4426db159310e36c1be04 100644
--- a/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/sync_engine.cpp
@@ -112,31 +112,33 @@ int SyncEngine::Close()
     isActive_ = false;
     UnRegCommunicatorsCallback();
     StopAutoSubscribeTimer();
-
+    std::vector<ISyncTaskContext *> decContext;
     // Clear SyncContexts
     {
         std::unique_lock<std::mutex> lock(contextMapLock_);
         for (auto &iter : syncTaskContextMap_) {
-            ISyncTaskContext *tempContext = iter.second;
-            lock.unlock();
-            RefObject::KillAndDecObjRef(tempContext);
-            tempContext = nullptr;
-            lock.lock();
+            decContext.push_back(iter.second);
             iter.second = nullptr;
         }
         syncTaskContextMap_.clear();
     }
+    for (auto &iter : decContext) {
+        RefObject::KillAndDecObjRef(iter);
+        iter = nullptr;
+    }
 
     WaitingExecTaskExist();
     ReleaseCommunicators();
-    std::lock_guard<std::mutex> msgLock(queueLock_);
-    while (!msgQueue_.empty()) {
-        Message *inMsg = msgQueue_.front();
-        msgQueue_.pop_front();
-        if (inMsg != nullptr) {
-            queueCacheSize_ -= GetMsgSize(inMsg);
-            delete inMsg;
-            inMsg = nullptr;
+    {
+        std::lock_guard<std::mutex> msgLock(queueLock_);
+        while (!msgQueue_.empty()) {
+            Message *inMsg = msgQueue_.front();
+            msgQueue_.pop_front();
+            if (inMsg != nullptr) {
+                queueCacheSize_ -= GetMsgSize(inMsg);
+                delete inMsg;
+                inMsg = nullptr;
+            }
         }
     }
     // close db, rekey or import scene, need clear all remote query info
@@ -200,18 +202,17 @@ void SyncEngine::BroadCastDataChanged() const
     }
 }
 
-void SyncEngine::RegConnectCallback()
+void SyncEngine::StartCommunicator()
 {
     if (communicator_ == nullptr) {
-        LOGE("[SyncEngine][RegConnCB] communicator is not set!");
+        LOGE("[SyncEngine][StartCommunicator] communicator is not set!");
         return;
     }
-    LOGD("[SyncEngine] RegOnConnectCallback");
-    int errCode = communicator_->RegOnConnectCallback(
-        std::bind(&DeviceManager::OnDeviceConnectCallback, deviceManager_,
-            std::placeholders::_1, std::placeholders::_2), nullptr);
+    LOGD("[SyncEngine][StartCommunicator] RegOnConnectCallback");
+    int errCode = communicator_->RegOnConnectCallback(std::bind(&DeviceManager::OnDeviceConnectCallback,
+        deviceManager_, std::placeholders::_1, std::placeholders::_2), nullptr);
     if (errCode != E_OK) {
-        LOGE("[SyncEngine][RegConnCB] register failed, auto sync can not use! err %d", errCode);
+        LOGE("[SyncEngine][StartCommunicator] register failed, auto sync can not use! err %d", errCode);
         return;
     }
     communicator_->Activate();
@@ -243,7 +244,14 @@ int SyncEngine::InitInnerSource(const std::function<void(std::string)> &onRemote
 
     int errCode = E_OK;
     do {
-        errCode = deviceManager_->Initialize(communicatorProxy_, onRemoteDataChanged, offlineChanged);
+        CommunicatorProxy *comProxy = nullptr;
+        {
+            std::lock_guard<std::mutex> lock(communicatorProxyLock_);
+            comProxy = communicatorProxy_;
+            RefObject::IncObjRef(comProxy);
+        }
+        errCode = deviceManager_->Initialize(comProxy, onRemoteDataChanged, offlineChanged);
+        RefObject::DecObjRef(comProxy);
         if (errCode != E_OK) {
             LOGE("[SyncEngine] deviceManager init failed! err %d", errCode);
             break;
@@ -292,15 +300,16 @@ int SyncEngine::InitComunicator(const ISyncInterface *syncInterface)
         communicator_ = nullptr;
         return errCode;
     }
-
-    communicatorProxy_ = new (std::nothrow) CommunicatorProxy();
-    if (communicatorProxy_ == nullptr) {
-        communicatorAggregator->ReleaseCommunicator(communicator_);
-        communicator_ = nullptr;
-        return -E_OUT_OF_MEMORY;
+    {
+        std::lock_guard<std::mutex> lock(communicatorProxyLock_);
+        communicatorProxy_ = new (std::nothrow) CommunicatorProxy();
+        if (communicatorProxy_ == nullptr) {
+            communicatorAggregator->ReleaseCommunicator(communicator_);
+            communicator_ = nullptr;
+            return -E_OUT_OF_MEMORY;
+        }
+        communicatorProxy_->SetMainCommunicator(communicator_);
     }
-
-    communicatorProxy_->SetMainCommunicator(communicator_);
     label.resize(3); // only show 3 Bytes enough
     label_ = DBCommon::VectorToHexString(label);
     LOGD("[SyncEngine] RegOnConnectCallback");
@@ -361,14 +370,12 @@ MSG_CALLBACK_OUT_NOT_DEL:
 
 void SyncEngine::RemoteDataChangedTask(ISyncTaskContext *context, const ICommunicator *communicator, Message *inMsg)
 {
-    do {
-        std::string deviceId = context->GetDeviceId();
-        if (onRemoteDataChanged_ && deviceManager_->IsDeviceOnline(deviceId)) {
-            onRemoteDataChanged_(deviceId);
-        } else {
-            LOGE("[SyncEngine] onRemoteDataChanged is null!");
-        }
-    } while (false);
+    std::string deviceId = context->GetDeviceId();
+    if (onRemoteDataChanged_ && deviceManager_->IsDeviceOnline(deviceId)) {
+        onRemoteDataChanged_(deviceId);
+    } else {
+        LOGE("[SyncEngine] onRemoteDataChanged is null!");
+    }
     delete inMsg;
     inMsg = nullptr;
     ScheduleTaskOut(context, communicator);
@@ -403,7 +410,7 @@ int SyncEngine::DealMsgUtilQueueEmpty()
     // it will deal with the first message in queue, we should increase object reference counts and sure that resources
     // could be prevented from destroying by other threads.
     do {
-        ISyncTaskContext *nextContext = GetConextForMsg(inMsg->GetTarget(), errCode);
+        ISyncTaskContext *nextContext = GetContextForMsg(inMsg->GetTarget(), errCode);
         if (errCode != E_OK) {
             break;
         }
@@ -420,7 +427,7 @@ int SyncEngine::DealMsgUtilQueueEmpty()
     return errCode;
 }
 
-ISyncTaskContext *SyncEngine::GetConextForMsg(const std::string &targetDev, int &errCode)
+ISyncTaskContext *SyncEngine::GetContextForMsg(const std::string &targetDev, int &errCode)
 {
     ISyncTaskContext *context = nullptr;
     {
@@ -454,19 +461,24 @@ int SyncEngine::ScheduleDealMsg(ISyncTaskContext *context, Message *inMsg)
         DecExecTaskCount();
         return E_OK;
     }
-    RefObject::IncObjRef(communicatorProxy_);
+    CommunicatorProxy *comProxy = nullptr;
+    {
+        std::lock_guard<std::mutex> lock(communicatorProxyLock_);
+        comProxy = communicatorProxy_;
+        RefObject::IncObjRef(comProxy);
+    }
     int errCode = E_OK;
     // deal remote local data changed message
     if (inMsg->GetMessageId() == LOCAL_DATA_CHANGED) {
-        RemoteDataChangedTask(context, communicatorProxy_, inMsg);
+        RemoteDataChangedTask(context, comProxy, inMsg);
     } else {
         errCode = RuntimeContext::GetInstance()->ScheduleTask(std::bind(&SyncEngine::MessageReciveCallbackTask,
-            this, context, communicatorProxy_, inMsg));
+            this, context, comProxy, inMsg));
     }
 
     if (errCode != E_OK) {
         LOGE("[SyncEngine] MessageReciveCallbackTask Schedule failed err %d", errCode);
-        RefObject::DecObjRef(communicatorProxy_);
+        RefObject::DecObjRef(comProxy);
     }
     return errCode;
 }
@@ -530,7 +542,7 @@ int SyncEngine::MessageReciveCallbackInner(const std::string &targetDev, Message
     }
 
     int errCode = E_OK;
-    ISyncTaskContext *nextContext = GetConextForMsg(targetDev, errCode);
+    ISyncTaskContext *nextContext = GetContextForMsg(targetDev, errCode);
     if (errCode != E_OK) {
         return errCode;
     }
@@ -749,8 +761,14 @@ int SyncEngine::SetEqualIdentifier(const std::string &identifier, const std::vec
     }
     LOGI("[SyncEngine] set equal identifier=%s, original=%s, targetDevices=%s",
         DBCommon::TransferStringToHex(identifier).c_str(), label_.c_str(),
-        targetDevices.substr(0, targetDevices.size() - 1).c_str());
-    communicatorProxy_->SetEqualCommunicator(communicator, identifier, targets);
+        targetDevices.substr(0, (targetDevices.size() > 0 ? targetDevices.size() - 1 : 0)).c_str());
+    {
+        std::lock_guard<std::mutex> lock(communicatorProxyLock_);
+        if (communicatorProxy_ == nullptr) {
+            return -E_INTERNAL_ERROR;
+        }
+        communicatorProxy_->SetEqualCommunicator(communicator, identifier, targets);
+    }
     communicator->Activate();
     return E_OK;
 }
@@ -765,7 +783,7 @@ void SyncEngine::SetEqualIdentifier()
             equalIdentifier[item.second].push_back(item.first);
         }
     }
-    for (auto &item : equalIdentifier) {
+    for (const auto &item : equalIdentifier) {
         SetEqualIdentifier(item.first, item.second);
     }
 }
@@ -779,17 +797,13 @@ void SyncEngine::SetEqualIdentifierMap(const std::string &identifier, const std:
         }
         iter++;
     }
-    for (auto &device : targets) {
+    for (const auto &device : targets) {
         equalIdentifierMap_[device] = identifier;
     }
 }
 
 void SyncEngine::OfflineHandleByDevice(const std::string &deviceId)
 {
-    if (communicatorProxy_ == nullptr) {
-        return;
-    }
-
     RemoteExecutor *executor = GetAndIncRemoteExector();
     if (executor != nullptr) {
         executor->NotifyDeviceOffline(deviceId);
@@ -806,10 +820,16 @@ void SyncEngine::OfflineHandleByDevice(const std::string &deviceId)
     if (context != nullptr) {
         context->SetIsNeedResetAbilitySync(true);
     }
-    if (communicatorProxy_->IsDeviceOnline(deviceId)) {
-        LOGI("[SyncEngine] target dev=%s is online, no need to clear task.", STR_MASK(deviceId));
-        RefObject::DecObjRef(context);
-        return;
+    {
+        std::lock_guard<std::mutex> lock(communicatorProxyLock_);
+        if (communicatorProxy_ == nullptr) {
+            return;
+        }
+        if (communicatorProxy_->IsDeviceOnline(deviceId)) {
+            LOGI("[SyncEngine] target dev=%s is online, no need to clear task.", STR_MASK(deviceId));
+            RefObject::DecObjRef(context);
+            return;
+        }
     }
     // means device is offline, clear local subscribe
     subManager_->ClearLocalSubscribeQuery(deviceId);
@@ -835,9 +855,9 @@ void SyncEngine::GetRemoteSubscribeQueries(const std::string &device, std::vecto
     subManager_->GetRemoteSubscribeQueries(device, subscribeQueries);
 }
 
-void SyncEngine::PutUnfiniedSubQueries(const std::string &device, std::vector<QuerySyncObject> &subscribeQueries)
+void SyncEngine::PutUnfinishedSubQueries(const std::string &device, const std::vector<QuerySyncObject> &subscribeQueries)
 {
-    subManager_->PutLocalUnFiniedSubQueries(device, subscribeQueries);
+    subManager_->PutLocalUnFinishedSubQueries(device, subscribeQueries);
 }
 
 void SyncEngine::GetAllUnFinishSubQueries(std::map<std::string, std::vector<QuerySyncObject>> &allSyncQueries)
@@ -899,8 +919,11 @@ void SyncEngine::UnRegCommunicatorsCallback()
 
 void SyncEngine::ReleaseCommunicators()
 {
-    RefObject::KillAndDecObjRef(communicatorProxy_);
-    communicatorProxy_ = nullptr;
+    {
+        std::lock_guard<std::mutex> lock(communicatorProxyLock_);
+        RefObject::KillAndDecObjRef(communicatorProxy_);
+        communicatorProxy_ = nullptr;
+    }
     ICommunicatorAggregator *communicatorAggregator = nullptr;
     int errCode = RuntimeContext::GetInstance()->GetCommunicatorAggregator(communicatorAggregator);
     if (communicatorAggregator == nullptr) {
@@ -992,9 +1015,9 @@ bool SyncEngine::IsEngineActive() const
 void SyncEngine::SchemaChange()
 {
     std::lock_guard<std::mutex> lock(contextMapLock_);
-    for (auto &entry : syncTaskContextMap_) {
+    for (const auto &entry : syncTaskContextMap_) {
         auto context = entry.second;
-        if (context->IsKilled()) {
+        if (context == nullptr || context->IsKilled()) {
             continue;
         }
         // IncRef for SyncEngine to make sure context is valid, to avoid a big lock
@@ -1019,20 +1042,25 @@ void SyncEngine::DecExecTaskCount()
 
 void SyncEngine::Dump(int fd)
 {
-    std::string communicatorLabel;
-    if (communicatorProxy_ != nullptr) {
-        communicatorProxy_->GetLocalIdentity(communicatorLabel);
-    }
-    DBDumpHelper::Dump(fd, "\tcommunicator label = %s, equalIdentify Info [\n", communicatorLabel.c_str());
-    if (communicatorProxy_ != nullptr) {
-        communicatorProxy_->GetLocalIdentity(communicatorLabel);
-        communicatorProxy_->Dump(fd);
+    {
+        std::lock_guard<std::mutex> lock(communicatorProxyLock_);
+        std::string communicatorLabel;
+        if (communicatorProxy_ != nullptr) {
+            communicatorProxy_->GetLocalIdentity(communicatorLabel);
+        }
+        DBDumpHelper::Dump(fd, "\tcommunicator label = %s, equalIdentify Info [\n", communicatorLabel.c_str());
+        if (communicatorProxy_ != nullptr) {
+            communicatorProxy_->GetLocalIdentity(communicatorLabel);
+            communicatorProxy_->Dump(fd);
+        }
     }
     DBDumpHelper::Dump(fd, "\t]\n\tcontext info [\n");
     // dump context info
     std::lock_guard<std::mutex> autoLock(contextMapLock_);
     for (const auto &entry : syncTaskContextMap_) {
-        entry.second->Dump(fd);
+        if (entry.second != nullptr) {
+            entry.second->Dump(fd);
+        }
     }
     DBDumpHelper::Dump(fd, "\t]\n\n");
 }
@@ -1108,23 +1136,23 @@ int SyncEngine::GetLocalDeviceId(std::string &deviceId)
 
 void SyncEngine::AbortMachineIfNeed(uint32_t syncId)
 {
-    ISyncTaskContext *abortContext = nullptr;
+    std::vector<ISyncTaskContext *> abortContexts;
     {
         std::lock_guard<std::mutex> lock(contextMapLock_);
-        for (auto &entry : syncTaskContextMap_) {
+        for (const auto &entry : syncTaskContextMap_) {
             auto context = entry.second;
-            if (context->IsKilled()) {
+            if (context == nullptr || context->IsKilled()) {
                 continue;
             }
             RefObject::IncObjRef(context);
             if (context->GetSyncId() == syncId) {
-                abortContext = context;
-                RefObject::IncObjRef(abortContext);
+                RefObject::IncObjRef(context);
+                abortContexts.push_back(context);
             }
             RefObject::DecObjRef(context);
         }
     }
-    if (abortContext != nullptr) {
+    for (const auto &abortContext : abortContexts) {
         abortContext->AbortMachineIfNeed(static_cast<uint32_t>(syncId));
         RefObject::DecObjRef(abortContext);
     }
diff --git a/frameworks/libs/distributeddb/syncer/src/sync_engine.h b/frameworks/libs/distributeddb/syncer/src/sync_engine.h
index a7f8fad203a4ef0fef94bd758a1940141aba06a6..9d0e28f36d4278a22c08ddb914608473c3eddeb6 100644
--- a/frameworks/libs/distributeddb/syncer/src/sync_engine.h
+++ b/frameworks/libs/distributeddb/syncer/src/sync_engine.h
@@ -58,7 +58,7 @@ public:
     void GetOnlineDevices(std::vector<std::string> &devices) const override;
 
     // Register the device connect callback, this function must be called after Engine inited
-    void RegConnectCallback() override;
+    void StartCommunicator() override;
 
     // Get the queue cache memory size
     int GetQueueCacheSize() const;
@@ -93,7 +93,7 @@ public:
 
     void GetRemoteSubscribeQueries(const std::string &device, std::vector<QuerySyncObject> &subscribeQueries);
 
-    void PutUnfiniedSubQueries(const std::string &device, std::vector<QuerySyncObject> &subscribeQueries);
+    void PutUnfinishedSubQueries(const std::string &device, const std::vector<QuerySyncObject> &subscribeQueries);
 
     void GetAllUnFinishSubQueries(std::map<std::string, std::vector<QuerySyncObject>> &allSyncQueries);
 
@@ -179,10 +179,7 @@ private:
     // Handle message in order.
     int ScheduleDealMsg(ISyncTaskContext *context, Message *inMsg);
 
-    // Schedule Sync Task
-    void ScheduleSyncTask(ISyncTaskContext *context);
-
-    ISyncTaskContext *GetConextForMsg(const std::string &targetDev, int &errCode);
+    ISyncTaskContext *GetContextForMsg(const std::string &targetDev, int &errCode);
 
     ICommunicator *AllocCommunicator(const std::string &identifier, int &errCode);
 
@@ -214,9 +211,10 @@ private:
     std::function<void(const std::string &)> offlineChanged_;
     std::shared_ptr<Metadata> metadata_;
     std::deque<Message *> msgQueue_;
-    uint32_t execTaskCount_;
+    volatile uint32_t execTaskCount_;
     std::string label_;
-    bool isSyncRetry_;
+    volatile bool isSyncRetry_;
+    std::mutex communicatorProxyLock_;
     CommunicatorProxy *communicatorProxy_;
     std::mutex equalCommunicatorsLock_;
     std::map<std::string, ICommunicator *> equalCommunicators_;
diff --git a/frameworks/libs/distributeddb/syncer/src/sync_operation.cpp b/frameworks/libs/distributeddb/syncer/src/sync_operation.cpp
index b95d841aa1842f6ab36491d316c676dc32ee6658..dff73c7d7de398da39a0b85c486a78b16c493b3b 100644
--- a/frameworks/libs/distributeddb/syncer/src/sync_operation.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/sync_operation.cpp
@@ -255,22 +255,34 @@ void SyncOperation::SetIdentifier(const std::vector<uint8_t> &identifier)
     identifier_.assign(identifier.begin(), identifier.end());
 }
 
+namespace {
+struct SyncTypeNode {
+    int mode = static_cast<int>(SyncModeType::INVALID_MODE);
+    SyncType type = SyncType::INVALID_SYNC_TYPE;
+};
+struct SyncOperationStatusNode {
+    int operationStatus = 0;
+    DBStatus status = DBStatus::DB_ERROR;
+};
+}
+
 SyncType SyncOperation::GetSyncType(int mode)
 {
-    static const std::map<int, SyncType> syncTypeMap = {
-        {SyncModeType::PUSH, SyncType::MANUAL_FULL_SYNC_TYPE},
-        {SyncModeType::PULL, SyncType::MANUAL_FULL_SYNC_TYPE},
-        {SyncModeType::PUSH_AND_PULL, SyncType::MANUAL_FULL_SYNC_TYPE},
-        {SyncModeType::RESPONSE_PULL, SyncType::MANUAL_FULL_SYNC_TYPE},
-        {SyncModeType::AUTO_PULL, SyncType::AUTO_SYNC_TYPE},
-        {SyncModeType::AUTO_PUSH, SyncType::AUTO_SYNC_TYPE},
-        {SyncModeType::QUERY_PUSH, SyncType::QUERY_SYNC_TYPE},
-        {SyncModeType::QUERY_PULL, SyncType::QUERY_SYNC_TYPE},
-        {SyncModeType::QUERY_PUSH_PULL, SyncType::QUERY_SYNC_TYPE},
+    static const SyncTypeNode syncTypeNodes[] = {
+        {static_cast<int>(SyncModeType::PUSH), SyncType::MANUAL_FULL_SYNC_TYPE},
+        {static_cast<int>(SyncModeType::PULL), SyncType::MANUAL_FULL_SYNC_TYPE},
+        {static_cast<int>(SyncModeType::PUSH_AND_PULL), SyncType::MANUAL_FULL_SYNC_TYPE},
+        {static_cast<int>(SyncModeType::RESPONSE_PULL), SyncType::MANUAL_FULL_SYNC_TYPE},
+        {static_cast<int>(SyncModeType::AUTO_PULL), SyncType::AUTO_SYNC_TYPE},
+        {static_cast<int>(SyncModeType::AUTO_PUSH), SyncType::AUTO_SYNC_TYPE},
+        {static_cast<int>(SyncModeType::QUERY_PUSH), SyncType::QUERY_SYNC_TYPE},
+        {static_cast<int>(SyncModeType::QUERY_PULL), SyncType::QUERY_SYNC_TYPE},
+        {static_cast<int>(SyncModeType::QUERY_PUSH_PULL), SyncType::QUERY_SYNC_TYPE}
     };
-    auto iter = syncTypeMap.find(mode);
-    if (iter != syncTypeMap.end()) {
-        return iter->second;
+    for (const auto &node: syncTypeNodes) {
+        if (node.mode == mode) {
+            return node.type;
+        }
     }
     return SyncType::INVALID_SYNC_TYPE;
 }
@@ -290,9 +302,9 @@ std::string SyncOperation::GetQueryId() const
     return query_.GetIdentify();
 }
 
-const std::map<int, DBStatus> &SyncOperation::DBStatusTransMap()
+DBStatus SyncOperation::DBStatusTrans(int operationStatus)
 {
-    static const std::map<int, DBStatus> transMap = {
+    static const SyncOperationStatusNode syncOperationStatusNodes[] = {
         { static_cast<int>(OP_FINISHED_ALL),                  OK },
         { static_cast<int>(OP_TIMEOUT),                       TIME_OUT },
         { static_cast<int>(OP_PERMISSION_CHECK_FAILED),       PERMISSION_CHECK_FORBID_SYNC },
@@ -312,7 +324,12 @@ const std::map<int, DBStatus> &SyncOperation::DBStatusTransMap()
         { static_cast<int>(OP_DENIED_SQL),                    NO_PERMISSION },
         { static_cast<int>(OP_NOTADB_OR_CORRUPTED),           INVALID_PASSWD_OR_CORRUPTED_DB },
     };
-    return transMap;
+    for (const auto &node: syncOperationStatusNodes) {
+        if (node.operationStatus == operationStatus) {
+            return node.status;
+        }
+    }
+    return DB_ERROR;
 }
 DEFINE_OBJECT_TAG_FACILITIES(SyncOperation)
 } // namespace DistributedDB
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/syncer/src/sync_operation.h b/frameworks/libs/distributeddb/syncer/src/sync_operation.h
index c10013d2aa5c45e7cb4791135132409d1117a8dc..675420bfe6b52dc58a839b9c9442e937153d4c79 100644
--- a/frameworks/libs/distributeddb/syncer/src/sync_operation.h
+++ b/frameworks/libs/distributeddb/syncer/src/sync_operation.h
@@ -127,7 +127,7 @@ public:
     static SyncType GetSyncType(int mode);
     static int TransferSyncMode(int mode);
 
-    static const std::map<int, DBStatus> &DBStatusTransMap();
+    static DBStatus DBStatusTrans(int operationStatus);
 
 protected:
     virtual ~SyncOperation();
@@ -160,21 +160,21 @@ private:
     std::map<std::string, int> statuses_;
 
     // Is this operation is a block sync
-    bool isBlockSync_;
+    volatile bool isBlockSync_;
 
     // Is this operation is an auto sync
-    bool isAutoSync_;
+    volatile bool isAutoSync_;
 
     // Is this operation has finished
-    bool isFinished_;
+    volatile bool isFinished_;
 
     // Used for block sync
     std::unique_ptr<SemaphoreUtils> semaphore_;
 
     QuerySyncObject query_;
-    bool isQuerySync_;
+    volatile bool isQuerySync_;
 
-    bool isAutoSubscribe_;
+    volatile bool isAutoSubscribe_;
 
     // record identifier used to call ScheduleQueuedTask in SyncOperation::Finished
     std::string identifier_;
diff --git a/frameworks/libs/distributeddb/syncer/src/sync_state_machine.h b/frameworks/libs/distributeddb/syncer/src/sync_state_machine.h
index 477dc13d24a0ff438fca8c8b9e9e19573948e262..9c0921a02f494d131c3c07b3ac8a0fd2472439a4 100644
--- a/frameworks/libs/distributeddb/syncer/src/sync_state_machine.h
+++ b/frameworks/libs/distributeddb/syncer/src/sync_state_machine.h
@@ -160,8 +160,8 @@ protected:
     std::shared_ptr<Metadata> metadata_;
     std::mutex stateMachineLock_;
     uint8_t currentState_;
-    bool watchDogStarted_;
-    uint32_t currentSyncProctolVersion_;
+    volatile bool watchDogStarted_;
+    volatile uint32_t currentSyncProctolVersion_;
 
     // For save data notify
     static const int DATA_NOTIFY_INTERVAL = 2000; // 2s for save/get data notify
@@ -169,13 +169,13 @@ protected:
     static const int SYNC_DIRECTION_NUM = 2; // send receive
     std::mutex saveDataNotifyLock_;
     TimerId saveDataNotifyTimerId_;
-    uint8_t saveDataNotifyCount_;
-    bool waitingResetLockBySaveData_;
-    int32_t saveDataNotifyRefCount_;
+    volatile uint8_t saveDataNotifyCount_;
+    volatile bool waitingResetLockBySaveData_;
+    volatile uint32_t saveDataNotifyRefCount_;
 
     std::mutex getDataNotifyLock_;
     TimerId getDataNotifyTimerId_;
-    uint8_t getDataNotifyCount_;
+    volatile uint8_t getDataNotifyCount_;
 
     // used for one (key,value) bigger than mtu size, in this case, send packet need more longger time
     std::mutex feedDogLock_[SYNC_DIRECTION_NUM];
diff --git a/frameworks/libs/distributeddb/syncer/src/sync_task_context.cpp b/frameworks/libs/distributeddb/syncer/src/sync_task_context.cpp
index dcbf754068a5d46470449dccb7dead7e324873dc..3dd4ce7d4182983740e98bd00eb0eb6a4ba1b38a 100644
--- a/frameworks/libs/distributeddb/syncer/src/sync_task_context.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/sync_task_context.cpp
@@ -639,7 +639,7 @@ void SyncTaskContext::ClearSyncOperation()
 
 void SyncTaskContext::CancelCurrentSyncRetryIfNeed(int newTargetMode)
 {
-    AutoLock(this);
+    AutoLock lock(this);
     if (!isAutoSync_) {
         return;
     }
@@ -683,7 +683,7 @@ int SyncTaskContext::GetSyncRetryTimeout(int retryTime) const
     int timeoutTime = GetTimeoutTime();
     if (IsAutoSync()) {
         // set the new timeout value with 2 raised to the power of retryTime.
-        return timeoutTime * static_cast<int>(pow(2, retryTime));
+        return timeoutTime * (1u << retryTime);
     }
     return timeoutTime;
 }
diff --git a/frameworks/libs/distributeddb/syncer/src/sync_task_context.h b/frameworks/libs/distributeddb/syncer/src/sync_task_context.h
index dd751fa8a01ada4a859f4b2c29926613d9cdfa0d..c9aa9d17b2e55472d502161b48e6a1c8776c44f9 100644
--- a/frameworks/libs/distributeddb/syncer/src/sync_task_context.h
+++ b/frameworks/libs/distributeddb/syncer/src/sync_task_context.h
@@ -242,27 +242,27 @@ protected:
     std::list<ISyncTarget *> responseTargetQueue_;
     SyncOperation *syncOperation_;
     mutable std::mutex operationLock_;
-    uint32_t syncId_;
-    int mode_;
-    bool isAutoSync_;
-    int status_;
-    int taskExecStatus_;
+    volatile uint32_t syncId_;
+    volatile int mode_;
+    volatile bool isAutoSync_;
+    volatile int status_;
+    volatile int taskExecStatus_;
     std::string deviceId_;
     std::string syncActionName_;
     ISyncInterface *syncInterface_;
     ICommunicator *communicator_;
     ISyncStateMachine *stateMachine_;
     TimeOffset timeOffset_ = 0;
-    int retryTime_ = 0;
-    int isNeedRetry_ = SyncTaskContext::NO_NEED_RETRY;
-    uint32_t requestSessionId_ = 0;
-    uint32_t lastRequestSessionId_ = 0;
-    uint32_t sequenceId_ = 1;
+    volatile int retryTime_ = 0;
+    volatile int isNeedRetry_ = SyncTaskContext::NO_NEED_RETRY;
+    volatile uint32_t requestSessionId_ = 0;
+    volatile uint32_t lastRequestSessionId_ = 0;
+    volatile uint32_t sequenceId_ = 1;
     std::function<int(void)> onSyncTaskAdd_;
 
     // for safe exit
     std::condition_variable safeKill_;
-    int usedCount_ = 0;
+    volatile int usedCount_ = 0;
 
     // for timeout callback
     std::mutex timerLock_;
@@ -273,16 +273,16 @@ protected:
 
     // for version sync
     mutable std::mutex remoteSoftwareVersionLock_;
-    uint32_t remoteSoftwareVersion_;
-    uint64_t remoteSoftwareVersionId_; // Check if the remoteSoftwareVersion_ is is overdue
-
-    bool isCommNormal_;
-    int taskErrCode_;
-    uint64_t packetId_ = 0; // used for assignment to reSendMap_.ReSendInfo.packetId in 103 version or above
-    bool syncTaskRetryStatus_;
-    bool isSyncRetry_;
-    uint32_t negotiationCount_;
-    bool isAutoSubscribe_;
+    volatile uint32_t remoteSoftwareVersion_;
+    volatile uint64_t remoteSoftwareVersionId_; // Check if the remoteSoftwareVersion_ is is overdue
+
+    volatile bool isCommNormal_;
+    volatile int taskErrCode_;
+    volatile uint64_t packetId_ = 0; // used for assignment to reSendMap_.ReSendInfo.packetId in 103 version or above
+    volatile bool syncTaskRetryStatus_;
+    volatile bool isSyncRetry_;
+    volatile uint32_t negotiationCount_;
+    volatile bool isAutoSubscribe_;
     // syncFinished_ need to set false if isNeedResetSyncFinished_ is true when start do abilitySync interface
     std::atomic<bool> isNeedResetAbilitySync_;
 
diff --git a/frameworks/libs/distributeddb/syncer/src/syncer_proxy.cpp b/frameworks/libs/distributeddb/syncer/src/syncer_proxy.cpp
index e9c4f237bbe968e48149294cc1ca464619ccda54..324b4ea05cd667597ffed9046e84b04b3813175a 100644
--- a/frameworks/libs/distributeddb/syncer/src/syncer_proxy.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/syncer_proxy.cpp
@@ -210,7 +210,7 @@ void SyncerProxy::Dump(int fd)
 SyncerBasicInfo SyncerProxy::DumpSyncerBasicInfo()
 {
     if (syncer_ == nullptr) {
-        return SyncerBasicInfo { false, false, false };
+        return SyncerBasicInfo { false, false };
     }
     return syncer_->DumpSyncerBasicInfo();
 }
@@ -223,4 +223,12 @@ int SyncerProxy::RemoteQuery(const std::string &device, const RemoteCondition &c
     }
     return syncer_->RemoteQuery(device, condition, timeout, connectionId, result);
 }
+
+int SyncerProxy::GetSyncDataSize(const std::string &device, size_t &size) const
+{
+    if (syncer_ == nullptr) {
+        return -E_NOT_INIT;
+    }
+    return syncer_->GetSyncDataSize(device, size);
+}
 } // namespace DistributedDB
diff --git a/frameworks/libs/distributeddb/syncer/src/time_sync.cpp b/frameworks/libs/distributeddb/syncer/src/time_sync.cpp
index 26cc3b9fd404efeec8256b247d759975a27de633..c3eecfe3aba77197a1de975071fe28e4ebae52f8 100644
--- a/frameworks/libs/distributeddb/syncer/src/time_sync.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/time_sync.cpp
@@ -150,7 +150,7 @@ int TimeSync::RegisterTransformFunc()
     return MessageTransform::RegTransformFunction(TIME_SYNC_MESSAGE, func);
 }
 
-int TimeSync::Initialize(ICommunicator *communicator, std::shared_ptr<Metadata> &metadata,
+int TimeSync::Initialize(ICommunicator *communicator, const std::shared_ptr<Metadata> &metadata,
     const ISyncInterface *storage, const DeviceID &deviceId)
 {
     if ((communicator == nullptr) || (storage == nullptr) || (metadata == nullptr)) {
@@ -273,7 +273,9 @@ int TimeSync::Serialization(uint8_t *buffer, uint32_t length, const Message *inM
         return -E_SECUREC_ERROR;
     }
     parcel.EightByteAlign();
-
+    if (parcel.IsError()) {
+        return -E_PARSE_FAIL;
+    }
     return errCode;
 }
 
diff --git a/frameworks/libs/distributeddb/syncer/src/time_sync.h b/frameworks/libs/distributeddb/syncer/src/time_sync.h
index 0b79152cac619ce0c0fccfeb26901b334e7f9e95..263faac16778ab3c22839667fae592b76e937340 100644
--- a/frameworks/libs/distributeddb/syncer/src/time_sync.h
+++ b/frameworks/libs/distributeddb/syncer/src/time_sync.h
@@ -71,7 +71,7 @@ public:
 
     static int DeSerialization(const uint8_t *buffer, uint32_t length, Message *inMsg); // register to communicator
 
-    int Initialize(ICommunicator *communicator, std::shared_ptr<Metadata> &metadata,
+    int Initialize(ICommunicator *communicator, const std::shared_ptr<Metadata> &metadata,
         const ISyncInterface *storage, const DeviceID &deviceId);
 
     int SyncStart(const CommErrHandler &handler = nullptr, uint32_t sessionId = 0); // send timesync request
diff --git a/frameworks/libs/distributeddb/syncer/src/value_slice_sync.cpp b/frameworks/libs/distributeddb/syncer/src/value_slice_sync.cpp
index 62a822b4b7f621f3697b1d8636971b41cd40f098..ad39413f6e37a50379f1f6a9e510f9cbf4d3c2cc 100644
--- a/frameworks/libs/distributeddb/syncer/src/value_slice_sync.cpp
+++ b/frameworks/libs/distributeddb/syncer/src/value_slice_sync.cpp
@@ -381,6 +381,9 @@ int ValueSliceSync::RequestPacketDeSerialization(const uint8_t *buffer, uint32_t
     // errCode DeSerialization
     uint32_t packLen = parcel.ReadInt(ackCode);
     parcel.EightByteAlign();
+    if (parcel.IsError()) {
+        return -E_PARSE_FAIL;
+    }
     packLen = Parcel::GetEightByteAlign(packLen);
 
     ValueSliceHash valueSliceHash;
@@ -455,6 +458,9 @@ int ValueSliceSync::AckPacketDeSerialization(const uint8_t *buffer, uint32_t len
     // errCode DeSerialization
     packLen += parcel.ReadInt(ackCode);
     parcel.EightByteAlign();
+    if (parcel.IsError()) {
+        return -E_PARSE_FAIL;
+    }
     packLen = Parcel::GetEightByteAlign(packLen);
     // valueSlice DeSerialization
     packLen += parcel.ReadVectorChar(valueSlice);
diff --git a/frameworks/libs/distributeddb/test/BUILD.gn b/frameworks/libs/distributeddb/test/BUILD.gn
index 453ee0e53aa6459e444d40cb2b7ce0d9c6926512..471f4ac6446205d1b796e9e7de1e825e1c653625 100644
--- a/frameworks/libs/distributeddb/test/BUILD.gn
+++ b/frameworks/libs/distributeddb/test/BUILD.gn
@@ -269,6 +269,7 @@ ohos_source_set("src_file") {
     "unittest/common/common/distributeddb_data_generate_unit_test.cpp",
     "unittest/common/common/distributeddb_tools_unit_test.cpp",
     "unittest/common/common/native_sqlite.cpp",
+    "unittest/common/common/system_timer.cpp",
     "unittest/common/interfaces/process_system_api_adapter_impl.cpp",
     "unittest/common/syncer/generic_virtual_device.cpp",
     "unittest/common/syncer/kv_virtual_device.cpp",
@@ -658,7 +659,7 @@ distributeddb_unittest("DistributedDBCommunicatorProxyTest") {
 }
 
 distributeddb_unittest("DistributedDBSingleVerP2PSubscribeSyncTest") {
-  sources = [ "unittest/common/syncer/distributeddb_single_ver_p2p_subsribe_sync_test.cpp" ]
+  sources = [ "unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp" ]
 }
 
 distributeddb_unittest("DistributedDBMockSyncModuleTest") {
@@ -721,6 +722,10 @@ distributeddb_unittest("DistributedDBInterfacesRelationalRoutinesTest") {
   sources = [ "unittest/common/interfaces/distributeddb_interfaces_relational_routines_test.cpp" ]
 }
 
+distributeddb_unittest("DistributedDBRelationalSyncableStorageTest") {
+  sources = [ "unittest/common/storage/distributeddb_relational_syncable_storage_test.cpp" ]
+}
+
 ###############################################################################
 group("unittest") {
   testonly = true
@@ -773,6 +778,7 @@ group("unittest") {
     ":DistributedDBRelationalRemoteQueryTest",
     ":DistributedDBRelationalResultSetTest",
     ":DistributedDBRelationalSchemaObjectTest",
+    ":DistributedDBRelationalSyncableStorageTest",
     ":DistributedDBSchemaObjectTest",
     ":DistributedDBSchemalTest",
     ":DistributedDBSingleVerDLPTest",
@@ -813,12 +819,16 @@ group("distributeddatamgr_fuzztest") {
     "fuzztest/fileoper_fuzzer:fuzztest",
     "fuzztest/importfile_fuzzer:fuzztest",
     "fuzztest/iprocesscommunicator_fuzzer:fuzztest",
+    "fuzztest/kvdelegatemanager_fuzzer:fuzztest",
     "fuzztest/kvstoreresultset_fuzzer:fuzztest",
     "fuzztest/nbdelegate_fuzzer:fuzztest",
     "fuzztest/parseckeck_fuzzer:fuzztest",
     "fuzztest/query_fuzzer:fuzztest",
     "fuzztest/rekey_fuzzer:fuzztest",
+    "fuzztest/relationalstoredelegate_fuzzer:fuzztest",
+    "fuzztest/relationalstoremanager_fuzzer:fuzztest",
     "fuzztest/schemadelegate_fuzzer:fuzztest",
+    "fuzztest/sync_fuzzer:fuzztest",
   ]
 }
 ###############################################################################
diff --git a/frameworks/libs/distributeddb/test/fuzztest/common/distributeddb_tools_test.cpp b/frameworks/libs/distributeddb/test/fuzztest/common/distributeddb_tools_test.cpp
index c44360047a6b993b69f8b79ab03d381aa7fc654b..2ec3a30fc1188b07d9a5b50240c98c988339e198 100644
--- a/frameworks/libs/distributeddb/test/fuzztest/common/distributeddb_tools_test.cpp
+++ b/frameworks/libs/distributeddb/test/fuzztest/common/distributeddb_tools_test.cpp
@@ -130,6 +130,51 @@ void DistributedDBToolsTest::GetRandomKeyValue(std::vector<uint8_t> &value, uint
     RAND_bytes(value.data(), randSize);
 }
 
+DBStatus DistributedDBToolsTest::SyncTestWithQuery(KvStoreNbDelegate* delegate,
+    const std::vector<std::string>& devices, SyncMode mode,
+    std::map<std::string, DBStatus>& statuses, const Query &query)
+{
+    std::mutex syncLock;
+    std::condition_variable syncCondVar;
+    statuses.clear();
+    DBStatus callStatus = delegate->Sync(devices, mode,
+        [&statuses, &syncLock, &syncCondVar](const std::map<std::string, DBStatus>& statusMap) {
+            statuses = statusMap;
+            std::unique_lock<std::mutex> innerlock(syncLock);
+            syncCondVar.notify_one();
+        }, query, false);
+    std::unique_lock<std::mutex> lock(syncLock);
+    syncCondVar.wait(lock, [callStatus, &statuses]() {
+            if (callStatus != OK) {
+                return true;
+            }
+            return !statuses.empty();
+        });
+    return callStatus;
+}
+
+DBStatus DistributedDBToolsTest::SyncTest(KvStoreNbDelegate* delegate, const std::vector<std::string>& devices,
+    SyncMode mode, std::map<std::string, DBStatus>& statuses)
+{
+    std::mutex syncLock;
+    std::condition_variable syncCondVar;
+    statuses.clear();
+    DBStatus callStatus = delegate->Sync(devices, mode,
+        [&statuses,  &syncLock, &syncCondVar](const std::map<std::string, DBStatus>& statusMap) {
+            statuses = statusMap;
+            std::unique_lock<std::mutex> innerlock(syncLock);
+            syncCondVar.notify_one();
+        }, false);
+    std::unique_lock<std::mutex> lock(syncLock);
+    syncCondVar.wait(lock, [callStatus, &statuses]() {
+            if (callStatus != OK) {
+                return true;
+            }
+            return !statuses.empty();
+        });
+    return callStatus;
+}
+
 KvStoreObserverTest::KvStoreObserverTest() : callCount_(0), isCleared_(false)
 {}
 
@@ -143,4 +188,46 @@ void KvStoreObserverTest::OnChange(const KvStoreChangedData& data)
     LOGD("Onchangedata :%zu -- %zu -- %zu -- %d", inserted_.size(), updated_.size(), deleted_.size(), isCleared_);
     LOGD("Onchange() called success!");
 }
+
+sqlite3 *RdbTestUtils::CreateDataBase(const std::string &dbUri)
+{
+    sqlite3 *db = nullptr;
+    if (sqlite3_open_v2(dbUri.c_str(), &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nullptr) != SQLITE_OK) {
+        if (db != nullptr) {
+            (void)sqlite3_close_v2(db);
+            db = nullptr;
+        }
+    }
+    return db;
+}
+
+int RdbTestUtils::ExecSql(sqlite3 *db, const std::string &sql)
+{
+    if (db == nullptr || sql.empty()) {
+        return -E_INVALID_ARGS;
+    }
+    char *errMsg = nullptr;
+    int errCode = sqlite3_exec(db, sql.c_str(), nullptr, nullptr, &errMsg);
+    if (errCode != SQLITE_OK && errMsg != nullptr) {
+        LOGE("Execute sql failed. %d err: %s", errCode, errMsg);
+    }
+    sqlite3_free(errMsg);
+    return errCode;
+}
+
+int RdbTestUtils::CreateDeviceTable(sqlite3 *db, const std::string &table, const std::string &device)
+{
+    std::string deviceTable = DBCommon::GetDistributedTableName(device, table);
+    TableInfo baseTbl;
+    if (SQLiteUtils::AnalysisSchema(db, table, baseTbl) != E_OK) {
+        return -1;
+    }
+    if (SQLiteUtils::CreateSameStuTable(db, baseTbl, deviceTable) != E_OK) {
+        return -1;
+    }
+    if (SQLiteUtils::CloneIndexes(db, table, deviceTable) != E_OK) {
+        return -1;
+    }
+    return 0;
+}
 }
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/fuzztest/common/distributeddb_tools_test.h b/frameworks/libs/distributeddb/test/fuzztest/common/distributeddb_tools_test.h
index 8650499911aec052f229ed080190842abfebc741..2a49f86e488569c34d0f2641335d22fccd0474e7 100644
--- a/frameworks/libs/distributeddb/test/fuzztest/common/distributeddb_tools_test.h
+++ b/frameworks/libs/distributeddb/test/fuzztest/common/distributeddb_tools_test.h
@@ -24,6 +24,7 @@
 #include <vector>
 
 #include "db_types.h"
+#include "store_types.h"
 #include "kv_store_changed_data.h"
 #include "kv_store_delegate_impl.h"
 #include "kv_store_delegate_manager.h"
@@ -33,7 +34,11 @@
 #include "message.h"
 #include "query.h"
 
+#include "sqlite_utils.h"
+
 namespace DistributedDBTest {
+using namespace DistributedDB;
+
 class DistributedDBToolsTest final {
 public:
     DistributedDBToolsTest() {}
@@ -44,6 +49,10 @@ public:
     static int RemoveTestDbFiles(const std::string &dir);
     static int GetCurrentDir(std::string& dir);
     static void GetRandomKeyValue(std::vector<uint8_t> &value, uint32_t defaultSize = 0);
+    static DBStatus SyncTestWithQuery(KvStoreNbDelegate* delegate, const std::vector<std::string>& devices,
+        SyncMode mode, std::map<std::string, DBStatus>& statuses, const Query &query);
+    static DBStatus SyncTest(KvStoreNbDelegate* delegate, const std::vector<std::string>& devices, SyncMode mode,
+            std::map<std::string, DBStatus>& statuses);
 };
 
 class KvStoreObserverTest : public DistributedDB::KvStoreObserver {
@@ -61,5 +70,12 @@ private:
     std::list<DistributedDB::Entry> updated_;
     std::list<DistributedDB::Entry> deleted_;
 };
+
+class RdbTestUtils {
+public:
+    static sqlite3 *CreateDataBase(const std::string &dbUri);
+    static int ExecSql(sqlite3 *db, const std::string &sql);
+    static int CreateDeviceTable(sqlite3 *db, const std::string &table, const std::string &device);
+};
 } // namespace DistributedDBTest
 #endif // DISTRIBUTEDDB_TOOLS_TEST_H
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/fuzztest/common/fuzzer_data.cpp b/frameworks/libs/distributeddb/test/fuzztest/common/fuzzer_data.cpp
index 638f8746387a4834e024d90a2b48848e176e1b49..f21b4ae63ce18e5be873c76356da6e6b85d18da7 100644
--- a/frameworks/libs/distributeddb/test/fuzztest/common/fuzzer_data.cpp
+++ b/frameworks/libs/distributeddb/test/fuzztest/common/fuzzer_data.cpp
@@ -14,7 +14,9 @@
  */
 
 #include "fuzzer_data.h"
-
+#include <codecvt>
+#include <cstdio>
+#include <locale>
 
 namespace DistributedDBTest {
 FuzzerData::FuzzerData(const uint8_t *data, size_t size) : data_(data), size_(size), curr_(data)
@@ -62,4 +64,35 @@ std::vector<uint8_t> FuzzerData::GetSequence(size_t size)
     curr_ += size;
     return r;
 }
+
+std::string FuzzerData::GetString(size_t len)
+{
+    if (curr_ - data_ + len > size_ || len == 0) {
+        return "";
+    }
+
+    std::string res = std::string(curr_, curr_ + len - 1);
+    curr_ += len;
+    return res;
+}
+
+std::vector<std::string> FuzzerData::GetStringVector(size_t size)
+{
+    std::vector<std::string> vec;
+    for (size_t i = 1; i <= size; i++) {
+        vec.push_back(GetString(i));
+    }
+    return vec;
+}
+
+std::vector<std::u16string> FuzzerData::GetU16StringVector(size_t size)
+{
+    std::vector<std::u16string> vec;
+    for (size_t i = 1; i <= size; i++) {
+        std::u16string u16str = std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> {}.from_bytes(
+            GetString(i));
+        vec.push_back(u16str);
+    }
+    return vec;
+}
 } // DistributedDBTest
diff --git a/frameworks/libs/distributeddb/test/fuzztest/common/fuzzer_data.h b/frameworks/libs/distributeddb/test/fuzztest/common/fuzzer_data.h
index c4257e63776e91e0011e0e73a9db6e05a1216fc4..447ec8cc08568134b3084b1fc073f34eaa5a1d35 100644
--- a/frameworks/libs/distributeddb/test/fuzztest/common/fuzzer_data.h
+++ b/frameworks/libs/distributeddb/test/fuzztest/common/fuzzer_data.h
@@ -19,6 +19,7 @@
 
 #include <cstdint>
 #include <vector>
+#include <string>
 
 namespace DistributedDBTest {
 class FuzzerData final {
@@ -30,6 +31,9 @@ public:
     uint32_t GetUInt32();
     uint64_t GetUInt64();
     std::vector<uint8_t> GetSequence(size_t size);
+    std::string GetString(size_t len);
+    std::vector<std::string> GetStringVector(size_t size);
+    std::vector<std::u16string> GetU16StringVector(size_t size);
 private:
     const uint8_t *data_;
     const size_t size_;
diff --git a/frameworks/libs/distributeddb/test/fuzztest/delegate_fuzzer/delegate_fuzzer.cpp b/frameworks/libs/distributeddb/test/fuzztest/delegate_fuzzer/delegate_fuzzer.cpp
index 3d526c52b9d53f0d77ab2f970865477e78d0f876..fb3a4cb7f40e7c7d34cde2fdaf3791370ff1e569 100644
--- a/frameworks/libs/distributeddb/test/fuzztest/delegate_fuzzer/delegate_fuzzer.cpp
+++ b/frameworks/libs/distributeddb/test/fuzztest/delegate_fuzzer/delegate_fuzzer.cpp
@@ -79,7 +79,6 @@ void MultiCombineFuzzer(const uint8_t* data, size_t size, KvStoreDelegate::Optio
     kvStoreSnapshotPtr->GetEntries(keyPrefix, [](DBStatus status, const std::vector<Entry> &entries) {
         (void) entries.size();
     });
-
     kvDelegatePtr->DeleteBatch(keys);
     kvDelegatePtr->Clear();
     kvDelegatePtr->UnRegisterObserver(observer);
diff --git a/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer/BUILD.gn b/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..587b29e224156c3a3bc2ac36d9dca75f13459a92
--- /dev/null
+++ b/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer/BUILD.gn
@@ -0,0 +1,105 @@
+# Copyright (c) 2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#####################hydra-fuzz###################
+import("//build/config/features.gni")
+import("//build/test.gni")
+
+##############################fuzztest##########################################
+ohos_fuzztest("KvDelegateManagerFuzzTest") {
+  module_out_path = "kv_store/distributeddb"
+
+  include_dirs = [
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/common",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/common",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/interfaces/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/interfaces/src",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/storage/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/storage/src",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/storage/src/sqlite",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/storage/src/multiver",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/src",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/communicator/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/communicator/src",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/syncer/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/syncer/src",
+    "//commonlibrary/c_utils/base/include",
+    "//third_party/sqlite/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/include/relational",
+    "//third_party/jsoncpp/include/json",
+    "//third_party/skia/third_party/externals/spirv-headers/tools/buildHeaders/jsoncpp/dist/json",
+    "//third_party/skia/third_party/externals/swiftshader/third_party/SPIRV-Headers/tools/buildHeaders/jsoncpp/dist/json",
+    "//third_party/jsoncpp/include/json",
+    "//third_party/grpc/src/core/lib/json",
+  ]
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+
+  fuzz_config_file = "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer"
+
+  sources = [
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/src/db_common.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/src/log_print.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/src/platform_specific.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/common/distributeddb_tools_test.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_data_generate_unit_test.cpp",
+    "kvdelegatemanager_fuzzer.cpp",
+  ]
+
+  defines = [
+    "SQLITE_ENABLE_SNAPSHOT",
+    "_LARGEFILE64_SOURCE",
+    "_FILE_OFFSET_BITS=64",
+    "SQLITE_HAS_CODEC",
+    "SQLITE_ENABLE_JSON1",
+    "USING_HILOG_LOGGER",
+    "USE_SQLITE_SYMBOLS",
+    "USING_DB_JSON_EXTRACT_AUTOMATICALLY",
+    "LOW_LEVEL_MEM_DEV",
+    "JSONCPP_USE_BUILDER",
+    "OMIT_FLATBUFFER",
+    "RELATIONAL_STORE",
+    "SQLITE_DISTRIBUTE_RELATIONAL",
+  ]
+
+  deps = [
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb:distributeddb",
+    "//third_party/jsoncpp:jsoncpp",
+    "//third_party/openssl:libcrypto_shared",
+  ]
+
+  external_deps = [
+    "c_utils:utils",
+    "hiviewdfx_hilog_native:libhilog",
+  ]
+}
+
+###############################################################################
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [
+    # deps file
+    ":KvDelegateManagerFuzzTest",
+  ]
+}
diff --git a/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer/corpus/init b/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer/corpus/init
new file mode 100644
index 0000000000000000000000000000000000000000..bc977bd9738ee9a70b362067f57a9c63d3adb801
--- /dev/null
+++ b/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer/corpus/init
@@ -0,0 +1,14 @@
+# Copyright (c) 2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+FUZZ
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer/kvdelegatemanager_fuzzer.cpp b/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer/kvdelegatemanager_fuzzer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fd7399906eb3b70e436d5fe781dcd6394a59959e
--- /dev/null
+++ b/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer/kvdelegatemanager_fuzzer.cpp
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "kvdelegatemanager_fuzzer.h"
+#include <list>
+#include <securec.h>
+#include "distributeddb_tools_test.h"
+#include "kv_store_delegate_manager.h"
+#include "log_print.h"
+
+class KvDelegateManagerFuzzer {
+    /* Keep C++ file names the same as the class name. */
+};
+
+namespace OHOS {
+using namespace DistributedDB;
+using namespace DistributedDBTest;
+
+std::string GetRandomString(const uint8_t* data, size_t size, size_t len, uint32_t &start)
+{
+    std::string res;
+    if (size == 0) {
+        return "";
+    }
+    if (start >= size) {
+        return std::string(data, data + size - 1);
+    }
+    if (start + len > size) {
+        res = std::string(data + start, data + start + size - 1);
+        start += size;
+    } else {
+        res = std::string(data + start, data + start + len - 1);
+        start += len;
+    }
+    return res;
+}
+
+void GetRandomAutoLaunchOption(const uint8_t* data, size_t size, AutoLaunchOption &option)
+{
+    std::string randomStr = size == 0 ? "" : std::string(data, data + size - 1);
+    option.schema = randomStr;
+    option.observer = nullptr;
+    option.notifier = nullptr;
+    option.storeObserver = nullptr;
+}
+
+void CombineTest(const uint8_t* data, size_t size)
+{
+    LOGD("Begin KvDelegateManagerFuzzer");
+    std::string path;
+    DistributedDBToolsTest::TestDirInit(path);
+    const int paramCount = 3;
+    for (size_t len = 1; len < (size / paramCount); len++) {
+        uint32_t start = 0;
+        std::string appId = GetRandomString(data, size, len, start);
+        std::string userId = GetRandomString(data, size, len, start);
+        std::string storeId = GetRandomString(data, size, len, start);
+        std::string dir;
+        (void) KvStoreDelegateManager::GetDatabaseDir(storeId, appId, userId, dir);
+        (void) KvStoreDelegateManager::GetDatabaseDir(storeId, dir);
+        (void) KvStoreDelegateManager::SetProcessLabel(appId, userId);
+        bool syncDualTupleMode = static_cast<bool>(*data);
+        (void) KvStoreDelegateManager::GetKvStoreIdentifier(userId, appId, storeId, syncDualTupleMode);
+        AutoLaunchOption option;
+        GetRandomAutoLaunchOption(data, size, option);
+        option.dataDir = path;
+        (void) KvStoreDelegateManager::EnableKvStoreAutoLaunch(userId, appId, storeId, option, nullptr);
+        (void) KvStoreDelegateManager::DisableKvStoreAutoLaunch(userId, appId, storeId);
+    }
+    DistributedDBToolsTest::RemoveTestDbFiles(path);
+    LOGD("End KvDelegateManagerFuzzer");
+}
+}
+
+/* Fuzzer entry point */
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
+{
+    OHOS::CombineTest(data, size);
+    return 0;
+}
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer/kvdelegatemanager_fuzzer.h b/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer/kvdelegatemanager_fuzzer.h
new file mode 100644
index 0000000000000000000000000000000000000000..b6cf1c4392c1db64d0ae3a467cdbf1643a806a86
--- /dev/null
+++ b/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer/kvdelegatemanager_fuzzer.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef KV_DELEGATE_MANAGER_FUZZER_H
+#define KV_DELEGATE_MANAGER_FUZZER_H
+
+#define FUZZ_PROJECT_NAME "KvDelegateManager_fuzzer"
+
+#endif // KV_DELEGATE_MANAGER_FUZZER_H
diff --git a/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer/project.xml b/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer/project.xml
new file mode 100644
index 0000000000000000000000000000000000000000..be92381e05fc528d2fba5603365ee6df71b5b840
--- /dev/null
+++ b/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer/project.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (c) 2022 Huawei Device Co., Ltd.
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>30</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>
diff --git a/frameworks/libs/distributeddb/test/fuzztest/nbdelegate_fuzzer/BUILD.gn b/frameworks/libs/distributeddb/test/fuzztest/nbdelegate_fuzzer/BUILD.gn
index f7ad33321c8a10bbd23c2ae358cc8ab9673e0069..e73260a66ee163541c7d4609e33751f967799b35 100644
--- a/frameworks/libs/distributeddb/test/fuzztest/nbdelegate_fuzzer/BUILD.gn
+++ b/frameworks/libs/distributeddb/test/fuzztest/nbdelegate_fuzzer/BUILD.gn
@@ -61,7 +61,6 @@ ohos_fuzztest("NbDelegateFuzzTest") {
     "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/src/log_print.cpp",
     "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/src/platform_specific.cpp",
     "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/common/distributeddb_tools_test.cpp",
-    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_data_generate_unit_test.cpp",
     "nbdelegate_fuzzer.cpp",
   ]
 
diff --git a/frameworks/libs/distributeddb/test/fuzztest/nbdelegate_fuzzer/nbdelegate_fuzzer.cpp b/frameworks/libs/distributeddb/test/fuzztest/nbdelegate_fuzzer/nbdelegate_fuzzer.cpp
index 5138d498f002c823f2abb3a012b384912f8b5e45..e8c17d729116885f4cf545905cb80e5516b7b245 100644
--- a/frameworks/libs/distributeddb/test/fuzztest/nbdelegate_fuzzer/nbdelegate_fuzzer.cpp
+++ b/frameworks/libs/distributeddb/test/fuzztest/nbdelegate_fuzzer/nbdelegate_fuzzer.cpp
@@ -147,19 +147,71 @@ void FuzzCURD(const uint8_t* data, size_t size, KvStoreNbDelegate *kvNbDelegateP
     kvNbDelegatePtr->PutBatch(tmp);
     if (!keys.empty()) {
         /* random deletePublic updateTimestamp 2 */
-        kvNbDelegatePtr->UnpublishToLocal(keys[0], (data[0] > data[1]), (data[2] > data[1]));
+        bool deletePublic = true;
+        bool updateTimestamp = true;
+        if (size > 3u) {
+            deletePublic = (data[0] > data[1]);
+            updateTimestamp = (data[2] > data[1]);
+        }
+        kvNbDelegatePtr->UnpublishToLocal(keys[0], deletePublic, updateTimestamp);
     }
     kvNbDelegatePtr->DeleteBatch(keys);
     kvNbDelegatePtr->UnRegisterObserver(observer);
     kvNbDelegatePtr->PutLocalBatch(tmp);
-
+    kvNbDelegatePtr->DeleteLocalBatch(keys);
+    std::string tmpStoreId = kvNbDelegatePtr->GetStoreId();
+    SecurityOption secOption;
+    kvNbDelegatePtr->GetSecurityOption(secOption);
+    kvNbDelegatePtr->CheckIntegrity();
+    kvNbDelegatePtr->SetPushDataInterceptor(
+        [](InterceptedData &data, const std::string &sourceID, const std::string &targetID) {
+            int errCode = OK;
+            auto entries = data.GetEntries();
+            for (size_t i = 0; i < entries.size(); i++) {
+                if (entries[i].key.empty() || entries[i].key.at(0) != 'A') {
+                    continue;
+                }
+                auto newKey = entries[i].key;
+                newKey[0] = 'B';
+                errCode = data.ModifyKey(i, newKey);
+                if (errCode != OK) {
+                    break;
+                }
+            }
+            return errCode;
+        }
+    );
+    
     if (!keys.empty()) {
+        bool deleteLocal = true;
+        bool updateTimestamp = true;
+        if (size > 3u) {
+            deleteLocal = (data[0] > data[1]);
+            updateTimestamp = (data[2] > data[1]);
+        }
         /* random deletePublic updateTimestamp 2 */
-        kvNbDelegatePtr->PublishLocal(keys[0], (data[0] > data[1]), (data[2] > data[1]), nullptr);
+        kvNbDelegatePtr->PublishLocal(keys[0], deleteLocal, updateTimestamp, nullptr);
     }
     kvNbDelegatePtr->DeleteBatch(keys);
     std::string rawString(reinterpret_cast<const char *>(data), size);
     kvNbDelegatePtr->RemoveDeviceData(rawString);
+    kvNbDelegatePtr->RemoveDeviceData();
+}
+
+void EncryptOperation(const uint8_t* data, size_t size, std::string &DirPath, KvStoreNbDelegate *kvNbDelegatePtr)
+{
+    if (kvNbDelegatePtr == nullptr) {
+        return;
+    }
+    CipherPassword passwd;
+    int len = static_cast<int>(std::min(size, size_t(20)));
+    passwd.SetValue(data, len);
+    kvNbDelegatePtr->Rekey(passwd);
+    len = static_cast<int>(std::min(size, size_t(100)));
+    std::string fileName(data, data + len);
+    std::string mulitExportFileName = DirPath + "/" + fileName + ".db";
+    kvNbDelegatePtr->Export(mulitExportFileName, passwd);
+    kvNbDelegatePtr->Import(mulitExportFileName, passwd);
 }
 
 void CombineTest(const uint8_t* data, size_t size, KvStoreNbDelegate::Option &option)
@@ -176,6 +228,9 @@ void CombineTest(const uint8_t* data, size_t size, KvStoreNbDelegate::Option &op
             }
         });
     FuzzCURD(data, size, kvNbDelegatePtr);
+    if (option.isEncryptedDb) {
+        EncryptOperation(data, size, config.dataDir, kvNbDelegatePtr);
+    }
     kvManager.CloseKvStore(kvNbDelegatePtr);
     kvManager.DeleteKvStore("distributed_nb_delegate_test");
     DistributedDBToolsTest::RemoveTestDbFiles(config.dataDir);
diff --git a/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer/BUILD.gn b/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..10541455230d3a6530f2a69fe7edb16848af54d1
--- /dev/null
+++ b/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer/BUILD.gn
@@ -0,0 +1,111 @@
+# Copyright (c) 2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#####################hydra-fuzz###################
+import("//build/config/features.gni")
+import("//build/test.gni")
+
+##############################fuzztest##########################################
+ohos_fuzztest("RelationalstoredelegateFuzzTest") {
+  module_out_path = "kv_store/distributeddb"
+
+  include_dirs = [
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/common",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/common",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/include/distributeddb",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/interfaces/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/interfaces/src",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/storage/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/storage/src",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/storage/src/sqlite",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/storage/src/multiver",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/src",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/communicator/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/communicator/src",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/syncer/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/syncer/src",
+    "//commonlibrary/c_utils/base/include",
+    "//third_party/sqlite/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/include/relational",
+    "//third_party/jsoncpp/include/json",
+    "//third_party/skia/third_party/externals/spirv-headers/tools/buildHeaders/jsoncpp/dist/json",
+    "//third_party/skia/third_party/externals/swiftshader/third_party/SPIRV-Headers/tools/buildHeaders/jsoncpp/dist/json",
+    "//third_party/jsoncpp/include/json",
+    "//third_party/grpc/src/core/lib/json",
+  ]
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+
+  fuzz_config_file = "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer"
+
+  sources = [
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/src/db_common.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/src/log_print.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/src/platform_specific.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/common/distributeddb_tools_test.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/common/fuzzer_data.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer/relationalstoredelegate_fuzzer.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_data_generate_unit_test.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.cpp",
+  ]
+
+  defines = [
+    "SQLITE_ENABLE_SNAPSHOT",
+    "_LARGEFILE64_SOURCE",
+    "_FILE_OFFSET_BITS=64",
+    "SQLITE_HAS_CODEC",
+    "SQLITE_ENABLE_JSON1",
+    "USING_HILOG_LOGGER",
+    "USE_SQLITE_SYMBOLS",
+    "USING_DB_JSON_EXTRACT_AUTOMATICALLY",
+    "LOW_LEVEL_MEM_DEV",
+    "JSONCPP_USE_BUILDER",
+    "OMIT_FLATBUFFER",
+    "RELATIONAL_STORE",
+    "SQLITE_DISTRIBUTE_RELATIONAL",
+    "SQLITE_EXPORT_SYMBOLS",
+  ]
+
+  deps = [
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb:distributeddb",
+    "//third_party/jsoncpp:jsoncpp",
+    "//third_party/openssl:libcrypto_shared",
+    "//third_party/sqlite:sqlite",
+  ]
+
+  external_deps = [
+    "c_utils:utils",
+    "hiviewdfx_hilog_native:libhilog",
+  ]
+}
+
+###############################################################################
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [
+    # deps file
+    ":RelationalstoredelegateFuzzTest",
+  ]
+}
diff --git a/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer/corpus/init b/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer/corpus/init
new file mode 100644
index 0000000000000000000000000000000000000000..bc977bd9738ee9a70b362067f57a9c63d3adb801
--- /dev/null
+++ b/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer/corpus/init
@@ -0,0 +1,14 @@
+# Copyright (c) 2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+FUZZ
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer/project.xml b/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer/project.xml
new file mode 100644
index 0000000000000000000000000000000000000000..be92381e05fc528d2fba5603365ee6df71b5b840
--- /dev/null
+++ b/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer/project.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (c) 2022 Huawei Device Co., Ltd.
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>30</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>
diff --git a/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer/relationalstoredelegate_fuzzer.cpp b/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer/relationalstoredelegate_fuzzer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9a3e1ecb8bd535fd8e617c94f59ceb42ca8e2c00
--- /dev/null
+++ b/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer/relationalstoredelegate_fuzzer.cpp
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "relationalstoredelegate_fuzzer.h"
+#include "distributeddb_data_generate_unit_test.h"
+#include "distributeddb_tools_test.h"
+#include "log_print.h"
+#include "fuzzer_data.h"
+#include "relational_store_delegate.h"
+#include "relational_store_manager.h"
+#include "virtual_communicator_aggregator.h"
+#include "query.h"
+#include "store_types.h"
+#include "result_set.h"
+#include "runtime_context.h"
+
+namespace OHOS {
+using namespace DistributedDB;
+using namespace DistributedDBTest;
+using namespace DistributedDBUnitTest;
+
+constexpr const char* DB_SUFFIX = ".db";
+constexpr const char* STORE_ID = "Relational_Store_ID";
+const std::string DEVICE_A = "DEVICE_A";
+std::string g_testDir;
+std::string g_dbDir;
+DistributedDB::RelationalStoreManager g_mgr(APP_ID, USER_ID);
+sqlite3 *g_db = nullptr;
+RelationalStoreDelegate *g_delegate = nullptr;
+VirtualCommunicatorAggregator* g_communicatorAggregator = nullptr;
+const std::string NORMAL_CREATE_TABLE_SQL = "CREATE TABLE IF NOT EXISTS sync_data(" \
+    "key         BLOB NOT NULL UNIQUE," \
+    "value       BLOB," \
+    "timestamp   INT  NOT NULL," \
+    "flag        INT  NOT NULL," \
+    "device      BLOB," \
+    "ori_device  BLOB," \
+    "hash_key    BLOB PRIMARY KEY NOT NULL," \
+    "w_timestamp INT," \
+    "UNIQUE(device, ori_device));" \
+    "CREATE INDEX key_index ON sync_data (key, flag);";
+
+void Setup()
+{
+    DistributedDBToolsTest::TestDirInit(g_testDir);
+    g_dbDir = g_testDir + "/";
+    g_communicatorAggregator = new (std::nothrow) VirtualCommunicatorAggregator();
+    if (g_communicatorAggregator == nullptr) {
+        return;
+    }
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(g_communicatorAggregator);
+
+    g_db = RdbTestUtils::CreateDataBase(g_dbDir + STORE_ID + DB_SUFFIX);
+    if (g_db == nullptr) {
+        return;
+    }
+    if (RdbTestUtils::ExecSql(g_db, "PRAGMA journal_mode=WAL;") != SQLITE_OK) {
+        return;
+    }
+    if (RdbTestUtils::ExecSql(g_db, NORMAL_CREATE_TABLE_SQL) != SQLITE_OK) {
+        return;
+    }
+    if (RdbTestUtils::CreateDeviceTable(g_db, "sync_data", DEVICE_A) != 0) {
+        return;
+    }
+    LOGD("open store");
+    if (g_mgr.OpenStore(g_dbDir + STORE_ID + DB_SUFFIX, STORE_ID, {}, g_delegate) != E_OK) {
+        LOGE("fuzz open store faile");
+    }
+}
+
+void TearDown()
+{
+    LOGD("close store");
+    g_mgr.CloseStore(g_delegate);
+    g_delegate = nullptr;
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(nullptr);
+    g_communicatorAggregator = nullptr;
+    if (sqlite3_close_v2(g_db) != SQLITE_OK) {
+        LOGI("sqlite3_close_v2 faile");
+    }
+    g_db = nullptr;
+    DistributedDBToolsTest::RemoveTestDbFiles(g_testDir);
+}
+
+void CombineTest(const uint8_t* data, size_t size)
+{
+    if (g_delegate == nullptr) {
+        LOGI("delegate is null");
+        return;
+    }
+    FuzzerData fuzzerData(data, size);
+    uint32_t len = fuzzerData.GetUInt32();
+    const int lenMod = 30; // 30 is mod for string vector size
+    std::string tableName = fuzzerData.GetString(len % lenMod);
+    g_delegate->CreateDistributedTable(tableName);
+
+    std::vector<std::string> device = fuzzerData.GetStringVector(len % lenMod);
+    Query query = Query::Select();
+    int index = len % 3; // 3 is the mod
+    SyncMode mode = SyncMode::SYNC_MODE_PUSH_ONLY;
+    if (index == 1) {
+        mode = SyncMode::SYNC_MODE_PULL_ONLY;
+    } else if (index == 2) { // 2 is the remainder
+        mode = SyncMode::SYNC_MODE_PUSH_PULL;
+    }
+    g_delegate->Sync(device, mode, query, nullptr, len % 2); // 2 is mod num for wait parameter
+    std::string deviceId = device.size() > 0 ? device[0] : tableName;
+    g_delegate->RemoveDeviceData(deviceId);
+    g_delegate->RemoveDeviceData(deviceId, tableName);
+
+    RemoteCondition rc = { tableName, device };
+    std::shared_ptr<ResultSet> resultSet = nullptr;
+    uint64_t timeout = len;
+    g_delegate->RemoteQuery(deviceId, rc, timeout, resultSet);
+}
+}
+
+/* Fuzzer entry point */
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
+{
+    OHOS::Setup();
+    OHOS::CombineTest(data, size);
+    OHOS::TearDown();
+    return 0;
+}
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer/relationalstoredelegate_fuzzer.h b/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer/relationalstoredelegate_fuzzer.h
new file mode 100644
index 0000000000000000000000000000000000000000..c89e1dba997b751315ed2190211574f8f4fa45e6
--- /dev/null
+++ b/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer/relationalstoredelegate_fuzzer.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef RELATIONAL_STORE_DELEGATE_FUZZER_H
+#define RELATIONAL_STORE_DELEGATE_FUZZER_H
+
+#define FUZZ_PROJECT_NAME "relational_store_delegate_fuzzer"
+
+#endif // RELATIONAL_STORE_DELEGATE_FUZZER_H
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer/BUILD.gn b/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..558de907d0999f5d49d5ddb7287d073ae6ef3b04
--- /dev/null
+++ b/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer/BUILD.gn
@@ -0,0 +1,111 @@
+# Copyright (c) 2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#####################hydra-fuzz###################
+import("//build/config/features.gni")
+import("//build/test.gni")
+
+##############################fuzztest##########################################
+ohos_fuzztest("RelationalstoremanagerFuzzTest") {
+  module_out_path = "kv_store/distributeddb"
+
+  include_dirs = [
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/common",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/common",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/include/distributeddb",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/interfaces/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/interfaces/src",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/storage/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/storage/src",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/storage/src/sqlite",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/storage/src/multiver",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/src",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/communicator/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/communicator/src",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/syncer/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/syncer/src",
+    "//commonlibrary/c_utils/base/include",
+    "//third_party/sqlite/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/include/relational",
+    "//third_party/jsoncpp/include/json",
+    "//third_party/skia/third_party/externals/spirv-headers/tools/buildHeaders/jsoncpp/dist/json",
+    "//third_party/skia/third_party/externals/swiftshader/third_party/SPIRV-Headers/tools/buildHeaders/jsoncpp/dist/json",
+    "//third_party/jsoncpp/include/json",
+    "//third_party/grpc/src/core/lib/json",
+  ]
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+
+  fuzz_config_file = "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer"
+
+  sources = [
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/src/db_common.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/src/log_print.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/src/platform_specific.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/common/distributeddb_tools_test.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/common/fuzzer_data.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer/relationalstoremanager_fuzzer.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_data_generate_unit_test.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.cpp",
+  ]
+
+  defines = [
+    "SQLITE_ENABLE_SNAPSHOT",
+    "_LARGEFILE64_SOURCE",
+    "_FILE_OFFSET_BITS=64",
+    "SQLITE_HAS_CODEC",
+    "SQLITE_ENABLE_JSON1",
+    "USING_HILOG_LOGGER",
+    "USE_SQLITE_SYMBOLS",
+    "USING_DB_JSON_EXTRACT_AUTOMATICALLY",
+    "LOW_LEVEL_MEM_DEV",
+    "JSONCPP_USE_BUILDER",
+    "OMIT_FLATBUFFER",
+    "RELATIONAL_STORE",
+    "SQLITE_DISTRIBUTE_RELATIONAL",
+    "SQLITE_EXPORT_SYMBOLS",
+  ]
+
+  deps = [
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb:distributeddb",
+    "//third_party/jsoncpp:jsoncpp",
+    "//third_party/openssl:libcrypto_shared",
+    "//third_party/sqlite:sqlite",
+  ]
+
+  external_deps = [
+    "c_utils:utils",
+    "hiviewdfx_hilog_native:libhilog",
+  ]
+}
+
+###############################################################################
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [
+    # deps file
+    ":RelationalstoremanagerFuzzTest",
+  ]
+}
diff --git a/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer/corpus/init b/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer/corpus/init
new file mode 100644
index 0000000000000000000000000000000000000000..bc977bd9738ee9a70b362067f57a9c63d3adb801
--- /dev/null
+++ b/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer/corpus/init
@@ -0,0 +1,14 @@
+# Copyright (c) 2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+FUZZ
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer/project.xml b/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer/project.xml
new file mode 100644
index 0000000000000000000000000000000000000000..be92381e05fc528d2fba5603365ee6df71b5b840
--- /dev/null
+++ b/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer/project.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (c) 2022 Huawei Device Co., Ltd.
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>30</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>
diff --git a/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer/relationalstoremanager_fuzzer.cpp b/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer/relationalstoremanager_fuzzer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5621535136dad18d134563499b1f569993d68d1e
--- /dev/null
+++ b/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer/relationalstoremanager_fuzzer.cpp
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "relationalstoremanager_fuzzer.h"
+#include "distributeddb_data_generate_unit_test.h"
+#include "distributeddb_tools_test.h"
+#include "fuzzer_data.h"
+#include "relational_store_manager.h"
+#include "runtime_config.h"
+#include "store_changed_data.h"
+#include "virtual_communicator_aggregator.h"
+
+namespace OHOS {
+using namespace DistributedDB;
+using namespace DistributedDBTest;
+using namespace DistributedDBUnitTest;
+
+constexpr const char* DB_SUFFIX = ".db";
+constexpr const char* STORE_ID = "Relational_Store_ID";
+const std::string DEVICE_A = "DEVICE_A";
+std::string g_testDir;
+std::string g_dbDir;
+sqlite3 *g_db = nullptr;
+DistributedDB::RelationalStoreManager g_mgr(APP_ID, USER_ID);
+RelationalStoreDelegate *g_delegate = nullptr;
+VirtualCommunicatorAggregator* g_communicatorAggregator = nullptr;
+
+void Setup()
+{
+    DistributedDBToolsTest::TestDirInit(g_testDir);
+    g_dbDir = g_testDir + "/";
+    g_communicatorAggregator = new (std::nothrow) VirtualCommunicatorAggregator();
+    if (g_communicatorAggregator == nullptr) {
+        return;
+    }
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(g_communicatorAggregator);
+
+    g_db = RdbTestUtils::CreateDataBase(g_dbDir + STORE_ID + DB_SUFFIX);
+    if (g_db == nullptr) {
+        return;
+    }
+}
+
+void TearDown()
+{
+    g_mgr.CloseStore(g_delegate);
+    g_delegate = nullptr;
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(nullptr);
+    g_communicatorAggregator = nullptr;
+    if (sqlite3_close_v2(g_db) != SQLITE_OK) {
+        LOGI("sqlite3_close_v2 faile");
+    }
+    g_db = nullptr;
+    DistributedDBToolsTest::RemoveTestDbFiles(g_testDir);
+}
+
+void CombineTest(const uint8_t* data, size_t size)
+{
+    FuzzerData fuzzerData(data, size);
+    uint32_t instanceId = fuzzerData.GetUInt32();
+    std::string appId = fuzzerData.GetString(instanceId % 30);
+    std::string userId = fuzzerData.GetString(instanceId % 30);
+    std::string storeId = fuzzerData.GetString(instanceId % 30);
+    RelationalStoreManager::GetDistributedTableName(appId, userId);
+    RelationalStoreManager mgr(appId, userId, instanceId);
+    g_mgr.GetDistributedTableName(appId, userId);
+    g_mgr.OpenStore(g_dbDir + appId + DB_SUFFIX, storeId, {}, g_delegate);
+    g_mgr.GetRelationalStoreIdentifier(userId, appId, storeId, instanceId % 2); // 2 is mod num for last parameter
+    RuntimeConfig::SetProcessLabel(appId, userId);
+}
+}
+
+
+/* Fuzzer entry point */
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
+{
+    OHOS::Setup();
+    OHOS::CombineTest(data, size);
+    OHOS::TearDown();
+    return 0;
+}
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer/relationalstoremanager_fuzzer.h b/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer/relationalstoremanager_fuzzer.h
new file mode 100644
index 0000000000000000000000000000000000000000..141a66afd31e81f20f6c8197cfbbab906c49a7c8
--- /dev/null
+++ b/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer/relationalstoremanager_fuzzer.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef RELATIONAL_STORE_MANAGER_FUZZER_H
+#define RELATIONAL_STORE_MANAGER_FUZZER_H
+
+#define FUZZ_PROJECT_NAME "relationalstoremanager_fuzzer"
+
+#endif // RELATIONAL_STORE_MANAGER_FUZZER_H
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/fuzztest/schemadelegate_fuzzer/schemadelegate_fuzzer.h b/frameworks/libs/distributeddb/test/fuzztest/schemadelegate_fuzzer/schemadelegate_fuzzer.h
index 1baabe4be6fdd177ca592afd576d9f9218a2d1f6..9858530833bd7c3b068d390ca7071857343661ce 100644
--- a/frameworks/libs/distributeddb/test/fuzztest/schemadelegate_fuzzer/schemadelegate_fuzzer.h
+++ b/frameworks/libs/distributeddb/test/fuzztest/schemadelegate_fuzzer/schemadelegate_fuzzer.h
@@ -12,6 +12,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#ifndef SCHEMA_DELTEGATE_FUZZER_H
+#define SCHEMA_DELTEGATE_FUZZER_H
 
 #include <cstdint>
 #include <unistd.h>
@@ -22,3 +24,5 @@
 
 #define FUZZ_PROJECT_NAME "schemadelegate_fuzzer"
 
+#endif // SCHEMA_DELTEGATE_FUZZER_H
+
diff --git a/frameworks/libs/distributeddb/test/fuzztest/sync_fuzzer/BUILD.gn b/frameworks/libs/distributeddb/test/fuzztest/sync_fuzzer/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..e30d87c59c7d93f7a5be6523404702b9a9e178b8
--- /dev/null
+++ b/frameworks/libs/distributeddb/test/fuzztest/sync_fuzzer/BUILD.gn
@@ -0,0 +1,109 @@
+# Copyright (c) 2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#####################hydra-fuzz###################
+import("//build/config/features.gni")
+import("//build/test.gni")
+
+##############################fuzztest##########################################
+ohos_fuzztest("SyncFuzzTest") {
+  module_out_path = "kv_store/distributeddb"
+
+  include_dirs = [
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/common",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/common",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/interfaces/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/interfaces/src",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/storage/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/storage/src",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/storage/src/sqlite",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/storage/src/multiver",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/src",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/communicator/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/communicator/src",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/syncer/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/syncer/src",
+    "//commonlibrary/c_utils/base/include",
+    "//third_party/sqlite/include",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/include/relational",
+    "//third_party/jsoncpp/include/json",
+    "//third_party/skia/third_party/externals/spirv-headers/tools/buildHeaders/jsoncpp/dist/json",
+    "//third_party/skia/third_party/externals/swiftshader/third_party/SPIRV-Headers/tools/buildHeaders/jsoncpp/dist/json",
+    "//third_party/jsoncpp/include/json",
+    "//third_party/grpc/src/core/lib/json",
+  ]
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+
+  fuzz_config_file = "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/sync_fuzzer"
+
+  sources = [
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/src/db_common.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/src/log_print.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/src/platform_specific.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/common/distributeddb_tools_test.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/generic_virtual_device.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/kv_virtual_device.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.cpp",
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_single_ver_sync_db_Interface.cpp",
+    "sync_fuzzer.cpp",
+  ]
+
+  defines = [
+    "SQLITE_ENABLE_SNAPSHOT",
+    "_LARGEFILE64_SOURCE",
+    "_FILE_OFFSET_BITS=64",
+    "SQLITE_HAS_CODEC",
+    "SQLITE_ENABLE_JSON1",
+    "USING_HILOG_LOGGER",
+    "USE_SQLITE_SYMBOLS",
+    "USING_DB_JSON_EXTRACT_AUTOMATICALLY",
+    "LOW_LEVEL_MEM_DEV",
+    "JSONCPP_USE_BUILDER",
+    "OMIT_FLATBUFFER",
+    "RELATIONAL_STORE",
+    "SQLITE_DISTRIBUTE_RELATIONAL",
+  ]
+
+  deps = [
+    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb:distributeddb",
+    "//third_party/jsoncpp:jsoncpp",
+    "//third_party/openssl:libcrypto_shared",
+  ]
+
+  external_deps = [
+    "c_utils:utils",
+    "hiviewdfx_hilog_native:libhilog",
+  ]
+}
+
+###############################################################################
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [
+    # deps file
+    ":SyncFuzzTest",
+  ]
+}
diff --git a/frameworks/libs/distributeddb/test/fuzztest/sync_fuzzer/corpus/init b/frameworks/libs/distributeddb/test/fuzztest/sync_fuzzer/corpus/init
new file mode 100644
index 0000000000000000000000000000000000000000..bc977bd9738ee9a70b362067f57a9c63d3adb801
--- /dev/null
+++ b/frameworks/libs/distributeddb/test/fuzztest/sync_fuzzer/corpus/init
@@ -0,0 +1,14 @@
+# Copyright (c) 2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+FUZZ
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/fuzztest/sync_fuzzer/project.xml b/frameworks/libs/distributeddb/test/fuzztest/sync_fuzzer/project.xml
new file mode 100644
index 0000000000000000000000000000000000000000..5556db1cc4f35191401c6873e1768707f7cfd56f
--- /dev/null
+++ b/frameworks/libs/distributeddb/test/fuzztest/sync_fuzzer/project.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (c) 2022 Huawei Device Co., Ltd.
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>2000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>30</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>
diff --git a/frameworks/libs/distributeddb/test/fuzztest/sync_fuzzer/sync_fuzzer.cpp b/frameworks/libs/distributeddb/test/fuzztest/sync_fuzzer/sync_fuzzer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..497d7d7d4f4b7e19e928750dc21a6a804186d3d6
--- /dev/null
+++ b/frameworks/libs/distributeddb/test/fuzztest/sync_fuzzer/sync_fuzzer.cpp
@@ -0,0 +1,296 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "sync_fuzzer.h"
+
+#include "db_constant.h"
+#include "db_common.h"
+#include "distributeddb_data_generate_unit_test.h"
+#include "distributeddb_tools_test.h"
+#include "virtual_communicator_aggregator.h"
+#include "kv_store_nb_delegate.h"
+#include "kv_virtual_device.h"
+#include "platform_specific.h"
+#include "log_print.h"
+
+class KvStoreSyncFuzzer {
+    /* Keep C++ file names the same as the class name. */
+};
+
+namespace OHOS {
+using namespace DistributedDB;
+using namespace DistributedDBTest;
+
+VirtualCommunicatorAggregator* g_communicatorAggregator = nullptr;
+KvVirtualDevice *g_deviceB = nullptr;
+KvStoreDelegateManager g_mgr("APP_ID", "USER_ID");
+KvStoreNbDelegate* g_kvDelegatePtr = nullptr;
+const std::string DEVICE_B = "deviceB";
+const std::string STORE_ID = "kv_strore_sync_test";
+
+int InitEnv()
+{
+    g_communicatorAggregator = new (std::nothrow) VirtualCommunicatorAggregator();
+    if (g_communicatorAggregator == nullptr) {
+        return -E_OUT_OF_MEMORY;
+    }
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(g_communicatorAggregator);
+    return E_OK;
+}
+
+void FinalizeEnv()
+{
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(nullptr);
+}
+
+void SetUpTestcase()
+{
+    KvStoreNbDelegate::Option option = {true, false, false};
+    g_mgr.GetKvStore("distributed_nb_delegate_test", option,
+        [] (DBStatus status, KvStoreNbDelegate* kvNbDelegate) {
+            if (status == DBStatus::OK) {
+                g_kvDelegatePtr = kvNbDelegate;
+            }
+        });
+    g_deviceB = new (std::nothrow) KvVirtualDevice(DEVICE_B);
+    if (g_deviceB == nullptr) {
+        return;
+    }
+    VirtualSingleVerSyncDBInterface *syncInterfaceB = new (std::nothrow) VirtualSingleVerSyncDBInterface();
+    if (syncInterfaceB == nullptr) {
+        return;
+    }
+    g_deviceB->Initialize(g_communicatorAggregator, syncInterfaceB);
+}
+
+void TearDownTestCase()
+{
+    if (g_kvDelegatePtr != nullptr) {
+        g_mgr.CloseKvStore(g_kvDelegatePtr);
+        g_kvDelegatePtr = nullptr;
+        g_mgr.DeleteKvStore(STORE_ID);
+    }
+    if (g_deviceB != nullptr) {
+        delete g_deviceB;
+        g_deviceB = nullptr;
+    }
+}
+
+std::vector<Entry> CreateEntries(const uint8_t* data, size_t size, std::vector<Key> keys)
+{
+    std::vector<Entry> entries;
+    // key'length is less than 1024.
+    auto count = static_cast<int>(std::min(size, size_t(1024)));
+    for (int i = 1; i < count; i++) {
+        Entry entry;
+        entry.key = std::vector<uint8_t>(data, data + i);
+        keys.push_back(entry.key);
+        entry.value = std::vector<uint8_t>(data, data + size);
+        entries.push_back(entry);
+    }
+    return entries;
+}
+
+void NormalSyncPush(const uint8_t* data, size_t size, bool isWithQuery = false)
+{
+    SetUpTestcase();
+    if (g_kvDelegatePtr == nullptr) {
+        return;
+    }
+    std::vector<Key> keys;
+    std::vector<Entry> tmp = CreateEntries(data, size, keys);
+    g_kvDelegatePtr->PutBatch(tmp);
+    std::vector<std::string> devices;
+    devices.push_back(g_deviceB->GetDeviceId());
+    std::map<std::string, DBStatus> result;
+    if (isWithQuery) {
+        int len = std::min(size, size_t(100));
+        Key tmpKey = std::vector<uint8_t>(data, data + len);
+        Query query = Query::Select().PrefixKey(tmpKey);
+        DistributedDBToolsTest::SyncTestWithQuery(g_kvDelegatePtr, devices, SYNC_MODE_PUSH_ONLY, result, query);
+    } else {
+        DistributedDBToolsTest::SyncTest(g_kvDelegatePtr, devices, SYNC_MODE_PUSH_ONLY, result);
+    }
+    TearDownTestCase();
+}
+
+void NormalSyncPull(const uint8_t* data, size_t size, bool isWithQuery = false)
+{
+    SetUpTestcase();
+    if (g_kvDelegatePtr == nullptr) {
+        return;
+    }
+    std::vector<Key> keys;
+    std::vector<Entry> tmp = CreateEntries(data, size, keys);
+    g_kvDelegatePtr->PutBatch(tmp);
+    int i = 0;
+    for (auto &item : tmp) {
+        g_deviceB->PutData(item.key, item.value, i++, 0);
+    }
+    int pushfinishedFlag = 0;
+    g_kvDelegatePtr->SetRemotePushFinishedNotify(
+        [&pushfinishedFlag](const RemotePushNotifyInfo &info) {
+            pushfinishedFlag = 1;
+    });
+
+    std::vector<std::string> devices;
+    devices.push_back(g_deviceB->GetDeviceId());
+    std::map<std::string, DBStatus> result;
+    if (isWithQuery) {
+        int len = std::min(size, size_t(100));
+        Key tmpKey = std::vector<uint8_t>(data, data + len);
+        Query query = Query::Select().PrefixKey(tmpKey);
+        DistributedDBToolsTest::SyncTestWithQuery(g_kvDelegatePtr, devices, SYNC_MODE_PULL_ONLY, result, query);
+    } else {
+        DistributedDBToolsTest::SyncTest(g_kvDelegatePtr, devices, SYNC_MODE_PULL_ONLY, result);
+    }
+    TearDownTestCase();
+}
+
+void NormalSyncPushAndPull(const uint8_t* data, size_t size, bool isWithQuery = false)
+{
+    SetUpTestcase();
+    if (g_kvDelegatePtr == nullptr) {
+        return;
+    }
+    std::vector<Key> keys;
+    std::vector<Entry> tmp = CreateEntries(data, size, keys);
+    g_kvDelegatePtr->PutBatch(tmp);
+    std::vector<std::string> devices;
+    devices.push_back(g_deviceB->GetDeviceId());
+    std::map<std::string, DBStatus> result;
+    if (isWithQuery) {
+        int len = std::min(size, size_t(100));
+        Key tmpKey = std::vector<uint8_t>(data, data + len);
+        Query query = Query::Select().PrefixKey(tmpKey);
+        DistributedDBToolsTest::SyncTestWithQuery(g_kvDelegatePtr, devices, SYNC_MODE_PUSH_PULL, result, query);
+    } else {
+        DistributedDBToolsTest::SyncTest(g_kvDelegatePtr, devices, SYNC_MODE_PUSH_PULL, result);
+    }
+    TearDownTestCase();
+}
+
+void SubscribeOperation(const uint8_t* data, size_t size)
+{
+    SetUpTestcase();
+    if (g_kvDelegatePtr == nullptr) {
+        return;
+    }
+    std::vector<std::string> devices;
+    devices.push_back(g_deviceB->GetDeviceId());
+    Query query2 = Query::Select().EqualTo("$.field_name1", 1).Limit(20, 0);
+    g_kvDelegatePtr->SubscribeRemoteQuery(devices, nullptr, query2, true);
+    std::set<Key> keys;
+    int count = std::min(size, size_t(3));
+    for (int i = 0; i < count; i++) {
+        Key tmpKey = std::vector<uint8_t>(data + i, data + i + 1);
+        keys.insert(tmpKey);
+    }
+    Query query = Query::Select().InKeys(keys);
+    g_kvDelegatePtr->SubscribeRemoteQuery(devices, nullptr, query, true);
+    g_kvDelegatePtr->UnSubscribeRemoteQuery(devices, nullptr, query2, true);
+    g_kvDelegatePtr->UnSubscribeRemoteQuery(devices, nullptr, query, true);
+    TearDownTestCase();
+}
+
+void OtherOperation(const uint8_t* data, size_t size)
+{
+    SetUpTestcase();
+    if (g_kvDelegatePtr == nullptr) {
+        return;
+    }
+    int len = std::min(size, size_t(10));
+    std::string tmpIdentifier(data, data + len);
+    std::vector<std::string> targets;
+    int j = 0;
+    int count = std::min(size, size_t(4));
+    for (int i = 0; i < count; i++) {
+        std::string tmpStr(data + j, data + j + 1);
+        j = j + 10; // target size is 10
+        targets.push_back(tmpStr);
+        if ((1 + j) >= static_cast<int>(size)) {
+            break;
+        }
+    }
+    g_kvDelegatePtr->SetEqualIdentifier(tmpIdentifier, targets);
+    TearDownTestCase();
+}
+
+void PragmaOperation(const uint8_t* data, size_t size)
+{
+    SetUpTestcase();
+    if (g_kvDelegatePtr == nullptr) {
+        return;
+    }
+    bool autoSync = (size == 0) ? true : data[0];
+    PragmaData praData = static_cast<PragmaData>(&autoSync);
+    g_kvDelegatePtr->Pragma(AUTO_SYNC, praData);
+
+    PragmaDeviceIdentifier param1;
+    int len = std::min(size, size_t(100));
+    std::string tmpStr(data, data + len);
+    param1.deviceID = tmpStr;
+    PragmaData input = static_cast<void *>(&param1);
+    g_kvDelegatePtr->Pragma(GET_IDENTIFIER_OF_DEVICE, input);
+
+    PragmaEntryDeviceIdentifier param2;
+    len = std::min(size, size_t(10)); // use min 10
+    param2.key.assign(data, data + len);
+    param2.origDevice = false;
+    input = static_cast<void *>(&param2);
+    g_kvDelegatePtr->Pragma(GET_DEVICE_IDENTIFIER_OF_ENTRY, input);
+
+    int size2;
+    input = static_cast<PragmaData>(&size2);
+    g_kvDelegatePtr->Pragma(GET_QUEUED_SYNC_SIZE, input);
+
+    auto *r = reinterpret_cast<const int *>(data);
+    int limit = *r;
+    input = static_cast<PragmaData>(&limit);
+    g_kvDelegatePtr->Pragma(SET_QUEUED_SYNC_LIMIT, input);
+
+    int limit2 = 0;
+    input = static_cast<PragmaData>(&limit2);
+    g_kvDelegatePtr->Pragma(GET_QUEUED_SYNC_LIMIT, input);
+    TearDownTestCase();
+}
+
+void FuzzSync(const uint8_t* data, size_t size)
+{
+    KvStoreConfig config;
+    DistributedDBToolsTest::TestDirInit(config.dataDir);
+    g_mgr.SetKvStoreConfig(config);
+    InitEnv();
+    NormalSyncPush(data, size);
+    NormalSyncPull(data, size);
+    NormalSyncPushAndPull(data, size);
+    NormalSyncPush(data, size, true);
+    NormalSyncPull(data, size, true);
+    NormalSyncPushAndPull(data, size, true);
+    SubscribeOperation(data, size);
+    OtherOperation(data, size);
+    PragmaOperation(data, size);
+    FinalizeEnv();
+    DistributedDBToolsTest::RemoveTestDbFiles(config.dataDir);
+}
+}
+
+/* Fuzzer entry point */
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
+{
+    OHOS::FuzzSync(data, size);
+    return 0;
+}
+
diff --git a/frameworks/libs/distributeddb/test/fuzztest/sync_fuzzer/sync_fuzzer.h b/frameworks/libs/distributeddb/test/fuzztest/sync_fuzzer/sync_fuzzer.h
new file mode 100644
index 0000000000000000000000000000000000000000..40a6f49cd407e6fa50f1f46c9d289b7b8c6fc54b
--- /dev/null
+++ b/frameworks/libs/distributeddb/test/fuzztest/sync_fuzzer/sync_fuzzer.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SYNC_FUZZER_H
+#define SYNC_FUZZER_H
+
+#define FUZZ_PROJECT_NAME "Sync_fuzzer"
+
+#endif // NBDELEGATE_FUZZER_H
diff --git a/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.cpp
index f4cba596589bfa98ce5e2aae7cb472dc11a5b8df..540306ed1c7ccbc2250e4f42e601e488f8d21883 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.cpp
@@ -15,10 +15,13 @@
 
 #include "distributeddb_tools_unit_test.h"
 
+#include <codecvt>
+#include <cstdio>
 #include <cstring>
 #include <dirent.h>
 #include <fstream>
 #include <gtest/gtest.h>
+#include <locale>
 #include <openssl/rand.h>
 #include <random>
 #include <set>
@@ -29,6 +32,7 @@
 #include "db_constant.h"
 #include "generic_single_ver_kv_entry.h"
 #include "platform_specific.h"
+#include "runtime_config.h"
 #include "single_ver_data_packet.h"
 #include "value_hash_calc.h"
 
@@ -664,6 +668,22 @@ void DistributedDBToolsUnitTest::CalcHash(const std::vector<uint8_t> &value, std
     hashCalc.GetResult(hashValue);
 }
 
+void DistributedDBToolsUnitTest::Dump()
+{
+    constexpr const char *rightDumpParam = "dump-distributeddb";
+    constexpr const char *ignoreDumpParam = "ignore-param";
+    const std::u16string u16DumpRightParam =
+        std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> {}.from_bytes(rightDumpParam);
+    const std::u16string u16DumpIgnoreParam =
+        std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> {}.from_bytes(ignoreDumpParam);
+    std::vector<std::u16string> params = {
+        u16DumpRightParam,
+        u16DumpIgnoreParam
+    };
+    // print to std::cout
+    RuntimeConfig::Dump(0, params);
+}
+
 KvStoreObserverUnitTest::KvStoreObserverUnitTest() : callCount_(0), isCleared_(false)
 {}
 
diff --git a/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.h b/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.h
index 68bcdbae88169c31bc3c4607dcdae4397d923b41..675f8f253c4733fe5bcb4b5ab94a0e30815b74be 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.h
+++ b/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.h
@@ -216,6 +216,8 @@ public:
 
     static int BuildMessage(const DataSyncMessageInfo &messageInfo, DistributedDB::Message *&message);
 
+    static void Dump();
+
 private:
     static int OpenMockMultiDb(DatabaseInfo &dbInfo, DistributedDB::OpenDbProperties &properties);
 
diff --git a/frameworks/libs/distributeddb/test/unittest/common/common/evloop_timer_unit_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/common/evloop_timer_unit_test.cpp
index b9e48b9d5155b775086ae251c1f5dc535dbaf0a5..e8be7df92b0b0511cb1155404e74921099dbb0ae 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/common/evloop_timer_unit_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/common/evloop_timer_unit_test.cpp
@@ -19,8 +19,8 @@
 
 #include "db_errno.h"
 #include "distributeddb_tools_unit_test.h"
-#include "evloop/include/ievent.h"
-#include "evloop/include/ievent_loop.h"
+#include "evloop/src/ievent.h"
+#include "evloop/src/ievent_loop.h"
 #include "log_print.h"
 #include "platform_specific.h"
 
diff --git a/frameworks/libs/distributeddb/test/unittest/common/common/system_timer.cpp b/frameworks/libs/distributeddb/test/unittest/common/common/system_timer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eb2215b6f2010de14381cf8c58f8bf68022db6c6
--- /dev/null
+++ b/frameworks/libs/distributeddb/test/unittest/common/common/system_timer.cpp
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "system_timer.h"
+
+#include <atomic>
+#include <sys/time.h>
+
+#include "log_print.h"
+#include "platform_specific.h"
+
+namespace {
+    const uint64_t MULTIPLES_BETWEEN_SECONDS_AND_MICROSECONDS = 1000000;
+    std::atomic<int64_t> timeOffset(0);
+}
+
+namespace DistributedDB {
+namespace OS {
+
+#ifdef RUNNING_ON_SIMULATED_ENV
+int GetCurrentSysTimeInMicrosecond(uint64_t &outTime)
+{
+    struct timeval rawTime;
+    int errCode = gettimeofday(&rawTime, nullptr);
+    if (errCode < 0) {
+        LOGE("[GetSysTime] Fail:%d.", errCode);
+        return errCode;
+    }
+    outTime = static_cast<uint64_t>(rawTime.tv_sec) * MULTIPLES_BETWEEN_SECONDS_AND_MICROSECONDS +
+        static_cast<uint64_t>(rawTime.tv_usec);
+    outTime = outTime + timeOffset.load();
+    return 0;
+}
+#endif // RUNNING_ON_SIMULATED_ENV
+
+void SetOffsetBySecond(int64_t inSecond)
+{
+    int64_t microSecond = static_cast<int64_t>(inSecond) * 1000 * 1000; // to ms
+    timeOffset.store(microSecond);
+    LOGD("[SetTimeOffset] offset : %llds", inSecond);
+}
+}
+}
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/unittest/common/common/system_timer.h b/frameworks/libs/distributeddb/test/unittest/common/common/system_timer.h
new file mode 100644
index 0000000000000000000000000000000000000000..227821b6c4f6625848967d5640eadb4259de4746
--- /dev/null
+++ b/frameworks/libs/distributeddb/test/unittest/common/common/system_timer.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SYSTEM_TIMER_H
+#define SYSTEM_TIMER_H
+
+#include <cstdint>
+
+namespace DistributedDB {
+namespace OS {
+void SetOffsetBySecond(int64_t inSecond);
+}
+}
+#endif // SYSTEM_TIMER_H
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_import_and_export_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_import_and_export_test.cpp
index 552c2f4f92532674bf3f3b15ace69aa6a4187f52..08bebb0064357050a0935eeeda82140f125c5ba3 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_import_and_export_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_import_and_export_test.cpp
@@ -15,6 +15,7 @@
 #ifndef OMIT_ENCRYPT
 #include <gtest/gtest.h>
 
+#include "db_common.h"
 #include "distributeddb_data_generate_unit_test.h"
 #include "platform_specific.h"
 #include "process_communicator_test_stub.h"
@@ -116,6 +117,7 @@ void DistributedDBInterfacesImportAndExportTest::TearDownTestCase(void)
     if (DistributedDBToolsUnitTest::RemoveTestDbFiles(g_testDir) != 0) {
         LOGE("rm test db files error!");
     }
+    RuntimeContext::GetInstance()->StopTaskPool(); // wait for all thread exit
 }
 
 void DistributedDBInterfacesImportAndExportTest::SetUp(void)
@@ -1179,4 +1181,62 @@ HWTEST_F(DistributedDBInterfacesImportAndExportTest, ForceExportTest001, TestSiz
     g_kvNbDelegatePtr = nullptr;
     EXPECT_EQ(g_mgr.DeleteKvStore(STORE_ID_1), OK);
 }
-#endif
+
+/**
+  * @tc.name: ImportWithTimeChange001
+  * @tc.desc: Import DB after time changed.
+  * @tc.type: FUNC
+  * @tc.require:
+  * @tc.author: lianhuix
+  */
+HWTEST_F(DistributedDBInterfacesImportAndExportTest, ImportWithTimeChange001, TestSize.Level1)
+{
+    KvStoreNbDelegate::Option option = {true, false, false};
+    std::string storeId = "ImportWithTimeChange001";
+    g_mgr.GetKvStore(storeId, option, g_kvNbDelegateCallback);
+    EXPECT_EQ(g_kvDelegateStatus, OK);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+
+    EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_1), OK);
+
+    // fake entry timestamp
+    std::string origId = USER_ID + "-" + APP_ID + "-" + storeId;
+    std::string identifier = DBCommon::TransferHashString(origId);
+    std::string hexDir = DBCommon::TransferStringToHex(identifier);
+    std::string dbPath = g_testDir + "/" + hexDir + "/single_ver/main/gen_natural_store.db";
+    sqlite3 *db = RelationalTestUtils::CreateDataBase(dbPath);
+    ASSERT_NE(db, nullptr);
+    std::string fakeSql = "UPDATE sync_data SET timestamp = 3270281552768731970, w_timestamp = 3270281552768731970";
+    EXPECT_EQ(RelationalTestUtils::ExecSql(db, fakeSql), OK);
+    EXPECT_EQ(sqlite3_close_v2(db), SQLITE_OK);
+    db = nullptr;
+
+    // prepare import file with timestamp later then current
+    CipherPassword passwd;
+    std::string exportFileName = g_exportFileDir + storeId + ".back";
+    EXPECT_EQ(g_kvNbDelegatePtr->Export(exportFileName, passwd, true), OK);
+
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    g_kvNbDelegatePtr = nullptr;
+    EXPECT_EQ(g_mgr.DeleteKvStore(storeId), OK);
+
+    // import
+    g_mgr.GetKvStore(STORE_ID_1, option, g_kvNbDelegateCallback);
+    EXPECT_EQ(g_kvDelegateStatus, OK);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+
+    EXPECT_EQ(g_kvNbDelegatePtr->Import(exportFileName, passwd), OK);
+
+    // check crud normal
+    EXPECT_EQ(g_kvNbDelegatePtr->Delete(KEY_1), OK);
+    Value val;
+    EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_1, val), NOT_FOUND);
+
+    EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_2, VALUE_2), OK);
+    EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_2, val), OK);
+
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    g_kvNbDelegatePtr = nullptr;
+    EXPECT_EQ(g_mgr.DeleteKvStore(STORE_ID_1), OK);
+}
+#endif // OMIT_ENCRYPT
diff --git a/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_nb_delegate_schema_put_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_nb_delegate_schema_put_test.cpp
index 96246688dcfd41ebdc1e0af5287385ad9179b23b..eefdbe910498b964131970093faf61aa1ab6cb31 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_nb_delegate_schema_put_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_nb_delegate_schema_put_test.cpp
@@ -42,6 +42,13 @@ namespace {
             "\"field_name2\":\"INTEGER, NOT NULL\""
         "},"
         "\"SCHEMA_INDEXES\":[\"$.field_name1\"]}";
+    const std::string VALID_SCHEMA_COMPA_WITH_SQL_KEYWORD_DEFINE = "{\"SCHEMA_VERSION\":\"1.0\","
+        "\"SCHEMA_MODE\":\"COMPATIBLE\","
+        "\"SCHEMA_DEFINE\":{"
+            "\"create\":\"BOOL\","
+            "\"default\":\"INTEGER, NOT NULL\""
+        "},"
+        "\"SCHEMA_INDEXES\":[\"create\"]}";
     // define some variables to init a KvStoreDelegateManager object.
     KvStoreDelegateManager g_mgr("app0", "user0");
     std::string g_testDir;
@@ -371,4 +378,35 @@ HWTEST_F(DistributedDBInterfacesNBDelegateSchemaPutTest, QueryDeleted001, TestSi
     EXPECT_EQ(resultSet->GetCount(), 0);
     EXPECT_EQ(g_kvStore->CloseResultSet(resultSet), OK);
 }
-#endif
\ No newline at end of file
+
+/**
+  * @tc.name: SqliteKeyWord001
+  * @tc.desc: Test kv schema with sqlite key world.
+  * @tc.type: FUNC
+  * @tc.require:
+  * @tc.author: lianhuix
+  */
+HWTEST_F(DistributedDBInterfacesNBDelegateSchemaPutTest, SqliteKeyWord001, TestSize.Level1)
+{
+    KvStoreNbDelegate::Option option = {true, false, false};
+    option.schema = VALID_SCHEMA_COMPA_WITH_SQL_KEYWORD_DEFINE;
+    g_mgr.GetKvStore(g_storeName, option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvStore != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+
+    /**
+     * @tc.steps:step1. Put one data whose value has more fields than the schema.
+     * @tc.expected: step1. return INVALID_VALUE_FIELDS.
+     */
+    Key key;
+    DistributedDBToolsUnitTest::GetRandomKeyValue(key);
+    std::string moreData = "{\"create\":true,\"default\":10,\"field_name3\":10}";
+    Value value(moreData.begin(), moreData.end());
+    EXPECT_EQ(g_kvStore->Put(key, value), OK);
+
+    std::vector<Entry> entries;
+    Query query = Query::Select().EqualTo("create", true);
+    EXPECT_EQ(g_kvStore->GetEntries(query, entries), OK);
+    EXPECT_EQ(entries.size(), 1U);
+}
+#endif // OMIT_JSON
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_nb_delegate_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_nb_delegate_test.cpp
index ce4284220b57eda8d0794bfaab12f0734fbf7b5f..f5d013f89627c1ed4253c1833986193798d82a7b 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_nb_delegate_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_nb_delegate_test.cpp
@@ -26,6 +26,7 @@
 #include "process_system_api_adapter_impl.h"
 #include "runtime_context.h"
 #include "sqlite_single_ver_natural_store.h"
+#include "system_timer.h"
 #include "kv_virtual_device.h"
 #include "virtual_communicator_aggregator.h"
 
@@ -1882,6 +1883,7 @@ HWTEST_F(DistributedDBInterfacesNBDelegateTest, MaxLogSize002, TestSize.Level2)
     EXPECT_EQ(g_kvNbDelegatePtr->Put(key, value), OK);
     DistributedDBToolsUnitTest::GetRandomKeyValue(key, 40); // for 40B random key
     EXPECT_EQ(g_kvNbDelegatePtr->Put(key, value), OK);
+
     DistributedDBToolsUnitTest::GetRandomKeyValue(key, 20); // for 20B random key
     DistributedDBToolsUnitTest::GetRandomKeyValue(value, 1 * 1024 * 1024); // 1M value
     EXPECT_EQ(g_kvNbDelegatePtr->Put(key, value), OK);
@@ -2085,6 +2087,66 @@ HWTEST_F(DistributedDBInterfacesNBDelegateTest, BusyTest001, TestSize.Level1)
     EXPECT_EQ(mgr.DeleteKvStore(STORE_ID_1), OK);
 }
 
+/**
+ * @tc.name: GetKeys001
+ * @tc.desc: Test get keys from the database.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: zhangqiquan
+ */
+HWTEST_F(DistributedDBInterfacesNBDelegateTest, GetKeys001, TestSize.Level1)
+{
+    /**
+     * @tc.steps:step1. Create database.
+     * @tc.expected: step1. Returns a non-null kvstore.
+     */
+    KvStoreNbDelegate::Option option;
+    g_mgr.GetKvStore("GetKeys001", option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+
+    /**
+     * @tc.steps:step2. Put the all keys into the database.
+     * @tc.expected: step2. Returns OK.
+     */
+    std::vector<Key> expectKeys = {
+        {'k', '1', '1'},
+        {'k', '2'},
+        {'k', '3'},
+        {'k', '4'}
+    };
+    for (const auto &key : expectKeys) {
+        EXPECT_EQ(g_kvNbDelegatePtr->Put(key, {}), OK);
+    }
+    EXPECT_EQ(g_kvNbDelegatePtr->Put({'k', '2'}, {}), OK);
+    EXPECT_EQ(g_kvNbDelegatePtr->Delete({'k', '4'}), OK);
+
+    /**
+     * @tc.steps:step3. Get the all keys.
+     * @tc.expected: step3. Returns OK.
+     */
+    Key keyPrefix = {'k', '1'};
+    std::vector<Key> actualKeys;
+    EXPECT_EQ(g_kvNbDelegatePtr->GetKeys(keyPrefix, actualKeys), OK);
+    EXPECT_EQ(actualKeys.size(), 1u); // get the k11
+    for (const auto &key : actualKeys) {
+        EXPECT_EQ(key, expectKeys[0]);
+    }
+    keyPrefix.clear();
+    EXPECT_EQ(g_kvNbDelegatePtr->GetKeys(keyPrefix, actualKeys), OK);
+    EXPECT_EQ(actualKeys.size(), 3u); // size of all the key is 3
+
+    keyPrefix = {'k', '4'};
+    EXPECT_EQ(g_kvNbDelegatePtr->GetKeys(keyPrefix, actualKeys), NOT_FOUND);
+    EXPECT_EQ(actualKeys.size(), 0u); // not found key and size is 0
+
+    DistributedDBToolsUnitTest::GetRandomKeyValue(keyPrefix, 2048); // for 2048B random key
+    EXPECT_EQ(g_kvNbDelegatePtr->GetKeys(keyPrefix, actualKeys), INVALID_ARGS);
+    EXPECT_EQ(actualKeys.size(), 0u); // invalid prefix key and size is 0
+
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore("GetKeys001"), OK);
+}
 namespace {
 void InitVirtualDevice(const std::string &devId, KvVirtualDevice *&devices,
     VirtualSingleVerSyncDBInterface *&syncInterface)
@@ -2157,4 +2219,53 @@ HWTEST_F(DistributedDBInterfacesNBDelegateTest, RemoveDeviceDataTest001, TestSiz
     FreeVirtualDevice(g_deviceB);
     FreeVirtualDevice(g_deviceC);
     FreeVirtualDevice(g_deviceD);
+}
+
+/**
+  * @tc.name: TimeChangeWithCloseStoreTest001
+  * @tc.desc: Test close store with time changed
+  * @tc.type: FUNC
+  * @tc.require:
+  * @tc.author: lianhuix
+  */
+HWTEST_F(DistributedDBInterfacesNBDelegateTest, TimeChangeWithCloseStoreTest001, TestSize.Level3)
+{
+    KvStoreDelegateManager mgr(APP_ID, USER_ID);
+    mgr.SetKvStoreConfig(g_config);
+
+    std::atomic<bool> isFinished(false);
+
+    std::vector<std::thread> slowThreads;
+    for (int i = 0; i < 10; i++) { // 10: thread to slow donw system
+        std::thread th([&isFinished]() {
+            while (!isFinished) {
+                // pass
+            }
+        });
+        slowThreads.emplace_back(std::move(th));
+    }
+
+    std::thread th([&isFinished]() {
+        int timeChangedCnt = 0;
+        while (!isFinished.load()) {
+            OS::SetOffsetBySecond(100 - timeChangedCnt++ * 2); // 100 2 : fake system time change
+            std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 100: wait for a while
+        }
+    });
+
+    for (int i = 0; i < 100; i++) { // run 100 times
+        const KvStoreNbDelegate::Option option = {true, false, false};
+        mgr.GetKvStore(STORE_ID_1, option, g_kvNbDelegateCallback);
+        ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+        EXPECT_EQ(g_kvDelegateStatus, OK);
+        EXPECT_EQ(mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    }
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 1000: wait for a while
+    isFinished.store(true);
+    th.join();
+    for (auto &it : slowThreads) {
+        it.join();
+    }
+    EXPECT_EQ(mgr.DeleteKvStore(STORE_ID_1), OK);
 }
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_relational_sync_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_relational_sync_test.cpp
index bb0f38e14545b871836c743d3b32df5b1fa1fcd3..27fb2a4022bf238fd90f981044f5cc7a7dd8410a 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_relational_sync_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_relational_sync_test.cpp
@@ -31,6 +31,7 @@ namespace {
     constexpr const char* DB_SUFFIX = ".db";
     constexpr const char* STORE_ID = "Relational_Store_ID";
     const std::string DEVICE_A = "DEVICE_A";
+    const std::string DEVICE_B = "DEVICE_B";
     std::string g_testDir;
     std::string g_dbDir;
     DistributedDB::RelationalStoreManager g_mgr(APP_ID, USER_ID);
@@ -72,8 +73,6 @@ namespace {
             "flag=0x22 WHERE hash_key=calc_hash(OLD.id) AND flag&0x02=0x02;\n"
             "END;";
         EXPECT_EQ(RelationalTestUtils::ExecSql(db, oldTrigger), SQLITE_OK);
-        std::string logVersion = "UPDATE naturalbase_rdb_aux_metadata SET value = '1.0'" \
-            " where key = 'log_table_version'";
         Key key;
         DBCommon::StringToVector("log_table_version", key);
         Value val;
@@ -468,13 +467,13 @@ HWTEST_F(DistributedDBInterfacesRelationalSyncTest, UpgradeTriggerTest001, TestS
     EXPECT_EQ(errCode, E_OK);
     LOGD("result trigger: %s", resultTrigger.c_str());
     std::string expectTrigger = "CREATE TRIGGER naturalbase_rdb_student_1_ON_UPDATE AFTER UPDATE \n"
-        "ON student_1\n"
+        "ON 'student_1'\n"
         "BEGIN\n"
         "\t UPDATE naturalbase_rdb_aux_student_1_log SET data_key=-1,timestamp=get_sys_time(0), device='',"
-        " flag=0x03 WHERE hash_key=calc_hash(OLD.id) AND flag&0x02=0x02;\n"
+        " flag=0x03 WHERE hash_key=calc_hash(OLD.'id') AND flag&0x02=0x02;\n"
         "\t INSERT OR REPLACE INTO naturalbase_rdb_aux_student_1_log VALUES (NEW.rowid, '', '', get_sys_time(0), "
-        "get_sys_time(0), CASE WHEN (calc_hash(NEW.id) != calc_hash(NEW.id)) " \
-        "THEN 0x02 ELSE 0x22 END, calc_hash(NEW.id));\n"
+        "get_sys_time(0), CASE WHEN (calc_hash(NEW.'id') != calc_hash(NEW.'id')) " \
+        "THEN 0x02 ELSE 0x22 END, calc_hash(NEW.'id'));\n"
         "END";
     EXPECT_TRUE(resultTrigger == expectTrigger);
 }
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_relational_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_relational_test.cpp
index bf5892783260b60c9d9ab031e6f0fa417fb6355e..5763e5e79a84aa61929a5d00182298256fbbc446 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_relational_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_relational_test.cpp
@@ -24,6 +24,9 @@
 #include "platform_specific.h"
 #include "relational_store_manager.h"
 #include "relational_store_sqlite_ext.h"
+#include "relational_virtual_device.h"
+#include "runtime_config.h"
+#include "virtual_relational_ver_sync_db_interface.h"
 
 using namespace testing::ext;
 using namespace DistributedDB;
@@ -37,6 +40,11 @@ namespace {
     std::string g_dbDir;
     DistributedDB::RelationalStoreManager g_mgr(APP_ID, USER_ID);
 
+    const std::string DEVICE_A = "real_device";
+    const std::string DEVICE_B = "deviceB";
+    VirtualCommunicatorAggregator* g_communicatorAggregator = nullptr;
+    RelationalVirtualDevice *g_deviceB = nullptr;
+
     const std::string NORMAL_CREATE_TABLE_SQL = "CREATE TABLE IF NOT EXISTS sync_data(" \
         "key         BLOB NOT NULL UNIQUE," \
         "value       BLOB," \
@@ -49,6 +57,8 @@ namespace {
         "UNIQUE(device, ori_device));" \
         "CREATE INDEX key_index ON sync_data (key, flag);";
 
+    const std::string SIMPLE_CREATE_TABLE_SQL = "CREATE TABLE IF NOT EXISTS t1(a INT, b TEXT)";
+
     const std::string CREATE_TABLE_SQL_NO_PRIMARY_KEY = "CREATE TABLE IF NOT EXISTS sync_data(" \
         "key         BLOB NOT NULL UNIQUE," \
         "value       BLOB," \
@@ -75,6 +85,21 @@ namespace {
         "VALUES('KEY', 123456789, 1, 'HASH_KEY');";
 
     const std::string INVALID_TABLE_FIELD_SQL = "create table if not exists t1 ('1 = 1; --' int primary key, b blob)";
+
+    void PrepareVirtualDeviceEnv(const std::string &tableName, const std::string &dbPath,
+        const std::vector<RelationalVirtualDevice *> &remoteDeviceVec)
+    {
+        sqlite3 *db = RelationalTestUtils::CreateDataBase(dbPath);
+        ASSERT_NE(db, nullptr);
+        TableInfo tableInfo;
+        SQLiteUtils::AnalysisSchema(db, tableName, tableInfo);
+        for (const auto &dev : remoteDeviceVec) {
+            std::vector<FieldInfo> fieldInfoList = tableInfo.GetFieldInfos();
+            dev->SetLocalFieldInfo(fieldInfoList);
+            dev->SetTableInfo(tableInfo);
+        }
+        EXPECT_EQ(sqlite3_close_v2(db), SQLITE_OK);
+    }
 }
 
 class DistributedDBInterfacesRelationalTest : public testing::Test {
@@ -91,6 +116,10 @@ void DistributedDBInterfacesRelationalTest::SetUpTestCase(void)
     LOGD("Test dir is %s", g_testDir.c_str());
     g_dbDir = g_testDir + "/";
     DistributedDBToolsUnitTest::RemoveTestDbFiles(g_testDir);
+
+    g_communicatorAggregator = new (std::nothrow) VirtualCommunicatorAggregator();
+    ASSERT_TRUE(g_communicatorAggregator != nullptr);
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(g_communicatorAggregator);
 }
 
 void DistributedDBInterfacesRelationalTest::TearDownTestCase(void)
@@ -100,11 +129,31 @@ void DistributedDBInterfacesRelationalTest::TearDownTestCase(void)
 void DistributedDBInterfacesRelationalTest::SetUp(void)
 {
     DistributedDBToolsUnitTest::PrintTestCaseInfo();
+
+    g_deviceB = new (std::nothrow) RelationalVirtualDevice(DEVICE_B);
+    ASSERT_TRUE(g_deviceB != nullptr);
+    auto *syncInterfaceB = new (std::nothrow) VirtualRelationalVerSyncDBInterface();
+    ASSERT_TRUE(syncInterfaceB != nullptr);
+    ASSERT_EQ(g_deviceB->Initialize(g_communicatorAggregator, syncInterfaceB), E_OK);
+    auto permissionCheckCallback = [] (const std::string &userId, const std::string &appId, const std::string &storeId,
+        const std::string &deviceId, uint8_t flag) -> bool {
+        return true;
+    };
+    EXPECT_EQ(RuntimeConfig::SetPermissionCheckCallback(permissionCheckCallback), OK);
 }
 
 void DistributedDBInterfacesRelationalTest::TearDown(void)
 {
     DistributedDBToolsUnitTest::RemoveTestDbFiles(g_testDir);
+    if (g_deviceB != nullptr) {
+        delete g_deviceB;
+        g_deviceB = nullptr;
+    }
+    PermissionCheckCallbackV2 nullCallback;
+    EXPECT_EQ(RuntimeConfig::SetPermissionCheckCallback(nullCallback), OK);
+    if (g_communicatorAggregator != nullptr) {
+        g_communicatorAggregator->RegOnDispatch(nullptr);
+    }
 }
 
 /**
@@ -338,8 +387,17 @@ HWTEST_F(DistributedDBInterfacesRelationalTest, RelationalStoreTest005, TestSize
     EXPECT_EQ(delegate->CreateDistributedTable("t1"), NOT_SUPPORT);
 
     /**
-     * @tc.steps:step4. Close store
-     * @tc.expected: step4. Return OK.
+     * @tc.steps:step4. Create distributed table temp table or not exist table
+     * @tc.expected: step4. Create distributed table failed.
+     */
+    EXPECT_EQ(delegate->CreateDistributedTable("child"), NOT_FOUND);
+    std::string tempTableSql = "CREATE TEMP TABLE child(x, y, z)";
+    EXPECT_EQ(RelationalTestUtils::ExecSql(db, tempTableSql), SQLITE_OK);
+    EXPECT_EQ(delegate->CreateDistributedTable("child"), NOT_FOUND);
+
+    /**
+     * @tc.steps:step5. Close store
+     * @tc.expected: step5. Return OK.
      */
     status = g_mgr.CloseStore(delegate);
     EXPECT_EQ(status, OK);
@@ -691,6 +749,108 @@ HWTEST_F(DistributedDBInterfacesRelationalTest, RelationalRemoveDeviceDataTest00
     EXPECT_EQ(sqlite3_close_v2(db), SQLITE_OK);
 }
 
+namespace {
+struct TableT1 {
+    int a;
+    std::string b;
+    int rowid;
+    int flag;
+    int timestamp;
+
+    VirtualRowData operator() () const
+    {
+        VirtualRowData rowData;
+        DataValue dA;
+        dA = static_cast<int64_t>(a);
+        rowData.objectData.PutDataValue("a", dA);
+        DataValue dB;
+        dB.SetText(b);
+        rowData.objectData.PutDataValue("b", dB);
+        rowData.logInfo.dataKey = rowid;
+        rowData.logInfo.device = DEVICE_B;
+        rowData.logInfo.originDev = DEVICE_B;
+        rowData.logInfo.timestamp = timestamp;
+        rowData.logInfo.wTimestamp = timestamp;
+        rowData.logInfo.flag = flag;
+        Key key;
+        DBCommon::StringToVector(std::to_string(rowid), key);
+        std::vector<uint8_t> hashKey;
+        DBCommon::CalcValueHash(key, hashKey);
+        rowData.logInfo.hashKey = hashKey;
+        return rowData;
+    }
+};
+
+void AddDeviceSchema(RelationalVirtualDevice *device, sqlite3 *db, const std::string &name)
+{
+    TableInfo table;
+    SQLiteUtils::AnalysisSchema(db, name, table);
+    device->SetLocalFieldInfo(table.GetFieldInfos());
+    device->SetTableInfo(table);
+}
+}
+
+/**
+  * @tc.name: RelationalRemoveDeviceDataTest002
+  * @tc.desc: Test remove device data and syn
+  * @tc.type: FUNC
+  * @tc.require: AR000GK58F
+  * @tc.author: lianhuix
+  */
+HWTEST_F(DistributedDBInterfacesRelationalTest, RelationalRemoveDeviceDataTest002, TestSize.Level1)
+{
+    sqlite3 *db = RelationalTestUtils::CreateDataBase(g_dbDir + STORE_ID + DB_SUFFIX);
+    ASSERT_NE(db, nullptr);
+    EXPECT_EQ(RelationalTestUtils::ExecSql(db, "PRAGMA journal_mode=WAL;"), SQLITE_OK);
+    EXPECT_EQ(RelationalTestUtils::ExecSql(db, SIMPLE_CREATE_TABLE_SQL), SQLITE_OK);
+    AddDeviceSchema(g_deviceB, db, "t1");
+
+    RelationalStoreDelegate *delegate = nullptr;
+    DBStatus status = g_mgr.OpenStore(g_dbDir + STORE_ID + DB_SUFFIX, STORE_ID, {}, delegate);
+    EXPECT_EQ(status, OK);
+    ASSERT_NE(delegate, nullptr);
+
+    EXPECT_EQ(delegate->CreateDistributedTable("t1"), OK);
+
+    g_deviceB->PutDeviceData("t1", std::vector<TableT1>{
+        {1, "111", 1, 2, 1}, // test data
+        {2, "222", 2, 2, 2}, // test data
+        {3, "333", 3, 2, 3}, // test data
+        {4, "444", 4, 2, 4} // test data
+    });
+    std::vector<std::string> devices = {DEVICE_B};
+    Query query = Query::Select("t1").NotEqualTo("a", 0);
+    status = delegate->Sync(devices, SyncMode::SYNC_MODE_PULL_ONLY, query,
+        [&devices](const std::map<std::string, std::vector<TableStatus>> &devicesMap) {
+            EXPECT_EQ(devicesMap.size(), devices.size());
+            EXPECT_EQ(devicesMap.at(DEVICE_B)[0].status, OK);
+        }, true);
+    EXPECT_EQ(status, OK);
+
+    EXPECT_EQ(delegate->RemoveDeviceData(DEVICE_B), OK);
+
+    int logCnt = -1;
+    std::string checkLogSql = "SELECT count(*) FROM naturalbase_rdb_aux_t1_log WHERE device = '" + DEVICE_B + "'";
+    RelationalTestUtils::ExecSql(db, checkLogSql, nullptr, [&logCnt](sqlite3_stmt *stmt) {
+        logCnt = sqlite3_column_int(stmt, 0);
+        return E_OK;
+    });
+    EXPECT_EQ(logCnt, 0);
+
+    int dataCnt = -1;
+    std::string deviceTable = g_mgr.GetDistributedTableName(DEVICE_B, "t1");
+    std::string checkDataSql = "SELECT count(*) FROM " + deviceTable + " WHERE device = '" + DEVICE_B + "'";
+    RelationalTestUtils::ExecSql(db, checkDataSql, nullptr, [&dataCnt](sqlite3_stmt *stmt) {
+        dataCnt = sqlite3_column_int(stmt, 0);
+        return E_OK;
+    });
+    EXPECT_EQ(logCnt, 0);
+
+    status = g_mgr.CloseStore(delegate);
+    EXPECT_EQ(status, OK);
+    EXPECT_EQ(sqlite3_close_v2(db), SQLITE_OK);
+}
+
 /**
   * @tc.name: RelationalOpenStorePathCheckTest001
   * @tc.desc: Test open store with same label but different path.
@@ -814,3 +974,97 @@ HWTEST_F(DistributedDBInterfacesRelationalTest, RelationalOpenStorePressureTest0
     }
     openStoreThread.join();
 }
+
+namespace {
+void ProcessSync(RelationalStoreDelegate *delegate)
+{
+    std::vector<std::string> devices = {DEVICE_B};
+    Query query = Query::Select("create").EqualTo("create", 1);
+    DBStatus status = delegate->Sync(devices, SyncMode::SYNC_MODE_PUSH_ONLY, query,
+        [&devices](const std::map<std::string, std::vector<TableStatus>> &devicesMap) {
+            EXPECT_EQ(devicesMap.size(), devices.size());
+            EXPECT_EQ(devicesMap.at(DEVICE_B)[0].status, OK);
+        }, true);
+    EXPECT_EQ(status, OK);
+
+    std::vector<VirtualRowData> data;
+    g_deviceB->GetAllSyncData("create", data);
+    EXPECT_EQ(data.size(), 2u);
+
+    VirtualRowData virtualRowData;
+    DataValue d1;
+    d1 = static_cast<int64_t>(2); // 2: test data
+    virtualRowData.objectData.PutDataValue("create", d1);
+    DataValue d2;
+    d2.SetText("hello");
+    virtualRowData.objectData.PutDataValue("ddd", d2);
+    DataValue d3;
+    d3.SetText("hello");
+    virtualRowData.objectData.PutDataValue("eee", d3);
+    virtualRowData.logInfo.timestamp = 1;
+    g_deviceB->PutData("create", {virtualRowData});
+    status = delegate->Sync(devices, SyncMode::SYNC_MODE_PULL_ONLY, query,
+        [&devices](const std::map<std::string, std::vector<TableStatus>> &devicesMap) {
+            EXPECT_EQ(devicesMap.size(), devices.size());
+            EXPECT_EQ(devicesMap.at(DEVICE_B)[0].status, OK);
+        }, true);
+    EXPECT_EQ(status, OK);
+}
+}
+
+/**
+  * @tc.name: SqliteKeyWord001
+  * @tc.desc: Test relational table with sqlite key world.
+  * @tc.type: FUNC
+  * @tc.require:
+  * @tc.author: lianhuix
+  */
+HWTEST_F(DistributedDBInterfacesRelationalTest, SqliteKeyWordTest001, TestSize.Level1)
+{
+    sqlite3 *db = RelationalTestUtils::CreateDataBase(g_dbDir + STORE_ID + DB_SUFFIX);
+    ASSERT_NE(db, nullptr);
+    EXPECT_EQ(RelationalTestUtils::ExecSql(db, "PRAGMA journal_mode=WAL;"), SQLITE_OK);
+
+    std::string tableSql = "CREATE TABLE IF NOT EXISTS 'create' ('create' INTEGER PRIMARY KEY, b 'CREATE', " \
+        "c TEXT DEFAULT 'DEFAULT', UNIQUE(b, c))";
+    EXPECT_EQ(RelationalTestUtils::ExecSql(db, tableSql), SQLITE_OK);
+    std::string indexSql = "CREATE INDEX IF NOT EXISTS 'index' on 'create' (b)";
+    EXPECT_EQ(RelationalTestUtils::ExecSql(db, indexSql), SQLITE_OK);
+
+    PrepareVirtualDeviceEnv("create", g_dbDir + STORE_ID + DB_SUFFIX, {g_deviceB});
+
+    DBStatus status = OK;
+    RelationalStoreDelegate *delegate = nullptr;
+    status = g_mgr.OpenStore(g_dbDir + STORE_ID + DB_SUFFIX, STORE_ID, {}, delegate);
+    EXPECT_EQ(status, OK);
+    ASSERT_NE(delegate, nullptr);
+
+    status = delegate->CreateDistributedTable("create");
+    EXPECT_EQ(status, OK);
+
+    EXPECT_EQ(RelationalTestUtils::ExecSql(db, "INSERT INTO 'create' values(1, 'bbb', 'ccc')"), SQLITE_OK);
+
+    std::string insertSql = "INSERT INTO 'create' values(1001, 'create', 'text')";
+    EXPECT_EQ(RelationalTestUtils::ExecSql(db, insertSql), SQLITE_OK);
+
+    std::string updateSql = "UPDATE 'create' SET 'create' = 1002 WHERE b = 'create'";
+    EXPECT_EQ(RelationalTestUtils::ExecSql(db, updateSql), SQLITE_OK);
+
+    std::string deleteSql = "DELETE FROM 'create' WHERE 'create' = 1002";
+    EXPECT_EQ(RelationalTestUtils::ExecSql(db, deleteSql), SQLITE_OK);
+
+    ProcessSync(delegate);
+
+    std::string alterSql = "ALTER TABLE 'create' ADD COLUMN 'table' 'insert' DEFAULT NULL";
+    EXPECT_EQ(RelationalTestUtils::ExecSql(db, alterSql), SQLITE_OK);
+    status = delegate->CreateDistributedTable("create");
+    EXPECT_EQ(status, OK);
+
+    status = delegate->RemoveDeviceData("DEVICES_B", "create");
+    EXPECT_EQ(status, OK);
+
+    status = g_mgr.CloseStore(delegate);
+    EXPECT_EQ(status, OK);
+    delegate = nullptr;
+    EXPECT_EQ(sqlite3_close_v2(db), SQLITE_OK);
+}
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_schema_database_upgrade_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_schema_database_upgrade_test.cpp
index c0dd063026e1c17546fe5d6fef2abe2f6c4ba9e4..9587a2c46f6ab921b5447d8bc032f170378bf413 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_schema_database_upgrade_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_schema_database_upgrade_test.cpp
@@ -96,7 +96,7 @@ namespace {
         }
         return oriSchemaStr;
     }
-    bool SchemaChecker(const std::string schema)
+    bool SchemaChecker(const std::string &schema)
     {
         SchemaObject schemaObj;
         return (schemaObj.ParseFromSchemaString(schema) == E_OK);
diff --git a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_file_package_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_file_package_test.cpp
index 2947a03ae92d9c56dd6231548f3eaa60ba57df92..807014182d91aab63e95a9e5f6da747fcb30cacf 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_file_package_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_file_package_test.cpp
@@ -50,9 +50,8 @@ namespace {
         list<OS::FileAttr> files;
         int errCode = OS::GetFileAttrFromPath(path, files);
         ASSERT_EQ(errCode, E_OK);
-        string fileName;
         for (auto file : files) {
-            fileName = path + "/" + file.fileName;
+            string fileName = path + "/" + file.fileName;
             switch (file.fileType) {
                 case OS::FILE:
                     (void)remove(fileName.c_str());
diff --git a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_encrypted_db_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_encrypted_db_test.cpp
index 8ce1573800271b010b53e08598d525b8eed5edf5..f1321ccd2bd9cf116515418f031827820349907b 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_encrypted_db_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_encrypted_db_test.cpp
@@ -116,9 +116,9 @@ void DistributedDBRelationalEncryptedDbTest::SetUpTestCase(void)
     ASSERT_TRUE(communicator != nullptr);
     RuntimeContext::GetInstance()->SetCommunicatorAggregator(communicator);
 
-    g_correctPasswd.SetValue((const uint8_t *)(CORRECT_KEY.data()), CORRECT_KEY.size());
-    g_rekeyPasswd.SetValue((const uint8_t *)(REKEY_KEY.data()), REKEY_KEY.size());
-    g_incorrectPasswd.SetValue((const uint8_t *)(INCORRECT_KEY.data()), INCORRECT_KEY.size());
+    g_correctPasswd.SetValue(reinterpret_cast<const uint8_t *>(CORRECT_KEY.data()), CORRECT_KEY.size());
+    g_rekeyPasswd.SetValue(reinterpret_cast<const uint8_t *>(REKEY_KEY.data()), REKEY_KEY.size());
+    g_incorrectPasswd.SetValue(reinterpret_cast<const uint8_t *>(INCORRECT_KEY.data()), INCORRECT_KEY.size());
 }
 
 void DistributedDBRelationalEncryptedDbTest::TearDownTestCase(void)
diff --git a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_get_data_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_get_data_test.cpp
index 24536471b45f33353db16d3506b3eaf612f105b4..dbc1f719d92d45c3e200f665ce62fb4d8f915451 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_get_data_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_get_data_test.cpp
@@ -31,6 +31,7 @@
 #include "relational_store_manager.h"
 #include "relational_store_sqlite_ext.h"
 #include "relational_sync_able_storage.h"
+#include "runtime_config.h"
 #include "sqlite_relational_store.h"
 #include "sqlite_utils.h"
 #include "virtual_communicator_aggregator.h"
@@ -87,7 +88,6 @@ int AddOrUpdateRecord(int64_t key, int64_t value)
 
 int GetLogData(int key, uint64_t &flag, Timestamp &timestamp, const DeviceID &device = "")
 {
-    string tableName = g_tableName;
     if (!device.empty()) {
     }
     const string sql = "SELECT timestamp, flag \
@@ -744,8 +744,8 @@ HWTEST_F(DistributedDBRelationalGetDataTest, UpdateData1, TestSize.Level1)
         "INSERT INTO " + tableName + " VALUES(NULL, x'0123456789');",
     };
     const size_t RECORD_COUNT = sqls.size();
-    for (const auto &sql : sqls) {
-        ASSERT_EQ(sqlite3_exec(db, sql.c_str(), nullptr, nullptr, nullptr), SQLITE_OK);
+    for (const auto &item : sqls) {
+        ASSERT_EQ(sqlite3_exec(db, item.c_str(), nullptr, nullptr, nullptr), SQLITE_OK);
     }
 
     /**
@@ -1195,10 +1195,10 @@ HWTEST_F(DistributedDBRelationalGetDataTest, CompatibleData2, TestSize.Level1)
      * @tc.steps: step3. Check deviceA's distributed table.
      * @tc.expected: The create sql is correct.
      */
-    std::string expectSql = "CREATE TABLE naturalbase_rdb_aux_data_"
-        "265a9c8c3c690cdfdac72acfe7a50f748811802635d987bb7d69dc602ed3794f(key integer NOT NULL,"
-        "value integer, integer_type integer NOT NULL DEFAULT 123, text_type text NOT NULL DEFAULT 'high_version', "
-        "real_type real NOT NULL DEFAULT 123.123456, blob_type blob NOT NULL DEFAULT 123, PRIMARY KEY (key))";
+    std::string expectSql = "CREATE TABLE 'naturalbase_rdb_aux_data_"
+        "265a9c8c3c690cdfdac72acfe7a50f748811802635d987bb7d69dc602ed3794f' ('key' 'integer' NOT NULL,'value' 'integer',"
+        " 'integer_type' 'integer' NOT NULL DEFAULT 123, 'text_type' 'text' NOT NULL DEFAULT 'high_version', "
+        "'real_type' 'real' NOT NULL DEFAULT 123.123456, 'blob_type' 'blob' NOT NULL DEFAULT 123, PRIMARY KEY ('key'))";
     sql = "SELECT sql FROM sqlite_master WHERE tbl_name='" + DBConstant::RELATIONAL_PREFIX + g_tableName + "_" +
         DBCommon::TransferStringToHex(DBCommon::TransferHashString(deviceID)) + "';";
     EXPECT_EQ(GetOneText(db, sql), expectSql);
@@ -1534,4 +1534,93 @@ HWTEST_F(DistributedDBRelationalGetDataTest, GetAfterDropTable1, TestSize.Level1
     ExpectCount(db, getLogSql, 3u);  // 3 means all deleted data.
     sqlite3_close(db);
 }
+
+/**
+ * @tc.name: CloseStore001
+ * @tc.desc: Test Relational Store Close Action.
+ * @tc.type: FUNC
+ * @tc.require: AR000H2QPN
+ * @tc.author: zhangqiquan
+ */
+HWTEST_F(DistributedDBRelationalGetDataTest, CloseStore001, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. new store and get connection now ref count is 2.
+     * @tc.expected: Succeed.
+     */
+    auto store = new (std::nothrow) SQLiteRelationalStore();
+    ASSERT_NE(store, nullptr);
+    RelationalDBProperties properties;
+    InitStoreProp(g_storePath, APP_ID, USER_ID, properties);
+    EXPECT_EQ(store->Open(properties), E_OK);
+    int errCode = E_OK;
+    auto connection = store->GetDBConnection(errCode);
+    EXPECT_EQ(errCode, E_OK);
+    ASSERT_NE(connection, nullptr);
+    errCode = store->RegisterLifeCycleCallback([](const std::string &, const std::string &) {
+    });
+    EXPECT_EQ(errCode, E_OK);
+    errCode = store->RegisterLifeCycleCallback(nullptr);
+    EXPECT_EQ(errCode, E_OK);
+    auto syncInterface = store->GetStorageEngine();
+    ASSERT_NE(syncInterface, nullptr);
+    RefObject::IncObjRef(syncInterface);
+    /**
+     * @tc.steps: step2. release store.
+     * @tc.expected: Succeed.
+     */
+    store->ReleaseDBConnection(connection);
+    RefObject::DecObjRef(store);
+    store = nullptr;
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+
+    /**
+     * @tc.steps: step3. try trigger heart beat after store release.
+     * @tc.expected: No crash.
+     */
+    Timestamp maxTimestamp = 0u;
+    syncInterface->GetMaxTimestamp(maxTimestamp);
+    RefObject::DecObjRef(syncInterface);
+}
+
+/**
+ * @tc.name: StopSync001
+ * @tc.desc: Test Relational Stop Sync Action.
+ * @tc.type: FUNC
+ * @tc.require: AR000H2QPN
+ * @tc.author: zhangqiquan
+ */
+HWTEST_F(DistributedDBRelationalGetDataTest, StopSync001, TestSize.Level1)
+{
+    RelationalDBProperties properties;
+    InitStoreProp(g_storePath, APP_ID, USER_ID, properties);
+    properties.SetBoolProp(DBProperties::SYNC_DUAL_TUPLE_MODE, true);
+    const int loopCount = 1000;
+    std::thread userChangeThread([]() {
+        for (int i = 0; i < loopCount; ++i) {
+            RuntimeConfig::NotifyUserChanged();
+            std::this_thread::sleep_for(std::chrono::milliseconds(1));
+        }
+    });
+    std::string hashIdentifier = properties.GetStringProp(RelationalDBProperties::IDENTIFIER_DATA, "");
+    properties.SetStringProp(DBProperties::DUAL_TUPLE_IDENTIFIER_DATA, hashIdentifier);
+    OpenDbProperties option;
+    option.uri = properties.GetStringProp(DBProperties::DATA_DIR, "");
+    option.createIfNecessary = true;
+    for (int i = 0; i < loopCount; ++i) {
+        auto sqliteStorageEngine = std::make_shared<SQLiteSingleRelationalStorageEngine>(properties);
+        ASSERT_NE(sqliteStorageEngine, nullptr);
+        StorageEngineAttr poolSize = {1, 1, 0, 16}; // at most 1 write 16 read.
+        int errCode = sqliteStorageEngine->InitSQLiteStorageEngine(poolSize, option, hashIdentifier);
+        EXPECT_EQ(errCode, E_OK);
+        auto storageEngine = new (std::nothrow) RelationalSyncAbleStorage(sqliteStorageEngine);
+        ASSERT_NE(storageEngine, nullptr);
+        auto syncAbleEngine = std::make_unique<SyncAbleEngine>(storageEngine);
+        ASSERT_NE(syncAbleEngine, nullptr);
+        syncAbleEngine->WakeUpSyncer();
+        syncAbleEngine->Close();
+        RefObject::KillAndDecObjRef(storageEngine);
+    }
+    userChangeThread.join();
+}
 #endif
diff --git a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_remote_query_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_remote_query_test.cpp
index 0dd763af20faabc163f8f912c324761d159b9ee9..bbfdc2c8de33cf47f575759db8301fb8596f11e7 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_remote_query_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_remote_query_test.cpp
@@ -204,6 +204,25 @@ HWTEST_F(DistributedDBRelationalRemoteQueryTest, NormalQuery1, TestSize.Level1)
     RefObject::DecObjRef(g_store);
 }
 
+/**
+ * @tc.name: NormalQuery1
+ * @tc.desc: test sql len is larger than 100,0000
+ * @tc.type: FUNC
+ * @tc.require: AR000GK58G
+ * @tc.author: zhuwentao
+ */
+HWTEST_F(DistributedDBRelationalRemoteQueryTest, NormalQuery2, TestSize.Level1)
+{
+    ASSERT_EQ(g_mgr.OpenStore(g_storePath, g_storeID, RelationalStoreDelegate::Option {}, g_delegate), DBStatus::OK);
+    ASSERT_NE(g_delegate, nullptr);
+    ASSERT_EQ(g_delegate->CreateDistributedTable(g_tableName), DBStatus::OK);
+    std::string device = "deviceB";
+    RemoteCondition sqlCondition;
+    sqlCondition.sql.resize(1000001, 'a');
+    std::shared_ptr<ResultSet> result = nullptr;
+    EXPECT_EQ(g_delegate->RemoteQuery(device, sqlCondition, 5000, result), OVER_MAX_LIMITS);
+}
+
 /**
  * @tc.name: BoolQuery1
  * @tc.desc: Query bool.
diff --git a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_syncable_storage_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_syncable_storage_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f6ebd0ae3cc90a2d0192d5cc72f787e3772ec2ab
--- /dev/null
+++ b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_syncable_storage_test.cpp
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifdef RELATIONAL_STORE
+#include <gtest/gtest.h>
+
+#include "distributeddb_tools_unit_test.h"
+#include "relational_sync_able_storage.h"
+#include "sqlite_single_relational_storage_engine.h"
+#include "sqlite_utils.h"
+
+using namespace testing::ext;
+using namespace DistributedDB;
+using namespace DistributedDBUnitTest;
+using namespace std;
+
+namespace {
+constexpr const char* DB_SUFFIX = ".db";
+constexpr const char* STORE_ID = "Relational_Store_ID";
+std::string g_testDir;
+std::string g_dbDir;
+
+const std::string NORMAL_CREATE_TABLE_SQL = "CREATE TABLE IF NOT EXISTS sync_data(" \
+    "key         BLOB NOT NULL UNIQUE," \
+    "value       BLOB," \
+    "timestamp   INT  NOT NULL," \
+    "flag        INT  NOT NULL," \
+    "device      BLOB," \
+    "ori_device  BLOB," \
+    "hash_key    BLOB PRIMARY KEY NOT NULL," \
+    "w_timestamp INT," \
+    "UNIQUE(device, ori_device));" \
+    "CREATE INDEX key_index ON sync_data (key, flag);";
+}
+
+class DistributedDBRelationalSyncableStorageTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+};
+
+
+void DistributedDBRelationalSyncableStorageTest::SetUpTestCase(void)
+{}
+
+void DistributedDBRelationalSyncableStorageTest::TearDownTestCase(void)
+{}
+
+void DistributedDBRelationalSyncableStorageTest::SetUp(void)
+{
+    DistributedDBToolsUnitTest::PrintTestCaseInfo();
+    DistributedDBToolsUnitTest::TestDirInit(g_testDir);
+    LOGD("Test dir is %s", g_testDir.c_str());
+    g_dbDir = g_testDir + "/";
+}
+
+void DistributedDBRelationalSyncableStorageTest::TearDown(void)
+{
+    DistributedDBToolsUnitTest::RemoveTestDbFiles(g_testDir);
+}
+
+/**
+ * @tc.name: SchemaRefTest001
+ * @tc.desc: Test sync interface get schema
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: xulianhui
+  */
+HWTEST_F(DistributedDBRelationalSyncableStorageTest, SchemaRefTest001, TestSize.Level1)
+{
+    sqlite3 *db = RelationalTestUtils::CreateDataBase(g_dbDir + STORE_ID + DB_SUFFIX);
+    ASSERT_NE(db, nullptr);
+    EXPECT_EQ(RelationalTestUtils::ExecSql(db, "PRAGMA journal_mode=WAL;"), SQLITE_OK);
+
+    RelationalDBProperties properties;
+    auto sqliteStorageEngine = std::make_shared<SQLiteSingleRelationalStorageEngine>(properties);
+    RelationalSyncAbleStorage *syncAbleStorage = new RelationalSyncAbleStorage(sqliteStorageEngine);
+
+    static std::atomic<bool> isFinish(false);
+    int getCount = 0;
+    std::thread th([syncAbleStorage, &getCount]() {
+        while (!isFinish.load()) {
+            RelationalSchemaObject schema = syncAbleStorage->GetSchemaInfo();
+            (void)schema.ToSchemaString();
+            getCount++;
+        }
+    });
+
+    RelationalSchemaObject schema;
+    EXPECT_EQ(RelationalTestUtils::ExecSql(db, NORMAL_CREATE_TABLE_SQL), SQLITE_OK);
+    TableInfo table;
+    SQLiteUtils::AnalysisSchema(db, "sync_data", table);
+    schema.AddRelationalTable(table);
+
+    int setCount = 0;
+    for (; setCount < 1000; setCount++) { // 1000: run times
+        RelationalSchemaObject tmpSchema = schema;
+        sqliteStorageEngine->SetSchema(tmpSchema);
+    }
+
+    isFinish.store(true);
+    th.join();
+
+    LOGD("run round set: %d, get: %d", getCount, setCount);
+
+    RefObject::DecObjRef(syncAbleStorage);
+    EXPECT_EQ(sqlite3_close_v2(db), SQLITE_OK);
+}
+#endif // RELATIONAL_STORE
diff --git a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_commit_storage_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_commit_storage_test.cpp
index 615b8eb5dd547a714bf922f517788a4666c6faa9..ca62af7ad5b05ecbcabcbe74dc54d0378246ed4c 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_commit_storage_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_commit_storage_test.cpp
@@ -786,7 +786,6 @@ HWTEST_F(DistributedDBStorageCommitStorageTest, MultiVerCommitStorage016, TestSi
     TestLatestCommitOfDevice(latestCommits, g_remoteDeviceC, commitInfoC);
     for (auto latestCommit : latestCommits) {
         g_commitStorage->ReleaseCommit(latestCommit.second);
-        latestCommit.second = nullptr;
     }
 }
 
diff --git a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_data_operation_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_data_operation_test.cpp
index e6c4363754ca4978886427bcfd59dbcae198e29d..4f9fd946f13464f44c1d40aac7e9e2e9fa43d3a5 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_data_operation_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_data_operation_test.cpp
@@ -782,4 +782,38 @@ HWTEST_F(DistributedDBStorageDataOperationTest, ShaAlgoEncryptTest003, TestSize.
      * * @tc.expected: step4. interface return ok
     */
     sqlite3_close_v2(db);
+}
+
+/**
+  * @tc.name: ShaAlgoEncryptTest003
+  * @tc.desc: Test unnormal sql
+  * @tc.type: FUNC
+  * @tc.require: AR000HI2JS
+  * @tc.author: zhuwentao
+  */
+HWTEST_F(DistributedDBStorageDataOperationTest, ShaAlgoEncryptTest004, TestSize.Level1)
+{
+    sqlite3 *db = nullptr;
+    std::string fileUrl = g_testDir + "/ShaAlgoEncryptTest004.db";
+    std::string attachName = "EncryptTest004";
+    SQLiteUtils::AttachNewDatabase(db, CipherType::AES_256_GCM, g_passwd, fileUrl, attachName);
+    EXPECT_NE(SQLiteUtils::SetKeyInner(db, static_cast<CipherType>(3), g_passwd, DBConstant::DEFAULT_ITER_TIMES), E_OK);
+    uint64_t flag = SQLITE_OPEN_URI | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
+    EXPECT_EQ(sqlite3_open_v2(fileUrl.c_str(), &db, flag, nullptr), SQLITE_OK);
+    EXPECT_NE(SQLiteUtils::SetKey(db, static_cast<CipherType>(3), g_passwd, DBConstant::DEFAULT_ITER_TIMES), E_OK);
+    EXPECT_NE(SQLiteUtils::SetKeyInner(db, static_cast<CipherType>(3), g_passwd, DBConstant::DEFAULT_ITER_TIMES), E_OK);
+    EXPECT_EQ(SQLiteUtils::SetKey(db, CipherType::AES_256_GCM, g_passwd, DBConstant::DEFAULT_ITER_TIMES), E_OK);
+    EXPECT_EQ(SQLiteUtils::ExecuteRawSQL(db, SHA1_ALGO_SQL), E_OK);
+    ASSERT_TRUE(SQLiteUtils::ExecuteRawSQL(db, SET_USER_VERSION_SQL) == E_OK);
+    EXPECT_EQ(SQLiteUtils::ExecuteRawSQL(db, USER_VERSION_SQL), E_OK);
+    sqlite3_close_v2(db);
+    db = nullptr;
+
+    std::string fileUrl2 = g_testDir + "/ShaAlgoEncryptTest004_attach.db";
+    EXPECT_EQ(sqlite3_open_v2(fileUrl2.c_str(), &db, flag, nullptr), SQLITE_OK);
+    EXPECT_EQ(SQLiteUtils::SetKeyInner(db, CipherType::AES_256_GCM, g_passwd2, DBConstant::DEFAULT_ITER_TIMES), E_OK);
+    EXPECT_EQ(SQLiteUtils::ExecuteRawSQL(db, SHA256_ALGO_SQL), E_OK);
+    EXPECT_NE(SQLiteUtils::AttachNewDatabase(db, CipherType::AES_256_GCM, g_passwd2, fileUrl, attachName), E_OK);
+    sqlite3_close_v2(db);
+    db = nullptr;
 }
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_encrypt_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_encrypt_test.cpp
index e1733785e1515f0fd1ef499f6cdf1cfb75796a17..1fbb9181de95d0f68f3643ab23a177f031082938 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_encrypt_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_encrypt_test.cpp
@@ -102,25 +102,23 @@ namespace {
     {
         char *zErrMsg = nullptr;
         int errCode = sqlite3_key(g_db, static_cast<const void *>(passwd), strlen(passwd));
-        if (errCode != SQLITE_OK && zErrMsg != nullptr) {
-            LOGE(" [SQLITE]: %s", zErrMsg);
-            sqlite3_free(zErrMsg);
+        if (errCode != SQLITE_OK) {
             return errCode;
         }
 
-        errCode = sqlite3_exec(g_db, (PRAGMA_KDF_ITER + to_string(iterNumber)).c_str(), nullptr, nullptr,
-                               &zErrMsg);
-        if (errCode != SQLITE_OK && zErrMsg != nullptr) {
-            LOGE(" [SQLITE]: %s", zErrMsg);
-            sqlite3_free(zErrMsg);
+        errCode = sqlite3_exec(g_db, (PRAGMA_KDF_ITER + to_string(iterNumber)).c_str(), nullptr, nullptr, &zErrMsg);
+        if (errCode != SQLITE_OK) {
+            if (zErrMsg != nullptr) {
+                sqlite3_free(zErrMsg);
+            }
             return errCode;
         }
 
-        errCode = sqlite3_exec(g_db, (PRAGMA_CIPHER + algName + ";").c_str(), nullptr, nullptr,
-                               &zErrMsg);
-        if (errCode != SQLITE_OK && zErrMsg != nullptr) {
-            LOGE(" [SQLITE]: %s", zErrMsg);
-            sqlite3_free(zErrMsg);
+        errCode = sqlite3_exec(g_db, (PRAGMA_CIPHER + algName + ";").c_str(), nullptr, nullptr, &zErrMsg);
+        if (errCode != SQLITE_OK) {
+            if (zErrMsg != nullptr) {
+                sqlite3_free(zErrMsg);
+            }
             return errCode;
         }
 
@@ -348,9 +346,7 @@ void DistributedDBStorageEncryptTest::TearDown(void)
     /**
       * @tc.make sure g_db is nullptr and is closed.
       */
-    if (g_db != nullptr) {
-        g_db = nullptr;
-    }
+    g_db = nullptr;
     /**
       * @tc.Clean DB files created from every test case.
       */
diff --git a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_query_sync_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_query_sync_test.cpp
index c8791c199cbcc59a5f9dee27afd21ee762bd5200..86c802eba2337b32c1bd9bfa43cb7efa3d5ecd31 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_query_sync_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_query_sync_test.cpp
@@ -544,16 +544,13 @@ HWTEST_F(DistributedDBStorageQuerySyncTest, GetQuerySyncData010, TestSize.Level1
      * @tc.steps: step1. Put 100 entries from k100 to k1.
      * @tc.expected: step1. Put data successfully.
      */
-    Key key;
-    Value value;
-    string str;
     IOption option{ IOption::SYNC_DATA };
     const uint64_t totalSize = 100; // 100 data in DB.
     for (unsigned i = totalSize; i > 0; i--) {
-        str = "k" + to_string(i);
-        key = Key(str.begin(), str.end());
+        string str = "k" + to_string(i);
+        Key key = Key(str.begin(), str.end());
         str[0] = 'v';
-        value = Value(str.begin(), str.end());
+        Value value = Value(str.begin(), str.end());
         EXPECT_EQ(g_connection->Put(option, key, value), E_OK);
     }
 
diff --git a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_single_ver_natural_store_testcase.cpp b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_single_ver_natural_store_testcase.cpp
index 4ca1b1b460ce8e47de591ceba6cd5d8b68ebe348..c5233f048ab8b2387af1b0e00735a2ac94cf0102 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_single_ver_natural_store_testcase.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_single_ver_natural_store_testcase.cpp
@@ -1483,35 +1483,6 @@ void DistributedDBStorageSingleVerNaturalStoreTestCase::DeleteUserKeyValue006(SQ
     EXPECT_EQ(numSelect, 1);
 }
 
-// private Begin
-void DistributedDBStorageSingleVerNaturalStoreTestCase::CreateMemDb(SQLiteSingleVerNaturalStoreConnection *&connection,
-    int &errCode)
-{
-    // pre-Set close other db
-    if (connection != nullptr) {
-        connection->Close();
-        connection = nullptr;
-    }
-
-    KvDBProperties property;
-    property.SetStringProp(KvDBProperties::STORE_ID, "TestGeneralNB");
-    property.SetStringProp(KvDBProperties::IDENTIFIER_DIR, "TestGeneralNB");
-    property.SetBoolProp(KvDBProperties::MEMORY_MODE, true);
-
-    SQLiteSingleVerNaturalStore *memoryStore = nullptr;
-    memoryStore = new (std::nothrow) SQLiteSingleVerNaturalStore;
-    ASSERT_NE(memoryStore, nullptr);
-
-    errCode = memoryStore->Open(property);
-    if (errCode != E_OK) {
-        return;
-    }
-
-    connection = static_cast<SQLiteSingleVerNaturalStoreConnection *>(memoryStore->GetDBConnection(errCode));
-    ASSERT_NE(connection, nullptr);
-    memoryStore->DecObjRef(memoryStore);
-}
-
 // param [in] dbName:Database name,strSql: The sql statement executed,[out],vecSyncData:SYNC_DATA table data
 // Real query sync-DATA table data via sqlite. return query data row number
 int DistributedDBStorageSingleVerNaturalStoreTestCase::GetRawSyncData(const std::string &dbName,
diff --git a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_single_ver_natural_store_testcase.h b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_single_ver_natural_store_testcase.h
index 148fd14dc2d647ac2916b456421f5ab66ce6a5aa..72c514e56258a65c25bdd683b405616f9ff5d1b7 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_single_ver_natural_store_testcase.h
+++ b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_single_ver_natural_store_testcase.h
@@ -111,36 +111,34 @@ public:
         DistributedDB::SQLiteSingleVerNaturalStoreConnection *&connection);
 
     static void DeleteUserKeyValue001(DistributedDB::SQLiteSingleVerNaturalStore *&store,
-        DistributedDB::SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &dbName);
+        DistributedDB::SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url);
 
     static void MemoryDbDeleteUserKeyValue001(DistributedDB::SQLiteSingleVerNaturalStore *&store,
-        DistributedDB::SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &dbName);
+        DistributedDB::SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url);
 
     static void DeleteUserKeyValue002(DistributedDB::SQLiteSingleVerNaturalStore *&store,
-        DistributedDB::SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &dbName);
+        DistributedDB::SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url);
 
     static void DeleteUserKeyValue003(DistributedDB::SQLiteSingleVerNaturalStore *&store,
-        DistributedDB::SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &dbName);
+        DistributedDB::SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url);
 
     static void DeleteUserKeyValue004(DistributedDB::SQLiteSingleVerNaturalStore *&store,
-        DistributedDB::SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &dbName);
+        DistributedDB::SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url);
 
     static void MemoryDbDeleteUserKeyValue004(DistributedDB::SQLiteSingleVerNaturalStore *&store,
-        DistributedDB::SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &dbName);
+        DistributedDB::SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url);
 
     static void DeleteUserKeyValue005(DistributedDB::SQLiteSingleVerNaturalStore *&store,
-        DistributedDB::SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &dbName);
+        DistributedDB::SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url);
 
     static void MemoryDbDeleteUserKeyValue005(DistributedDB::SQLiteSingleVerNaturalStore *&store,
-        DistributedDB::SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &dbName);
+        DistributedDB::SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url);
 
     static void DeleteUserKeyValue006(DistributedDB::SQLiteSingleVerNaturalStore *&store,
-        DistributedDB::SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &dbName);
+        DistributedDB::SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url);
     static int GetRawSyncData(const std::string &dbName, const std::string &strSql, std::vector<SyncData> &vecSyncData);
 
 private:
-    static void CreateMemDb(DistributedDB::SQLiteSingleVerNaturalStoreConnection *&connection, int &errCode);
-
     static bool IsSqlinteExistKey(const std::vector<SyncData> &vecSyncData, const std::vector<uint8_t> &key);
 
     static void TestMetaDataPutAndGet(DistributedDB::SQLiteSingleVerNaturalStore *&store,
diff --git a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_subscribe_query_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_subscribe_query_test.cpp
index 7d7fc916285e55aba0ee2e19f6fe2fd033e72046..0493de259e1659a5f1c121bc3f51b9ce467ffdff 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_subscribe_query_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_subscribe_query_test.cpp
@@ -671,4 +671,128 @@ HWTEST_F(DistributedDBStorageSubscribeQueryTest, AddSubscribeTest002, TestSize.L
      */
     RefObject::KillAndDecObjRef(store);
     KvDBManager::ReleaseDatabaseConnection(conn);
+}
+
+namespace {
+void PutSyncData(SQLiteSingleVerNaturalStore *store, const Key &key, const std::string &valStr)
+{
+    Value value(valStr.begin(), valStr.end());
+    std::vector<DataItem> data;
+    Timestamp now = store->GetCurrentTimestamp();
+    DataItem item{key, value, now, DataItem::LOCAL_FLAG, REMOTE_DEVICE_A, now};
+    data.push_back(item);
+    EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, data, REMOTE_DEVICE_ID), E_OK);
+}
+}
+
+/**
+  * @tc.name: GetSyncDataTransTest001
+  * @tc.desc: Get sync data with put
+  * @tc.type: FUNC
+  * @tc.require:
+  * @tc.author: xulianhui
+  */
+HWTEST_F(DistributedDBStorageSubscribeQueryTest, GetSyncDataTransTest001, TestSize.Level3)
+{
+    /**
+     * @tc.steps:step1. Create a json schema db, get the natural store instance.
+     * @tc.expected: Get results OK and non-null store.
+     */
+    SQLiteSingleVerNaturalStoreConnection *conn = nullptr;
+    SQLiteSingleVerNaturalStore *store = nullptr;
+    CreateAndGetStore("SubscribeTest02", SCHEMA_STRING, conn, store);
+
+    /**
+     * @tc.steps:step2. Put data when sync
+     * @tc.expected: step2. Get sync data correct
+     */
+    std::string data1(R""({"field_name1":false,"field_name2":true,"field_name3":100})"");
+    PutSyncData(store, KEY1, data1);
+
+    std::thread th([store]() {
+        std::string data2(R""({"field_name1":false,"field_name2":true,"field_name3":101})"");
+        PutSyncData(store, KEY2, data2);
+    });
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(5)); // wait for 5 ms
+    Query query = Query::Select().EqualTo("field_name1", false);
+    QueryObject queryObj(query);
+    DataSizeSpecInfo  specInfo = {4 * 1024 * 1024, DBConstant::MAX_HPMODE_PACK_ITEM_SIZE};
+    std::vector<SingleVerKvEntry *> entries;
+    ContinueToken token = nullptr;
+    EXPECT_EQ(store->GetSyncData(queryObj, SyncTimeRange{}, specInfo, token, entries), E_OK);
+
+    th.join();
+
+    if (entries.size() == 1U) {
+        EXPECT_EQ(entries[0]->GetKey(), KEY1);
+    } else if (entries.size() == 2U) {
+        EXPECT_EQ(entries[0]->GetKey(), KEY1);
+        EXPECT_EQ(entries[0]->GetFlag(), 0U);
+        EXPECT_EQ(entries[1]->GetKey(), KEY2);
+        EXPECT_EQ(entries[1]->GetFlag(), 0U);
+    }
+
+    /**
+     * @tc.steps:step3. Close natural store
+     * @tc.expected: step3. Close ok
+     */
+    RefObject::KillAndDecObjRef(store);
+    KvDBManager::ReleaseDatabaseConnection(conn);
+}
+
+/**
+  * @tc.name: AddSubscribeTest003
+  * @tc.desc: Test put sync data with subscribe trigger
+  * @tc.type: FUNC
+  * @tc.require:
+  * @tc.author: lianhuix
+  */
+HWTEST_F(DistributedDBStorageSubscribeQueryTest, AddSubscribeTest003, TestSize.Level1)
+{
+    /**
+     * @tc.steps:step1. Create a json schema db, get the natural store instance.
+     * @tc.expected: Get results OK and non-null store.
+     */
+    SQLiteSingleVerNaturalStoreConnection *conn = nullptr;
+    SQLiteSingleVerNaturalStore *store = nullptr;
+    CreateAndGetStore("AddSubscribeErrTest002", SCHEMA_STRING, conn, store);
+
+    /**
+     * @tc.steps:step2. Add subscribe with query
+     * @tc.expected: step2. add success
+     */
+    Query query = Query::Select().EqualTo("field_name2", false);
+    QueryObject queryObj(query);
+    int errCode = store->AddSubscribe(SUBSCRIBE_ID, queryObj, false);
+    EXPECT_EQ(errCode, E_OK);
+
+    /**
+     * @tc.steps:step3. Reput same data with delete flag
+     * @tc.expected: step3. put data success
+     */
+    Key key ;
+    Value value;
+    std::string validJsonData(R"({"field_name1":false,"field_name2":false,"field_name3":100})");
+    DBCommon::StringToVector(validJsonData, value);
+    Timestamp now = store->GetCurrentTimestamp();
+    std::vector<DataItem> data;
+    data.push_back({{'K', '0'}, value, now, 0, REMOTE_DEVICE_ID, now});
+    EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, data, REMOTE_DEVICE_ID, queryObj), E_OK);
+
+    data.clear();
+    Key hashKey;
+    DBCommon::CalcValueHash({'K', '0'}, hashKey);
+    data.push_back({hashKey, {}, now + 1, 1, REMOTE_DEVICE_ID, now + 1});
+    EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, data, REMOTE_DEVICE_ID, queryObj), E_OK);
+
+    // repeat put with delete flag
+    EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, data, REMOTE_DEVICE_ID, queryObj), E_OK);
+
+    /**
+     * @tc.steps:step4. Close natural store
+     * @tc.expected: step4. Close ok
+     */
+    RefObject::KillAndDecObjRef(store);
+    KvDBManager::ReleaseDatabaseConnection(conn);
 }
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_transaction_record_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_transaction_record_test.cpp
index 8bc111fa37615348a04280249cc3a8eb3a52c41a..525d897f05353da2e6c8a52a77fbaeb3d97a12b9 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_transaction_record_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_transaction_record_test.cpp
@@ -948,7 +948,6 @@ HWTEST_F(DistributedDBStorageTransactionRecordTest, MultiverStorage022, TestSize
      * @tc.steps: step1. Put the batch data.
      */
     EXPECT_EQ(g_transaction->PutBatch(entries), E_OK);
-    std::vector<Key> keys = {entry.key, entry1.key};
     /**
      * @tc.steps: step2. Delete the batch data.
      */
@@ -1066,7 +1065,6 @@ HWTEST_F(DistributedDBStorageTransactionRecordTest, MultiverStorage025, TestSize
      * @tc.steps: step1. Put the batch data.
      */
     EXPECT_EQ(g_transaction->PutBatch(entries), E_OK);
-    std::vector<Key> keys = {entry.key, entry1.key};
     /**
      * @tc.steps: step2. Delete the batch data.
      */
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_mock_sync_module_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_mock_sync_module_test.cpp
index b90c53bf79d9ba37ab3e010201643db1f7ec87f4..f45c9ea8b555c365b39e804fd4ada822cd885b3d 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_mock_sync_module_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_mock_sync_module_test.cpp
@@ -29,6 +29,7 @@
 #include "mock_meta_data.h"
 #include "mock_remote_executor.h"
 #include "mock_single_ver_data_sync.h"
+#include "mock_single_ver_kv_syncer.h"
 #include "mock_single_ver_state_machine.h"
 #include "mock_sync_engine.h"
 #include "mock_sync_task_context.h"
@@ -752,8 +753,8 @@ HWTEST_F(DistributedDBMockSyncModuleTest, AbilitySync002, TestSize.Level1)
      * @tc.steps: step2. set syncDBInterface busy for save data return -E_BUSY
      */
     syncDBInterface.SetBusy(true);
-    SyncStrategy mockStrategy = {true, false, false};
-    EXPECT_CALL(syncTaskContext, GetSyncStrategy(_)).WillOnce(Return(mockStrategy));
+    std::pair<bool, bool> schemaSyncStatus = {true, true};
+    EXPECT_CALL(syncTaskContext, GetSchemaSyncStatus(_)).WillOnce(Return(schemaSyncStatus));
     EXPECT_EQ(abilitySync.AckRecv(message, &syncTaskContext), -E_BUSY);
     delete message;
     EXPECT_EQ(syncTaskContext.GetTaskErrCode(), -E_BUSY);
@@ -776,19 +777,19 @@ HWTEST_F(DistributedDBMockSyncModuleTest, AbilitySync003, TestSize.Level1)
     RelationalSyncStrategy strategy;
     const std::string tableName = "TEST";
     strategy[tableName] = {true, true, true};
-    context->SetRelationalSyncStrategy(strategy);
+    context->SetRelationalSyncStrategy(strategy, true);
     QuerySyncObject query;
     query.SetTableName(tableName);
     /**
      * @tc.steps: step2. set table is need reset ability sync but it still permit sync
      */
     context->SetIsNeedResetAbilitySync(true);
-    EXPECT_EQ(context->GetSyncStrategy(query).permitSync, true);
+    EXPECT_EQ(context->GetSchemaSyncStatus(query).first, true);
     /**
      * @tc.steps: step3. set table is schema change now it don't permit sync
      */
     context->SchemaChange();
-    EXPECT_EQ(context->GetSyncStrategy(query).permitSync, false);
+    EXPECT_EQ(context->GetSchemaSyncStatus(query).first, false);
     RefObject::KillAndDecObjRef(context);
 }
 
@@ -873,17 +874,39 @@ HWTEST_F(DistributedDBMockSyncModuleTest, SyncLifeTest003, TestSize.Level3)
     syncDBInterface->TestSetIdentifier(identifierVec);
     syncDBInterface->Initialize();
     virtualCommunicatorAggregator->OnlineDevice(DEVICE_B);
-    std::thread writeThread([&syncDBInterface] {
-        syncDBInterface->TestLocalChange();
-    });
-    std::thread deleteThread([&syncDBInterface] {
-        std::this_thread::sleep_for(std::chrono::milliseconds(1));
-        delete syncDBInterface;
+    syncDBInterface->TestLocalChange();
+    delete syncDBInterface;
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(nullptr);
+}
+
+/**
+ * @tc.name: SyncLifeTest004
+ * @tc.desc: Test syncer remote data change.
+ * @tc.type: FUNC
+ * @tc.require: AR000CCPOM
+ * @tc.author: zhangqiquan
+ */
+HWTEST_F(DistributedDBMockSyncModuleTest, SyncLifeTest004, TestSize.Level3)
+{
+    std::shared_ptr<SingleVerKVSyncer> syncer = std::make_shared<SingleVerKVSyncer>();
+    VirtualCommunicatorAggregator *virtualCommunicatorAggregator = new VirtualCommunicatorAggregator();
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(virtualCommunicatorAggregator);
+    auto syncDBInterface = new MockKvSyncInterface();
+    int incRefCount = 0;
+    EXPECT_CALL(*syncDBInterface, IncRefCount()).WillRepeatedly([&incRefCount]() {
+        incRefCount++;
     });
-    deleteThread.join();
-    writeThread.join();
-    std::this_thread::sleep_for(std::chrono::seconds(5));
+    EXPECT_CALL(*syncDBInterface, DecRefCount()).WillRepeatedly(Return());
+    std::vector<uint8_t> identifier(COMM_LABEL_LENGTH, 1u);
+    syncDBInterface->SetIdentifier(identifier);
+    syncer->Initialize(syncDBInterface, true);
+    syncer->EnableAutoSync(true);
+    syncer->RemoteDataChanged("");
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    syncer = nullptr;
     RuntimeContext::GetInstance()->SetCommunicatorAggregator(nullptr);
+    delete syncDBInterface;
+    EXPECT_EQ(incRefCount, 2); // refCount is 2
 }
 
 /**
@@ -962,6 +985,67 @@ HWTEST_F(DistributedDBMockSyncModuleTest, SyncEngineTest001, TestSize.Level1)
     virtualCommunicatorAggregator = nullptr;
 }
 
+/**
+ * @tc.name: SyncEngineTest002
+ * @tc.desc: Test SyncEngine add sync operation.
+ * @tc.type: FUNC
+ * @tc.require: AR000CCPOM
+ * @tc.author: zhangqiquan
+ */
+HWTEST_F(DistributedDBMockSyncModuleTest, SyncEngineTest002, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. prepare env
+     */
+    auto *enginePtr = new (std::nothrow) MockSyncEngine();
+    ASSERT_NE(enginePtr, nullptr);
+    EXPECT_CALL(*enginePtr, CreateSyncTaskContext())
+        .WillRepeatedly([]() {
+            return new (std::nothrow) SingleVerKvSyncTaskContext();
+        });
+    VirtualCommunicatorAggregator *virtualCommunicatorAggregator = new VirtualCommunicatorAggregator();
+    MockKvSyncInterface syncDBInterface;
+    int syncInterfaceRefCount = 1;
+    EXPECT_CALL(syncDBInterface, IncRefCount()).WillRepeatedly([&syncInterfaceRefCount]() {
+        syncInterfaceRefCount++;
+    });
+    EXPECT_CALL(syncDBInterface, DecRefCount()).WillRepeatedly([&syncInterfaceRefCount]() {
+        syncInterfaceRefCount--;
+    });
+    std::vector<uint8_t> identifier(COMM_LABEL_LENGTH, 1u);
+    syncDBInterface.SetIdentifier(identifier);
+    std::shared_ptr<Metadata> metaData = std::make_shared<Metadata>();
+    ASSERT_NE(virtualCommunicatorAggregator, nullptr);
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(virtualCommunicatorAggregator);
+    enginePtr->Initialize(&syncDBInterface, metaData, nullptr, nullptr, nullptr);
+    /**
+     * @tc.steps: step2. add sync operation for DEVICE_A and DEVICE_B. It will create two context for A and B
+     */
+    std::vector<std::string> devices = {
+        "DEVICES_A", "DEVICES_B"
+    };
+    const int syncId = 1;
+    auto operation = new (std::nothrow) SyncOperation(syncId, devices, 0, nullptr, false);
+    if (operation != nullptr) {
+        enginePtr->AddSyncOperation(operation);
+    }
+    /**
+     * @tc.steps: step3. abort machine and both context will be released
+     */
+    syncInterfaceRefCount = 0;
+    enginePtr->AbortMachineIfNeed(syncId);
+    EXPECT_EQ(syncInterfaceRefCount, 0);
+    enginePtr->Close();
+
+    RefObject::KillAndDecObjRef(enginePtr);
+    enginePtr = nullptr;
+    metaData = nullptr;
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(nullptr);
+    virtualCommunicatorAggregator = nullptr;
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    RuntimeContext::GetInstance()->StopTaskPool();
+}
+
 /**
 * @tc.name: remote query packet 001
 * @tc.desc: Test RemoteExecutorRequestPacket Serialization And DeSerialization
@@ -1158,4 +1242,39 @@ HWTEST_F(DistributedDBMockSyncModuleTest, TimeChangeListenerTest001, TestSize.Le
     EXPECT_NE(beforeOffset, afterOffset);
     ChangeTime(-2); // decrease 2s
 }
-#endif
\ No newline at end of file
+#endif
+
+/**
+ * @tc.name: TimeChangeListenerTest002
+ * @tc.desc: Test TimeChange.
+ * @tc.type: FUNC
+ * @tc.require: AR000CCPOM
+ * @tc.author: zhangqiquan
+ */
+HWTEST_F(DistributedDBMockSyncModuleTest, TimeChangeListenerTest002, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. create syncer without activation
+     */
+    MockSingleVerKVSyncer syncer;
+    VirtualSingleVerSyncDBInterface syncDBInterface;
+    KvDBProperties dbProperties;
+    dbProperties.SetBoolProp(DBProperties::SYNC_DUAL_TUPLE_MODE, true);
+    syncDBInterface.SetDbProperties(dbProperties);
+    /**
+     * @tc.steps: step2. trigger time change logic and reopen syncer at the same time
+     * @tc.expected: no crash here
+     */
+    const int loopCount = 100;
+    std::thread timeChangeThread([&syncer]() {
+        for (int i = 0; i < loopCount; ++i) {
+            int64_t changeOffset = 1;
+            syncer.CallRecordTimeChangeOffset(&changeOffset);
+        }
+    });
+    for (int i = 0; i < loopCount; ++i) {
+        EXPECT_EQ(syncer.Initialize(&syncDBInterface, false), -E_NO_NEED_ACTIVE);
+        EXPECT_EQ(syncer.Close(true), -E_NOT_INIT);
+    }
+    timeChangeThread.join();
+}
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_multi_ver_p2p_sync_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_multi_ver_p2p_sync_test.cpp
index 70d3ffbcd2af86d0aef10dfcec00985654e753de..f4cce093ad714720a840e3658c8a4aad89ac6593 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_multi_ver_p2p_sync_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_multi_ver_p2p_sync_test.cpp
@@ -770,7 +770,7 @@ static bool IsCommitHistorySyncRequestPacketEqual(const CommitHistorySyncRequest
     std::map<std::string, MultiVerCommitNode> commitMapB;
     inPacketA.GetCommitMap(commitMapA);
     inPacketB.GetCommitMap(commitMapB);
-    for (auto &entry : commitMapA) {
+    for (const auto &entry : commitMapA) {
         if (commitMapB.count(entry.first) == 0) {
             return false;
         }
@@ -778,7 +778,7 @@ static bool IsCommitHistorySyncRequestPacketEqual(const CommitHistorySyncRequest
             return false;
         }
     }
-    for (auto &entry : commitMapB) {
+    for (const auto &entry : commitMapB) {
         if (commitMapA.count(entry.first) == 0) {
             return false;
         }
@@ -897,7 +897,7 @@ static bool IsCommitHistorySyncAckPacketEqual(const CommitHistorySyncAckPacket &
         return false;
     }
     int count = 0;
-    for (auto &entry : commitVecA) {
+    for (const auto &entry : commitVecA) {
         if (!IsMultiVerCommitEqual(entry, commitVecB[count++])) {
             return false;
         }
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_relational_ver_p2p_sync_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_relational_ver_p2p_sync_test.cpp
index 9c49cac73959152fd4ec71a526d71f7b43038a60..74b351e6ea25f328620133af8e8acc9c8ccdb3d6 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_relational_ver_p2p_sync_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_relational_ver_p2p_sync_test.cpp
@@ -145,7 +145,7 @@ namespace {
         return sqlite3_exec(db, sql.c_str(), nullptr, nullptr, nullptr);
     }
 
-    int CreateTable(sqlite3 *db, std::vector<FieldInfo> &fieldInfoList, const std::string &tableName)
+    int CreateTable(sqlite3 *db, const std::vector<FieldInfo> &fieldInfoList, const std::string &tableName)
     {
         std::string sql = "CREATE TABLE " + tableName + "(";
         int index = 0;
@@ -398,7 +398,7 @@ namespace {
     }
 
     void GetSyncDataStep(std::map<std::string, DataValue> &dataMap, sqlite3_stmt *statement,
-        std::vector<FieldInfo> fieldInfoList)
+        std::vector<FieldInfo> &fieldInfoList)
     {
         int columnCount = sqlite3_column_count(statement);
         ASSERT_EQ(static_cast<size_t>(columnCount), fieldInfoList.size());
@@ -410,7 +410,7 @@ namespace {
     }
 
     void GetSyncData(sqlite3 *db, std::map<std::string, DataValue> &dataMap, const std::string &tableName,
-        std::vector<FieldInfo> fieldInfoList)
+        std::vector<FieldInfo> &fieldInfoList)
     {
         sqlite3_stmt *statement = nullptr;
         EXPECT_EQ(PrepareSelect(db, statement, GetDeviceTableName(tableName)), SQLITE_OK);
@@ -434,7 +434,7 @@ namespace {
     }
 
     void PrepareBasicTable(const std::string &tableName, std::vector<FieldInfo> &fieldInfoList,
-        std::vector<RelationalVirtualDevice *> &remoteDeviceVec, bool createDistributedTable = true)
+        const std::vector<RelationalVirtualDevice *> &remoteDeviceVec, bool createDistributedTable = true)
     {
         sqlite3 *db = nullptr;
         EXPECT_EQ(GetDB(db), SQLITE_OK);
@@ -466,7 +466,7 @@ namespace {
     }
 
     void PrepareVirtualEnvironment(std::map<std::string, DataValue> &dataMap, const std::string &tableName,
-        std::vector<FieldInfo> &fieldInfoList, std::vector<RelationalVirtualDevice *> remoteDeviceVec,
+        std::vector<FieldInfo> &fieldInfoList, const std::vector<RelationalVirtualDevice *> remoteDeviceVec,
         bool createDistributedTable = true)
     {
         PrepareBasicTable(tableName, fieldInfoList, remoteDeviceVec, createDistributedTable);
@@ -480,13 +480,13 @@ namespace {
     }
 
     void PrepareVirtualEnvironment(std::map<std::string, DataValue> &dataMap,
-        std::vector<RelationalVirtualDevice *> remoteDeviceVec, bool createDistributedTable = true)
+        const std::vector<RelationalVirtualDevice *> remoteDeviceVec, bool createDistributedTable = true)
     {
         PrepareVirtualEnvironment(dataMap, g_tableName, g_fieldInfoList, remoteDeviceVec, createDistributedTable);
     }
 
-    void CheckData(std::map<std::string, DataValue> &targetMap, const std::string &tableName,
-        std::vector<FieldInfo> fieldInfoList)
+    void CheckData(const std::map<std::string, DataValue> &targetMap, const std::string &tableName,
+        std::vector<FieldInfo> &fieldInfoList)
     {
         std::map<std::string, DataValue> dataMap;
         sqlite3 *db = nullptr;
@@ -500,7 +500,7 @@ namespace {
         }
     }
 
-    void CheckData(std::map<std::string, DataValue> &targetMap)
+    void CheckData(const std::map<std::string, DataValue> &targetMap)
     {
         CheckData(targetMap, g_tableName, g_fieldInfoList);
     }
@@ -576,7 +576,7 @@ namespace {
 
     void PrepareEnvironment(std::map<std::string, DataValue> &dataMap,
         std::vector<FieldInfo> &localFieldInfoList, std::vector<FieldInfo> &remoteFieldInfoList,
-        std::vector<RelationalVirtualDevice *> remoteDeviceVec)
+        const std::vector<RelationalVirtualDevice *> remoteDeviceVec)
     {
         PrepareEnvironment(dataMap, g_tableName, localFieldInfoList, remoteFieldInfoList, remoteDeviceVec);
     }
@@ -905,6 +905,7 @@ HWTEST_F(DistributedDBRelationalVerP2PSyncTest, NormalSync001, TestSize.Level0)
     BlockSync(SyncMode::SYNC_MODE_PUSH_ONLY, OK, {DEVICE_B});
 
     CheckVirtualData(dataMap);
+    DistributedDBToolsUnitTest::Dump();
 }
 
 /**
@@ -1538,7 +1539,7 @@ HWTEST_F(DistributedDBRelationalVerP2PSyncTest, Observer001, TestSize.Level0)
 * @tc.require: AR000GK58N
 * @tc.author: zhuwentao
 */
-HWTEST_F(DistributedDBRelationalVerP2PSyncTest, observer002, TestSize.Level3)
+HWTEST_F(DistributedDBRelationalVerP2PSyncTest, Observer002, TestSize.Level3)
 {
     /**
      * @tc.steps: step1. open rdb store, create distribute table and insert data
@@ -1592,6 +1593,56 @@ HWTEST_F(DistributedDBRelationalVerP2PSyncTest, observer002, TestSize.Level3)
     delete observer;
 }
 
+/*
+* @tc.name: relation observer 003
+* @tc.desc: Test relation observer without manager
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: zhangqiquan
+*/
+HWTEST_F(DistributedDBRelationalVerP2PSyncTest, Observer003, TestSize.Level0)
+{
+    /**
+     * @tc.steps: step1. device A create table and device B insert data and device C don't insert data
+     * @tc.expected: step1. create and insert ok
+     */
+    g_observer->ResetToZero();
+    std::map<std::string, DataValue> dataMap;
+    PrepareVirtualEnvironment(dataMap, {g_deviceB, g_deviceC});
+    std::shared_ptr<RelationalStoreManager> mgr = std::make_shared<RelationalStoreManager>(APP_ID, USER_ID);
+    ASSERT_NE(mgr, nullptr);
+    RelationalStoreDelegate::Option option;
+    option.observer = g_observer;
+#ifndef OMIT_ENCRYPT
+    option.isEncryptedDb = true;
+    option.iterateTimes = DEFAULT_ITER;
+    option.passwd = g_isAfterRekey ? g_rekeyPasswd : g_correctPasswd;
+    option.cipher = CipherType::DEFAULT;
+#endif
+    RelationalStoreDelegate *rdbDelegatePtr = nullptr;
+    mgr->OpenStore(g_dbDir, STORE_ID_1, option, rdbDelegatePtr);
+    mgr = nullptr;
+    /**
+     * @tc.steps: step2. device A pull sync mode
+     * @tc.expected: step2. sync ok
+     */
+    Query query = Query::Select(g_tableName);
+    DBStatus callStatus = rdbDelegatePtr->Sync({DEVICE_B, DEVICE_C}, SyncMode::SYNC_MODE_PULL_ONLY, query,
+        nullptr, true);
+    EXPECT_EQ(callStatus, OK);
+    /**
+     * @tc.steps: step3. device A check observer
+     * @tc.expected: step2. data change device is deviceB
+     */
+    EXPECT_EQ(g_observer->GetCallCount(), 1u);
+    EXPECT_EQ(g_observer->GetDataChangeDevice(), DEVICE_B);
+    CheckIdentify(g_observer);
+    mgr = std::make_shared<RelationalStoreManager>(APP_ID, USER_ID);
+    ASSERT_NE(mgr, nullptr);
+    mgr->CloseStore(rdbDelegatePtr);
+    mgr = nullptr;
+}
+
 /**
 * @tc.name: remote query 001
 * @tc.desc: Test rdb remote query
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_msg_schedule_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_msg_schedule_test.cpp
index 9df55d1bb65c8d80ba25eaa61aa9549aa421e17e..f1778d10a06873aa88d1c76715e2fd7bc23063a9 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_msg_schedule_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_msg_schedule_test.cpp
@@ -432,8 +432,8 @@ HWTEST_F(DistributedDBSingleVerMsgScheduleTest, MsgSchedule007, TestSize.Level0)
         msgSchedule.ScheduleInfoHandle(isNeedHandle, false, msg);
         delete msg;
     }
-    Message *msg = msgSchedule.MoveNextMsg(context, isNeedHandle, isNeedContinue);
-    ASSERT_TRUE(msg == nullptr);
+    Message *msg2 = msgSchedule.MoveNextMsg(context, isNeedHandle, isNeedContinue);
+    ASSERT_TRUE(msg2 == nullptr);
     /**
      * @tc.steps: step2. put msg seq1_packet1, seq2_packet2
      * @tc.expected: get nullptr
@@ -448,9 +448,9 @@ HWTEST_F(DistributedDBSingleVerMsgScheduleTest, MsgSchedule007, TestSize.Level0)
     isNeedHandle = true;
     isNeedContinue = true;
     for (uint32_t i = 1; i <= 3; i++) {
-        Message *msg = msgSchedule.MoveNextMsg(context, isNeedHandle, isNeedContinue);
+        Message *msg3 = msgSchedule.MoveNextMsg(context, isNeedHandle, isNeedContinue);
         EXPECT_EQ(isNeedContinue, true);
-        ASSERT_TRUE(msg == nullptr);
+        ASSERT_TRUE(msg3 == nullptr);
     }
     RefObject::KillAndDecObjRef(context);
     context = nullptr;
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_multi_user_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_multi_user_test.cpp
index 682ee5447bbb78bd3262cc1ac93c19cd94fc4f31..bc6db1f4df6b72030ffee3dfbed5cbb3c087201a 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_multi_user_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_multi_user_test.cpp
@@ -529,6 +529,7 @@ HWTEST_F(DistributedDBSingleVerMultiUserTest, MultiUser004, TestSize.Level0)
     option.syncDualTupleMode = true;
     EXPECT_TRUE(g_mgr1.EnableKvStoreAutoLaunch(USER_ID_2, APP_ID, STORE_ID, option, notifier) == OK);
     EXPECT_TRUE(g_mgr1.EnableKvStoreAutoLaunch(USER_ID_1, APP_ID, STORE_ID, option, notifier) == OK);
+    DistributedDBToolsUnitTest::Dump();
 
     /**
      * @tc.steps: step3. RunCommunicatorLackCallback
@@ -805,4 +806,41 @@ HWTEST_F(DistributedDBSingleVerMultiUserTest, MultiUser011, TestSize.Level1)
     std::vector<std::string> devices = {g_deviceB->GetDeviceId()};
     EXPECT_EQ(g_tool.SyncTest(g_kvDelegatePtr1, devices, SYNC_MODE_PUSH_ONLY, result, true), OK);
     CloseStore();
+}
+
+/**
+ * @tc.name: MultiUser012
+ * @tc.desc: test NotifyUserChanged and SetEqualIdentifier sync concurrently
+ * @tc.type: FUNC
+ * @tc.require: AR000E8S2T
+ * @tc.author: zhangqiquan
+ */
+HWTEST_F(DistributedDBSingleVerMultiUserTest, MultiUser012, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. set SyncActivationCheckCallback and only userId1 can active
+     */
+    g_mgr1.SetSyncActivationCheckCallback(g_syncActivationCheckCallback2);
+    /**
+     * @tc.steps: step2. openstore1 and openstore2 in dual tuple sync mode
+     * @tc.expected: step2. only userId1 sync mode is active
+     */
+    OpenStore1(true);
+    OpenStore2(true);
+    /**
+     * @tc.steps: step3. set SyncActivationCheckCallback and only userId2 can active
+     */
+    g_mgr1.SetSyncActivationCheckCallback(g_syncActivationCheckCallback1);
+    /**
+     * @tc.steps: step4. SetEqualIdentifier and NotifyUserChanged concurrently called
+     */
+    thread subThread([]() {
+        EXPECT_TRUE(KvStoreDelegateManager::NotifyUserChanged() == OK);
+    });
+    std::string identifier = KvStoreDelegateManager::GetKvStoreIdentifier("default", APP_ID, STORE_ID);
+    std::vector<std::string> devices = {g_deviceB->GetDeviceId()};
+    g_kvDelegatePtr1->SetEqualIdentifier(identifier, devices);
+    std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_3_SECONDS));
+    subThread.join();
+    CloseStore();
 }
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_query_sync_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_query_sync_test.cpp
index cdf06110bd488c406bb5a67eed39661e51510654..112dc2f227098ddc7cbeed13ae8c8acb5270b6f5 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_query_sync_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_query_sync_test.cpp
@@ -344,9 +344,11 @@ HWTEST_F(DistributedDBSingleVerP2PQuerySyncTest, NormalSync003, TestSize.Level1)
     Value value = {'1'};
     const int dataSize = 10;
     status = g_kvDelegatePtr->Put(key, value);
+    ASSERT_TRUE(status == OK);
     Key key2 = {'2'};
     Value value2 = {'2'};
     status = g_kvDelegatePtr->Put(key2, value2);
+    ASSERT_TRUE(status == OK);
 
     /**
      * @tc.steps: step2. deviceB put {b0, v0} - {b9, v9}, {c, v}
@@ -1448,6 +1450,7 @@ HWTEST_F(DistributedDBSingleVerP2PQuerySyncTest, AllPredicateQuerySync001, TestS
         key.push_back(i);
         key2.push_back(i);
         status = g_schemaKvDelegatePtr->Put(key, value);
+        ASSERT_TRUE(status == OK);
         status = g_schemaKvDelegatePtr->Put(key2, value2);
         ASSERT_TRUE(status == OK);
         key.pop_back();
@@ -1545,6 +1548,7 @@ HWTEST_F(DistributedDBSingleVerP2PQuerySyncTest, AllPredicateQuerySync003, TestS
         key.push_back(i);
         key2.push_back(i);
         status = g_schemaKvDelegatePtr->Put(key, value);
+        ASSERT_TRUE(status == OK);
         status = g_schemaKvDelegatePtr->Put(key2, value2);
         ASSERT_TRUE(status == OK);
         key.pop_back();
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subsribe_sync_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
similarity index 98%
rename from frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subsribe_sync_test.cpp
rename to frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
index a7ce0829ad300c9a5c505b8655aa42fa20fb74b8..618cd40f6e119e9ca814c2cb2ad2ad8201bf5cf6 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subsribe_sync_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
@@ -511,9 +511,9 @@ HWTEST_F(DistributedDBSingleVerP2PSubscribeSyncTest, subscribeManager003, TestSi
      */
     LOGI("============step 3============");
     for (int i = 0; i < 8; i++) {
-        QuerySyncObject querySyncObj(Query::Select().PrefixKey({'a', static_cast<uint8_t>('a' + i)}));
-        ASSERT_TRUE(subManager.ReserveLocalSubscribeQuery(device + std::to_string(i), querySyncObj) == E_OK);
-        ASSERT_TRUE(subManager.ActiveLocalSubscribeQuery(device + std::to_string(i), querySyncObj) == E_OK);
+        QuerySyncObject querySyncObj2(Query::Select().PrefixKey({'a', static_cast<uint8_t>('a' + i)}));
+        ASSERT_TRUE(subManager.ReserveLocalSubscribeQuery(device + std::to_string(i), querySyncObj2) == E_OK);
+        ASSERT_TRUE(subManager.ActiveLocalSubscribeQuery(device + std::to_string(i), querySyncObj2) == E_OK);
     }
     QuerySyncObject querySyncObj1(Query::Select().PrefixKey({'a', static_cast<uint8_t>('a' + 8)}));
     ASSERT_TRUE(subManager.ReserveLocalSubscribeQuery(device + std::to_string(8), querySyncObj1) != E_OK);
@@ -562,9 +562,9 @@ HWTEST_F(DistributedDBSingleVerP2PSubscribeSyncTest, subscribeManager004, TestSi
      */
     LOGI("============step 3============");
     for (int i = 0; i < 8; i++) {
-        QuerySyncObject querySyncObj(Query::Select().PrefixKey({'a', static_cast<uint8_t>('a' + i)}));
-        ASSERT_TRUE(subManager.ReserveRemoteSubscribeQuery(device + std::to_string(i), querySyncObj) == E_OK);
-        ASSERT_TRUE(subManager.ActiveRemoteSubscribeQuery(device + std::to_string(i), querySyncObj) == E_OK);
+        QuerySyncObject querySyncObj2(Query::Select().PrefixKey({'a', static_cast<uint8_t>('a' + i)}));
+        ASSERT_TRUE(subManager.ReserveRemoteSubscribeQuery(device + std::to_string(i), querySyncObj2) == E_OK);
+        ASSERT_TRUE(subManager.ActiveRemoteSubscribeQuery(device + std::to_string(i), querySyncObj2) == E_OK);
     }
     QuerySyncObject querySyncObj1(Query::Select().PrefixKey({'a', static_cast<uint8_t>('a' + 8)}));
     ASSERT_TRUE(subManager.ReserveRemoteSubscribeQuery(device + std::to_string(8), querySyncObj1) != E_OK);
@@ -596,11 +596,11 @@ HWTEST_F(DistributedDBSingleVerP2PSubscribeSyncTest, subscribeManager005, TestSi
     LOGI("============step 2============");
     subManager.GetLocalSubscribeQueries(DEVICE_A, subscribeQueries);
     ASSERT_TRUE(subscribeQueries.size() == 4);
-    subManager.PutLocalUnFiniedSubQueries(DEVICE_A, subscribeQueries);
+    subManager.PutLocalUnFinishedSubQueries(DEVICE_A, subscribeQueries);
     subscribeQueries.clear();
     subManager.GetLocalSubscribeQueries(DEVICE_B, subscribeQueries);
     ASSERT_TRUE(subscribeQueries.size() == 2);
-    subManager.PutLocalUnFiniedSubQueries(DEVICE_B, subscribeQueries);
+    subManager.PutLocalUnFinishedSubQueries(DEVICE_B, subscribeQueries);
     subscribeQueries.clear();
     /**
      * @tc.steps: step3. get all device unFinished subscribe queries and check
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_sync_check_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_sync_check_test.cpp
index d30ccb4b274c8bf2da2b4b1afd444a4d37eb302d..3abf9a0ac05d9bd940b8a038565c97e0245abf52 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_sync_check_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_sync_check_test.cpp
@@ -593,7 +593,7 @@ void SyncWithQuery(vector<std::string> &devices, const Query &query, const DBSta
     SyncWithQuery(devices, query, DistributedDB::SYNC_MODE_PUSH_ONLY, targetStatus);
 }
 
-void SyncWithDeviceOffline(vector<std::string> &devices, Key &key, Query &query)
+void SyncWithDeviceOffline(vector<std::string> &devices, Key &key, const Query &query)
 {
     Value value = {'2'};
     ASSERT_TRUE(g_kvDelegatePtr->Put(key, value) == OK);
@@ -660,7 +660,6 @@ HWTEST_F(DistributedDBSingleVerP2PSyncCheckTest, AckSessionCheck001, TestSize.Le
      * @tc.steps: step1. deviceB sync to deviceA just for timeSync and abilitySync
      * @tc.expected: step1. should return OK.
      */
-    std::map<std::string, DBStatus> result;
     ASSERT_TRUE(g_deviceB->Sync(SYNC_MODE_PUSH_ONLY, true) == OK);
 
     /**
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_sync_test.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_sync_test.cpp
index c828bda01c9db8b1ff800b9c4576c5eb73618baf..b754bb9049110a97eda2b0c741aa67d2adb47eba 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_sync_test.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_sync_test.cpp
@@ -123,6 +123,29 @@ namespace {
             EXPECT_TRUE(resultvalue == value);
         }
     }
+
+    void CalculateDataTest(uint32_t itemCount, uint32_t keySize, uint32_t valueSize)
+    {
+        for (uint32_t i = 0; i < itemCount; i++) {
+            std::vector<uint8_t> prefixKey = {'a', 'b', 'c'};
+            Key key = DistributedDBToolsUnitTest::GetRandPrefixKey(prefixKey, keySize);
+            Value value;
+            DistributedDBToolsUnitTest::GetRandomKeyValue(value, valueSize);
+            EXPECT_EQ(g_kvDelegatePtr->Put(key, value), OK);
+        }
+        size_t dataSize = g_kvDelegatePtr->GetSyncDataSize(DEVICE_B);
+        uint32_t expectedDataSize = (valueSize + keySize);
+        uint32_t externalSize = 70u;
+        uint32_t serialHeadLen = 8u;
+        LOGI("expectedDataSize=%u, v=%u", expectedDataSize, externalSize);
+        uint32_t maxDataSize = 1024u * 1024u;
+        if (itemCount * expectedDataSize >= maxDataSize) {
+            EXPECT_EQ(static_cast<uint32_t>(dataSize), maxDataSize);
+            return;
+        }
+        ASSERT_GE(static_cast<uint32_t>(dataSize), itemCount * expectedDataSize);
+        ASSERT_LE(static_cast<uint32_t>(dataSize), serialHeadLen + itemCount * (expectedDataSize + externalSize));
+    }
 }
 
 class DistributedDBSingleVerP2PSyncTest : public testing::Test {
@@ -953,8 +976,7 @@ HWTEST_F(DistributedDBSingleVerP2PSyncTest, DeviceOfflineSync001, TestSize.Level
     item.value.clear();
     Key hashKey;
     DistributedDBToolsUnitTest::CalcHash(key3, hashKey);
-    g_deviceC->GetData(hashKey, item);
-    EXPECT_TRUE((item.flag & VirtualDataItem::DELETE_FLAG) == 1);
+    EXPECT_TRUE(g_deviceC->GetData(hashKey, item) == -E_NOT_FOUND);
     item.value.clear();
     g_deviceC->GetData(key4, item);
     EXPECT_TRUE(item.value == value4);
@@ -2302,11 +2324,12 @@ HWTEST_F(DistributedDBSingleVerP2PSyncTest, SaveDataNotify001, TestSize.Level3)
      */
     g_deviceB->SetSaveDataDelayTime(WAIT_30_SECONDS);
     status = g_kvDelegatePtr->Put(key, value);
-
+    ASSERT_TRUE(status == OK);
      /**
      * @tc.steps: step3. deviceA call sync and wait
      * @tc.expected: step3. sync should return OK. onComplete should be called, deviceB sync success.
      */
+    result.clear();
     status = g_tool.SyncTest(g_kvDelegatePtr, devices, SYNC_MODE_PUSH_ONLY, result);
     ASSERT_TRUE(status == OK);
     ASSERT_TRUE(result.size() == devices.size());
@@ -2317,11 +2340,12 @@ HWTEST_F(DistributedDBSingleVerP2PSyncTest, SaveDataNotify001, TestSize.Level3)
      */
     g_deviceB->SetSaveDataDelayTime(WAIT_36_SECONDS);
     status = g_kvDelegatePtr->Put(key, value);
-
+    ASSERT_TRUE(status == OK);
     /**
      * @tc.steps: step5. deviceA call sync and wait
      * @tc.expected: step5. sync should return OK. onComplete should be called, deviceB sync TIME_OUT.
      */
+    result.clear();
     status = g_tool.SyncTest(g_kvDelegatePtr, devices, SYNC_MODE_PUSH_ONLY, result);
     ASSERT_TRUE(status == OK);
     ASSERT_TRUE(result.size() == devices.size());
@@ -2412,7 +2436,7 @@ HWTEST_F(DistributedDBSingleVerP2PSyncTest, SametimeSync002, TestSize.Level3)
         }
     });
     std::map<std::string, DBStatus> result;
-    auto callback = [&result](std::map<std::string, DBStatus> map) {
+    auto callback = [&result](const std::map<std::string, DBStatus> &map) {
         result = map;
     };
     Query query = Query::Select().PrefixKey({'k', '1'});
@@ -2431,7 +2455,7 @@ HWTEST_F(DistributedDBSingleVerP2PSyncTest, SametimeSync002, TestSize.Level3)
     });
     std::thread subThread([&devices] {
         std::map<std::string, DBStatus> result;
-        auto callback = [&result](std::map<std::string, DBStatus> map) {
+        auto callback = [&result](const std::map<std::string, DBStatus> &map) {
             result = map;
         };
         Query query = Query::Select().PrefixKey({'k', '2'});
@@ -2447,7 +2471,7 @@ HWTEST_F(DistributedDBSingleVerP2PSyncTest, SametimeSync002, TestSize.Level3)
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
     std::map<std::string, int> virtualResult;
     g_deviceB->Sync(DistributedDB::SYNC_MODE_PULL_ONLY, query,
-        [&virtualResult](std::map<std::string, int> map) {
+        [&virtualResult](const std::map<std::string, int> &map) {
             virtualResult = map;
         }, true);
     EXPECT_TRUE(status == OK);
@@ -2578,6 +2602,7 @@ HWTEST_F(DistributedDBSingleVerP2PSyncTest, CloseSync001, TestSize.Level3)
     EXPECT_EQ(result.size(), 0u);
     VirtualDataItem actualValue;
     EXPECT_EQ(g_deviceB->GetData(key, actualValue), -E_NOT_FOUND);
+    g_communicatorAggregator->RegOnDispatch(nullptr);
 }
 
 /**
@@ -2629,6 +2654,7 @@ HWTEST_F(DistributedDBSingleVerP2PSyncTest, CloseSync002, TestSize.Level3)
     DBStatus status = g_mgr.DeleteKvStore(STORE_ID);
     LOGD("delete kv store status %d", status);
     ASSERT_TRUE(status == OK);
+    g_communicatorAggregator->RegOnDispatch(nullptr);
 }
 
 /**
@@ -2723,3 +2749,581 @@ HWTEST_F(DistributedDBSingleVerP2PSyncTest, EncryptedAlgoUpgrade001, TestSize.Le
     */
     CrudTest();
 }
+
+/**
+  * @tc.name: RemoveDeviceData001
+  * @tc.desc: call rekey and removeDeviceData Concurrently
+  * @tc.type: FUNC
+  * @tc.require: AR000D487B
+  * @tc.author: zhuwentao
+  */
+HWTEST_F(DistributedDBSingleVerP2PSyncTest, RemoveDeviceData001, TestSize.Level1)
+{
+    ASSERT_TRUE(g_kvDelegatePtr != nullptr);
+    /**
+     * @tc.steps: step1. sync deviceB data to A
+     * * @tc.expected: step1. interface return ok
+    */
+    Key key1 = {'1'};
+    Key key2 = {'2'};
+    Value value = {'1'};
+    g_deviceB->PutData(key1, value, 1, 0);
+    g_deviceB->PutData(key2, value, 2, 0);
+    g_deviceB->Sync(DistributedDB::SYNC_MODE_PUSH_ONLY, true);
+
+    Value actualValue;
+    g_kvDelegatePtr->Get(key1, actualValue);
+    EXPECT_EQ(actualValue, value);
+    actualValue.clear();
+    g_kvDelegatePtr->Get(key2, actualValue);
+    EXPECT_EQ(actualValue, value);
+    /**
+     * @tc.steps: step2. call Rekey and RemoveDeviceData Concurrently
+     * * @tc.expected: step2. interface return ok
+    */
+    std::thread thread1([]() {
+        CipherPassword passwd3;
+        std::vector<uint8_t> passwdVect = {'p', 's', 'd', 'z'};
+        passwd3.SetValue(passwdVect.data(), passwdVect.size());
+        g_kvDelegatePtr->Rekey(passwd3);
+    });
+    std::thread thread2([]() {
+        g_kvDelegatePtr->RemoveDeviceData(g_deviceB->GetDeviceId());
+    });
+    thread1.join();
+    thread2.join();
+}
+
+/**
+  * @tc.name: RemoveDeviceData002
+  * @tc.desc: test remove device data before sync
+  * @tc.type: FUNC
+  * @tc.require: AR000D487B
+  * @tc.author: zhuwentao
+  */
+HWTEST_F(DistributedDBSingleVerP2PSyncTest, RemoveDeviceData002, TestSize.Level1)
+{
+    ASSERT_TRUE(g_kvDelegatePtr != nullptr);
+    /**
+     * @tc.steps: step1. sync deviceB data to A and check data
+     * * @tc.expected: step1. interface return ok
+    */
+    Key key1 = {'1'};
+    Key key2 = {'2'};
+    Value value = {'1'};
+	Timestamp currentTime;
+    (void)OS::GetCurrentSysTimeInMicrosecond(currentTime);
+    EXPECT_EQ(g_deviceB->PutData(key1, value, currentTime, 0), E_OK);
+    (void)OS::GetCurrentSysTimeInMicrosecond(currentTime);
+    EXPECT_EQ(g_deviceB->PutData(key2, value, currentTime, 0), E_OK);
+    EXPECT_EQ(g_deviceB->Sync(DistributedDB::SYNC_MODE_PUSH_ONLY, true), E_OK);
+    Value actualValue;
+    EXPECT_EQ(g_kvDelegatePtr->Get(key1, actualValue), OK);
+    EXPECT_EQ(actualValue, value);
+    actualValue.clear();
+    EXPECT_EQ(g_kvDelegatePtr->Get(key2, actualValue), OK);
+    EXPECT_EQ(actualValue, value);
+    /**
+     * @tc.steps: step2. call RemoveDeviceData
+     * * @tc.expected: step2. interface return ok
+    */
+    g_kvDelegatePtr->RemoveDeviceData(g_deviceB->GetDeviceId());
+    EXPECT_EQ(g_kvDelegatePtr->Get(key1, actualValue), NOT_FOUND);
+    EXPECT_EQ(g_kvDelegatePtr->Get(key2, actualValue), NOT_FOUND);
+    /**
+     * @tc.steps: step3. sync to device A again and check data
+     * * @tc.expected: step3. sync ok
+    */
+    EXPECT_EQ(g_deviceB->Sync(DistributedDB::SYNC_MODE_PUSH_ONLY, true), E_OK);
+    actualValue.clear();
+    EXPECT_EQ(g_kvDelegatePtr->Get(key1, actualValue), OK);
+    EXPECT_EQ(actualValue, value);
+    actualValue.clear();
+    EXPECT_EQ(g_kvDelegatePtr->Get(key2, actualValue), OK);
+    EXPECT_EQ(actualValue, value);
+}
+
+
+/**
+  * @tc.name: CalculateSyncData001
+  * @tc.desc: Test sync data whose device never synced before
+  * @tc.type: FUNC
+  * @tc.require: AR000HI2JS
+  * @tc.author: zhuwentao
+  */
+HWTEST_F(DistributedDBSingleVerP2PSyncTest, CalculateSyncData001, TestSize.Level3)
+{
+    ASSERT_TRUE(g_kvDelegatePtr != nullptr);
+    size_t dataSize = g_kvDelegatePtr->GetSyncDataSize(DEVICE_B);
+    uint32_t serialHeadLen = 8u;
+    EXPECT_EQ(static_cast<uint32_t>(dataSize), 0u + serialHeadLen);
+    uint32_t keySize = 256u;
+    uint32_t valuesize = 1024u;
+    uint32_t itemCount = 10u;
+    CalculateDataTest(itemCount, keySize, valuesize);
+}
+
+/**
+  * @tc.name: CalculateSyncData002
+  * @tc.desc: Test sync data whose device synced before, but sync data is less than 1M
+  * @tc.type: FUNC
+  * @tc.require: AR000HI2JS
+  * @tc.author: zhuwentao
+  */
+HWTEST_F(DistributedDBSingleVerP2PSyncTest, CalculateSyncData002, TestSize.Level3)
+{
+    ASSERT_TRUE(g_kvDelegatePtr != nullptr);
+    Key key1 = {'1'};
+    Value value1 = {'1'};
+    EXPECT_EQ(g_kvDelegatePtr->Put(key1, value1), OK);
+
+    std::vector<std::string> devices;
+    devices.push_back(g_deviceB->GetDeviceId());
+    std::map<std::string, DBStatus> result;
+    DBStatus status = g_tool.SyncTest(g_kvDelegatePtr, devices, SYNC_MODE_PUSH_ONLY, result);
+    ASSERT_TRUE(status == OK);
+    ASSERT_TRUE(result.size() == devices.size());
+    for (const auto &pair : result) {
+        EXPECT_TRUE(pair.second == OK);
+    }
+
+    uint32_t keySize = 256u;
+    uint32_t valuesize = 512u;
+    uint32_t itemCount = 20u;
+    CalculateDataTest(itemCount, keySize, valuesize);
+}
+
+/**
+  * @tc.name: CalculateSyncData003
+  * @tc.desc: Test sync data whose device synced before, but sync data is larger than 1M
+  * @tc.type: FUNC
+  * @tc.require: AR000HI2JS
+  * @tc.author: zhuwentao
+  */
+HWTEST_F(DistributedDBSingleVerP2PSyncTest, CalculateSyncData003, TestSize.Level3)
+{
+    ASSERT_TRUE(g_kvDelegatePtr != nullptr);
+    Key key1 = {'1'};
+    Value value1 = {'1'};
+    EXPECT_EQ(g_kvDelegatePtr->Put(key1, value1), OK);
+
+    std::vector<std::string> devices;
+    devices.push_back(g_deviceB->GetDeviceId());
+    std::map<std::string, DBStatus> result;
+    DBStatus status = g_tool.SyncTest(g_kvDelegatePtr, devices, SYNC_MODE_PUSH_ONLY, result);
+    ASSERT_TRUE(status == OK);
+    ASSERT_TRUE(result.size() == devices.size());
+    for (const auto &pair : result) {
+        EXPECT_TRUE(pair.second == OK);
+    }
+    uint32_t keySize = 256u;
+    uint32_t valuesize = 1024u;
+    uint32_t itemCount = 2048u;
+    CalculateDataTest(itemCount, keySize, valuesize);
+}
+
+/**
+  * @tc.name: CalculateSyncData004
+  * @tc.desc: Test invalid device when call GetSyncDataSize interface
+  * @tc.type: FUNC
+  * @tc.require: AR000HI2JS
+  * @tc.author: zhuwentao
+  */
+HWTEST_F(DistributedDBSingleVerP2PSyncTest, CalculateSyncData004, TestSize.Level3)
+{
+    ASSERT_TRUE(g_kvDelegatePtr != nullptr);
+    std::string device;
+    EXPECT_EQ(g_kvDelegatePtr->GetSyncDataSize(device), 0u);
+}
+
+/**
+  * @tc.name: CalculateSyncData005
+  * @tc.desc: Test CalculateSyncData and rekey Concurrently
+  * @tc.type: FUNC
+  * @tc.require: AR000HI2JS
+  * @tc.author: zhuwentao
+  */
+HWTEST_F(DistributedDBSingleVerP2PSyncTest, CalculateSyncData005, TestSize.Level3)
+{
+    ASSERT_TRUE(g_kvDelegatePtr != nullptr);
+    size_t dataSize = 0;
+    Key key1 = {'1'};
+    Value value1 = {'1'};
+    EXPECT_EQ(g_kvDelegatePtr->Put(key1, value1), OK);
+    std::thread thread1([]() {
+        if (g_kvDelegatePtr != nullptr) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(1));
+            CipherPassword passwd; // random password
+            vector<uint8_t> passwdBuffer(10, 45);  // 10 and 45 as random password.
+            passwd.SetValue(passwdBuffer.data(), passwdBuffer.size());
+            g_kvDelegatePtr->Rekey(passwd);
+        }
+    });
+    std::thread thread2([&dataSize, &key1, &value1]() {
+        if (g_kvDelegatePtr != nullptr) {
+            dataSize = g_kvDelegatePtr->GetSyncDataSize(DEVICE_B);
+        }
+        if (dataSize > 0)
+        {
+            uint32_t expectedDataSize = (key1.size() + value1.size());
+            uint32_t externalSize = 70u;
+            uint32_t serialHeadLen = 8u;
+            ASSERT_GE(static_cast<uint32_t>(dataSize), expectedDataSize);
+            ASSERT_LE(static_cast<uint32_t>(dataSize), serialHeadLen + expectedDataSize + externalSize);
+        }
+    });
+    thread1.join();
+    thread2.join();
+}
+
+/**
+  * @tc.name: DeviceOfflineSyncTask001
+  * @tc.desc: Test sync task when device offline and close db Concurrently
+  * @tc.type: FUNC
+  * @tc.require: AR000HI2JS
+  * @tc.author: zhuwentao
+  */
+HWTEST_F(DistributedDBSingleVerP2PSyncTest, DeviceOfflineSyncTask001, TestSize.Level3)
+{
+    DBStatus status = OK;
+    std::vector<std::string> devices;
+    devices.push_back(g_deviceB->GetDeviceId());
+
+    /**
+     * @tc.steps: step1. deviceA put {k1, v1}
+     */
+    Key key = {'1'};
+    Value value = {'1'};
+    ASSERT_TRUE(g_kvDelegatePtr->Put(key, value) == OK);
+
+    /**
+     * @tc.steps: step2. deviceA set auto sync and put some key/value
+     * @tc.expected: step2. interface should return OK.
+     */
+    bool autoSync = true;
+    PragmaData data = static_cast<PragmaData>(&autoSync);
+    status = g_kvDelegatePtr->Pragma(AUTO_SYNC, data);
+    ASSERT_EQ(status, OK);
+
+    Key key1 = {'2'};
+    Key key2 = {'3'};
+    Key key3 = {'4'};
+    Key key4 = {'5'};
+    ASSERT_TRUE(g_kvDelegatePtr->Put(key, value) == OK);
+    ASSERT_TRUE(g_kvDelegatePtr->Put(key1, value) == OK);
+    ASSERT_TRUE(g_kvDelegatePtr->Put(key2, value) == OK);
+    ASSERT_TRUE(g_kvDelegatePtr->Put(key3, value) == OK);
+    ASSERT_TRUE(g_kvDelegatePtr->Put(key4, value) == OK);
+    /**
+     * @tc.steps: step3. device offline and close db Concurrently
+     * @tc.expected: step3. interface should return OK.
+     */
+    std::thread thread1([]() {
+        if (g_kvDelegatePtr != nullptr) {
+            g_mgr.CloseKvStore(g_kvDelegatePtr);
+            g_kvDelegatePtr = nullptr;
+        }
+    });
+    std::thread thread2([]() {
+        g_deviceB->Offline();
+    });
+    thread1.join();
+    thread2.join();
+    std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME));
+    ASSERT_TRUE(g_mgr.DeleteKvStore(STORE_ID) == OK);
+}
+
+/**
+  * @tc.name: DeviceOfflineSyncTask002
+  * @tc.desc: Test sync task when autoSync and close db Concurrently
+  * @tc.type: FUNC
+  * @tc.require:
+  * @tc.author: zhuwentao
+  */
+HWTEST_F(DistributedDBSingleVerP2PSyncTest, DeviceOfflineSyncTask002, TestSize.Level3)
+{
+    DBStatus status = OK;
+    g_deviceC->Offline();
+
+    /**
+     * @tc.steps: step1. deviceA put {k1, v1}
+     */
+    Key key = {'1'};
+    Value value = {'1'};
+    ASSERT_TRUE(g_kvDelegatePtr->Put(key, value) == OK);
+
+    /**
+     * @tc.steps: step2. deviceA set auto sync and put some key/value
+     * @tc.expected: step2. interface should return OK.
+     */
+    bool autoSync = true;
+    PragmaData data = static_cast<PragmaData>(&autoSync);
+    status = g_kvDelegatePtr->Pragma(AUTO_SYNC, data);
+    ASSERT_EQ(status, OK);
+    std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME * 2));
+
+    Key key1 = {'2'};
+    Key key2 = {'3'};
+    Key key3 = {'4'};
+    ASSERT_TRUE(g_kvDelegatePtr->Put(key1, value) == OK);
+    ASSERT_TRUE(g_kvDelegatePtr->Put(key2, value) == OK);
+    ASSERT_TRUE(g_kvDelegatePtr->Put(key3, value) == OK);
+    /**
+     * @tc.steps: step3. close db
+     * @tc.expected: step3. interface should return OK.
+     */
+    if (g_kvDelegatePtr != nullptr) {
+        g_mgr.CloseKvStore(g_kvDelegatePtr);
+        g_kvDelegatePtr = nullptr;
+    }
+    ASSERT_TRUE(g_mgr.DeleteKvStore(STORE_ID) == OK);
+}
+
+/**
+  * @tc.name: RebuildSync001
+  * @tc.desc: rebuild db and sync again
+  * @tc.type: FUNC
+  * @tc.require:
+  * @tc.author: zhuwentao
+  */
+HWTEST_F(DistributedDBSingleVerP2PSyncTest, RebuildSync001, TestSize.Level3)
+{
+    ASSERT_TRUE(g_kvDelegatePtr != nullptr);
+    /**
+     * @tc.steps: step1. sync deviceB data to A and check data
+     * * @tc.expected: step1. interface return ok
+    */
+    Key key1 = {'1'};
+    Key key2 = {'2'};
+    Value value = {'1'};
+	Timestamp currentTime;
+    (void)OS::GetCurrentSysTimeInMicrosecond(currentTime);
+    EXPECT_EQ(g_deviceB->PutData(key1, value, currentTime, 0), E_OK);
+    (void)OS::GetCurrentSysTimeInMicrosecond(currentTime);
+    EXPECT_EQ(g_deviceB->PutData(key2, value, currentTime, 0), E_OK);
+    EXPECT_EQ(g_deviceB->Sync(DistributedDB::SYNC_MODE_PUSH_ONLY, true), E_OK);
+
+    Value actualValue;
+    EXPECT_EQ(g_kvDelegatePtr->Get(key1, actualValue), OK);
+    EXPECT_EQ(actualValue, value);
+    actualValue.clear();
+    EXPECT_EQ(g_kvDelegatePtr->Get(key2, actualValue), OK);
+    EXPECT_EQ(actualValue, value);
+    /**
+     * @tc.steps: step2. delete db and rebuild
+     * * @tc.expected: step2. interface return ok
+    */
+    if (g_kvDelegatePtr != nullptr) {
+        g_mgr.CloseKvStore(g_kvDelegatePtr);
+        g_kvDelegatePtr = nullptr;
+    }
+    ASSERT_TRUE(g_mgr.DeleteKvStore(STORE_ID) == OK);
+    KvStoreNbDelegate::Option option;
+    g_mgr.GetKvStore(STORE_ID, option, g_kvDelegateCallback);
+    ASSERT_TRUE(g_kvDelegateStatus == OK);
+    ASSERT_TRUE(g_kvDelegatePtr != nullptr);
+    /**
+     * @tc.steps: step3. sync to device A again
+     * * @tc.expected: step3. sync ok
+    */
+    value = {'2'};
+    (void)OS::GetCurrentSysTimeInMicrosecond(currentTime);
+    EXPECT_EQ(g_deviceB->PutData(key1, value, currentTime, 0), E_OK);
+    EXPECT_EQ(g_deviceB->Sync(DistributedDB::SYNC_MODE_PUSH_ONLY, true), E_OK);
+    /**
+     * @tc.steps: step4. check data in device A
+     * * @tc.expected: step4. check ok
+    */
+    actualValue.clear();
+    EXPECT_EQ(g_kvDelegatePtr->Get(key1, actualValue), OK);
+    EXPECT_EQ(actualValue, value);
+}
+
+/**
+  * @tc.name: RebuildSync002
+  * @tc.desc: test clear remote data when receive data
+  * @tc.type: FUNC
+  * @tc.require: AR000D487B
+  * @tc.author: zhuwentao
+  */
+HWTEST_F(DistributedDBSingleVerP2PSyncTest, RebuildSync002, TestSize.Level1)
+{
+    ASSERT_TRUE(g_kvDelegatePtr != nullptr);
+    std::vector<std::string> devices;
+    devices.push_back(g_deviceB->GetDeviceId());
+    /**
+     * @tc.steps: step1. device A SET_WIPE_POLICY
+     * * @tc.expected: step1. interface return ok
+    */
+    int pragmaData = 2; // 2 means enable
+    PragmaData input = static_cast<PragmaData>(&pragmaData);
+    EXPECT_TRUE(g_kvDelegatePtr->Pragma(SET_WIPE_POLICY, input) == OK);
+    /**
+     * @tc.steps: step2. sync deviceB data to A and check data
+     * * @tc.expected: step2. interface return ok
+    */
+    Key key1 = {'1'};
+    Key key2 = {'2'};
+    Key key3 = {'3'};
+    Key key4 = {'4'};
+    Value value = {'1'};
+	Timestamp currentTime;
+    (void)OS::GetCurrentSysTimeInMicrosecond(currentTime);
+    EXPECT_EQ(g_deviceB->PutData(key1, value, currentTime, 0), E_OK);
+    (void)OS::GetCurrentSysTimeInMicrosecond(currentTime);
+    EXPECT_EQ(g_deviceB->PutData(key2, value, currentTime, 0), E_OK);
+    EXPECT_EQ(g_kvDelegatePtr->Put(key3, value), OK);
+    /**
+     * @tc.steps: step3. deviceA call pull sync
+     * @tc.expected: step3. sync should return OK.
+     */
+    std::map<std::string, DBStatus> result;
+    ASSERT_TRUE(g_tool.SyncTest(g_kvDelegatePtr, devices, SYNC_MODE_PUSH_PULL, result) == OK);
+
+    /**
+     * @tc.expected: step4. onComplete should be called, check data
+     */
+    ASSERT_TRUE(result.size() == devices.size());
+    for (const auto &pair : result) {
+        EXPECT_TRUE(pair.second == OK);
+    }
+    Value actualValue;
+    EXPECT_EQ(g_kvDelegatePtr->Get(key1, actualValue), OK);
+    EXPECT_EQ(actualValue, value);
+    EXPECT_EQ(g_kvDelegatePtr->Get(key2, actualValue), OK);
+    EXPECT_EQ(actualValue, value);
+    /**
+     * @tc.steps: step5. device B rebuild and put some data
+     * * @tc.expected: step5. rebuild ok
+    */
+    if (g_deviceB != nullptr) {
+        delete g_deviceB;
+        g_deviceB = nullptr;
+    }
+	g_deviceB = new (std::nothrow) KvVirtualDevice(DEVICE_B);
+    ASSERT_TRUE(g_deviceB != nullptr);
+    VirtualSingleVerSyncDBInterface *syncInterfaceB = new (std::nothrow) VirtualSingleVerSyncDBInterface();
+    ASSERT_TRUE(syncInterfaceB != nullptr);
+    ASSERT_EQ(g_deviceB->Initialize(g_communicatorAggregator, syncInterfaceB), E_OK);
+    (void)OS::GetCurrentSysTimeInMicrosecond(currentTime);
+    EXPECT_EQ(g_deviceB->PutData(key3, value, currentTime, 0), E_OK);
+    (void)OS::GetCurrentSysTimeInMicrosecond(currentTime);
+    EXPECT_EQ(g_deviceB->PutData(key4, value, currentTime, 0), E_OK);
+    /**
+     * @tc.steps: step6. sync to device A again and check data
+     * * @tc.expected: step6. sync ok
+    */
+    EXPECT_EQ(g_deviceB->Sync(DistributedDB::SYNC_MODE_PUSH_ONLY, true), E_OK);
+    EXPECT_EQ(g_kvDelegatePtr->Get(key3, actualValue), OK);
+    EXPECT_EQ(actualValue, value);
+    EXPECT_EQ(g_kvDelegatePtr->Get(key4, actualValue), OK);
+    EXPECT_EQ(actualValue, value);
+    EXPECT_EQ(g_kvDelegatePtr->Get(key1, actualValue), NOT_FOUND);
+    EXPECT_EQ(g_kvDelegatePtr->Get(key2, actualValue), NOT_FOUND);
+}
+
+/**
+  * @tc.name: RebuildSync003
+  * @tc.desc: test clear history data when receive ack
+  * @tc.type: FUNC
+  * @tc.require: AR000D487B
+  * @tc.author: zhuwentao
+  */
+HWTEST_F(DistributedDBSingleVerP2PSyncTest, RebuildSync003, TestSize.Level1)
+{
+    ASSERT_TRUE(g_kvDelegatePtr != nullptr);
+    /**
+     * @tc.steps: step1. sync deviceB data to A and check data
+     * * @tc.expected: step1. interface return ok
+    */
+    Key key1 = {'1'};
+    Key key2 = {'2'};
+    Key key3 = {'3'};
+    Key key4 = {'4'};
+    Value value = {'1'};
+    EXPECT_EQ(g_deviceB->PutData(key1, value, 1u, 0), E_OK); // 1: timestamp
+    EXPECT_EQ(g_deviceB->PutData(key2, value, 2u, 0), E_OK); // 2: timestamp
+    EXPECT_EQ(g_kvDelegatePtr->Put(key3, value), OK);
+    EXPECT_EQ(g_deviceB->Sync(DistributedDB::SYNC_MODE_PUSH_PULL, true), E_OK);
+    Value actualValue;
+    EXPECT_EQ(g_kvDelegatePtr->Get(key1, actualValue), OK);
+    EXPECT_EQ(actualValue, value);
+    EXPECT_EQ(g_kvDelegatePtr->Get(key2, actualValue), OK);
+    EXPECT_EQ(actualValue, value);
+    VirtualDataItem item;
+    EXPECT_EQ(g_deviceB->GetData(key3, item), E_OK);
+    EXPECT_EQ(item.value, value);
+    /**
+     * @tc.steps: step2. device B sync to device A,but make it failed
+     * * @tc.expected: step2. interface return ok
+    */
+    EXPECT_EQ(g_deviceB->PutData(key4, value, 3u, 0), E_OK); // 3: timestamp
+    g_communicatorAggregator->SetDropMessageTypeByDevice(DEVICE_A, DATA_SYNC_MESSAGE);
+    EXPECT_EQ(g_deviceB->Sync(DistributedDB::SYNC_MODE_PUSH_ONLY, true), E_OK);
+    /**
+     * @tc.steps: step3. device B set delay send time
+     * * @tc.expected: step3. interface return ok
+    */
+    std::set<std::string> delayDevice = {DEVICE_B};
+    g_communicatorAggregator->SetSendDelayInfo(3000u, DATA_SYNC_MESSAGE, 1u, 0u, delayDevice);// delay 3000ms one time
+    /**
+     * @tc.steps: step4. device A rebuilt, device B push data to A and set clear remote data mark into context after 1s
+     * * @tc.expected: step4. interface return ok
+    */
+    std::thread thread1([]() {
+        std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // wait 1s
+        g_deviceB->SetClearRemoteStaleData(true);
+        if (g_kvDelegatePtr != nullptr) {
+            g_mgr.CloseKvStore(g_kvDelegatePtr);
+            g_kvDelegatePtr = nullptr;
+        }
+        ASSERT_TRUE(g_mgr.DeleteKvStore(STORE_ID) == OK);
+        KvStoreNbDelegate::Option option;
+        g_mgr.GetKvStore(STORE_ID, option, g_kvDelegateCallback);
+        ASSERT_TRUE(g_kvDelegateStatus == OK);
+        ASSERT_TRUE(g_kvDelegatePtr != nullptr);
+        std::map<std::string, DBStatus> result;
+        std::vector<std::string> devices = {g_deviceB->GetDeviceId()};
+        g_communicatorAggregator->SetDropMessageTypeByDevice(DEVICE_B, DATA_SYNC_MESSAGE);
+        ASSERT_TRUE(g_tool.SyncTest(g_kvDelegatePtr, devices, SYNC_MODE_PUSH_ONLY, result) == OK);
+    });
+    /**
+     * @tc.steps: step5. device B sync to A, make it clear history data and check data
+     * * @tc.expected: step5. interface return ok
+    */
+    EXPECT_EQ(g_deviceB->Sync(DistributedDB::SYNC_MODE_PUSH_ONLY, true), E_OK);
+    thread1.join();
+    EXPECT_EQ(g_deviceB->GetData(key3, item), -E_NOT_FOUND);
+    EXPECT_EQ(g_kvDelegatePtr->Get(key1, actualValue), OK);
+    EXPECT_EQ(actualValue, value);
+    EXPECT_EQ(g_kvDelegatePtr->Get(key2, actualValue), OK);
+    EXPECT_EQ(actualValue, value);
+    g_communicatorAggregator->ResetSendDelayInfo();
+}
+
+/**
+  * @tc.name: GetSyncDataFail001
+  * @tc.desc: test get sync data failed when sync
+  * @tc.type: FUNC
+  * @tc.require: AR000D487B
+  * @tc.author: zhuwentao
+  */
+ HWTEST_F(DistributedDBSingleVerP2PSyncTest, GetSyncDataFail001, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. device B set get data errCode control and put some data
+     * * @tc.expected: step1. interface return ok
+    */
+    g_deviceB->SetGetDataErrCode(1, -E_BUSY, true);
+    Key key1 = {'1'};
+    Value value = {'1'};
+    EXPECT_EQ(g_deviceB->PutData(key1, value, 1u, 0), E_OK); // 1: timestamp
+    /**
+     * @tc.steps: step2. device B sync to device A and check data
+     * * @tc.expected: step2. interface return ok
+    */
+    EXPECT_EQ(g_deviceB->Sync(DistributedDB::SYNC_MODE_PUSH_ONLY, true), E_OK);
+    Value actualValue;
+    EXPECT_EQ(g_kvDelegatePtr->Get(key1, actualValue), NOT_FOUND);
+    g_deviceB->ResetDataControl();
+}
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/generic_virtual_device.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/generic_virtual_device.cpp
index f4c46fa1cfb7357da519371fb5a6422e4e0e260c..d0a0bff3ad9a1397423090988e1584eeed89027e 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/generic_virtual_device.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/generic_virtual_device.cpp
@@ -271,4 +271,12 @@ int GenericVirtualDevice::RemoteQuery(const std::string &device, const RemoteCon
     }
     return TransferDBErrno(errCode);
 }
+
+void GenericVirtualDevice::SetClearRemoteStaleData(bool isStaleData)
+{
+    if (context_ != nullptr) {
+        static_cast<SingleVerSyncTaskContext *>(context_)->EnableClearRemoteStaleData(isStaleData);
+        LOGD("set clear remote stale data mark");
+    }
+}
 } // DistributedDB
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/generic_virtual_device.h b/frameworks/libs/distributeddb/test/unittest/common/syncer/generic_virtual_device.h
index 8c226e440b8c33b2a7f7be208eafe1ea33180c98..04929441cbc09a737e0e7ac5f8e1e72e7ff8f638 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/generic_virtual_device.h
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/generic_virtual_device.h
@@ -20,6 +20,7 @@
 #include "ikvdb_sync_interface.h"
 #include "meta_data.h"
 #include "remote_executor.h"
+#include "single_ver_kv_sync_task_context.h"
 #include "subscribe_manager.h"
 #include "sync_task_context.h"
 #include "store_types.h"
@@ -45,6 +46,7 @@ public:
     virtual int Sync(SyncMode mode, const Query &query, const SyncOperation::UserCallback &callBack, bool wait);
     virtual int RemoteQuery(const std::string &device, const RemoteCondition &condition,
         uint64_t timeout, std::shared_ptr<ResultSet> &result);
+    void SetClearRemoteStaleData(bool isStaleData);
 protected:
     ICommunicator *communicateHandle_;
     VirtualCommunicatorAggregator *communicatorAggregator_;
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/kv_virtual_device.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/kv_virtual_device.cpp
index b272d6e19b46e09045f23742ffb978ff3ee3d050..ac691252f403288758dfbbdb7e1760d3d28baea3 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/kv_virtual_device.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/kv_virtual_device.cpp
@@ -81,6 +81,18 @@ void KvVirtualDevice::DelayGetSyncData(uint64_t milliDelayTime)
     syncInterface->DelayGetSyncData(milliDelayTime);
 }
 
+void KvVirtualDevice::SetGetDataErrCode(int whichTime, int errCode, bool isGetDataControl)
+{
+    VirtualSingleVerSyncDBInterface *syncInterface = static_cast<VirtualSingleVerSyncDBInterface *>(storage_);
+    syncInterface->SetGetDataErrCode(whichTime, errCode, isGetDataControl);
+}
+
+void KvVirtualDevice::ResetDataControl()
+{
+    VirtualSingleVerSyncDBInterface *syncInterface = static_cast<VirtualSingleVerSyncDBInterface *>(storage_);
+    syncInterface->ResetDataControl();
+}
+
 int KvVirtualDevice::Subscribe(QuerySyncObject query, bool wait, int id)
 {
     auto operation = new (std::nothrow) SyncOperation(id, {remoteDeviceId_}, SUBSCRIBE_QUERY, nullptr, wait);
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/kv_virtual_device.h b/frameworks/libs/distributeddb/test/unittest/common/syncer/kv_virtual_device.h
index b95e5402958ffedd3eb1d88fb4b1ea0ec0236025..b905510d5126e732773254c605db80724237c051 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/kv_virtual_device.h
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/kv_virtual_device.h
@@ -34,6 +34,8 @@ public:
     int Commit();
     void SetSaveDataDelayTime(uint64_t milliDelayTime);
     void DelayGetSyncData(uint64_t milliDelayTime);
+    void SetGetDataErrCode(int whichTime, int errCode, bool isGetDataControl);
+    void ResetDataControl();
 
     int Subscribe(QuerySyncObject query, bool wait, int id);
     int UnSubscribe(QuerySyncObject query, bool wait, int id);
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_auto_launch.h b/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_auto_launch.h
index af89a85aea477859a44b8ae9387d478ed6b1cebe..6236d010a937b51cfb8c05a785f0d9ec8aa14dc5 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_auto_launch.h
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_auto_launch.h
@@ -22,7 +22,7 @@
 namespace DistributedDB {
 class MockAutoLaunch : public AutoLaunch {
 public:
-    void SetAutoLaunchItem(const std::string &identify, const std::string &userId, AutoLaunchItem &item)
+    void SetAutoLaunchItem(const std::string &identify, const std::string &userId, const AutoLaunchItem &item)
     {
         std::lock_guard<std::mutex> autoLock(extLock_);
         extItemMap_[identify][userId] = item;
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_single_ver_kv_syncer.h b/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_single_ver_kv_syncer.h
new file mode 100644
index 0000000000000000000000000000000000000000..65bc95bca6d6b695e052ea053ae387ad8c60c9e3
--- /dev/null
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_single_ver_kv_syncer.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef MOCK_SINGLE_VER_KV_SYNCER_H
+#define MOCK_SINGLE_VER_KV_SYNCER_H
+#include <gmock/gmock.h>
+#include "single_ver_kv_syncer.h"
+
+namespace DistributedDB {
+class MockSingleVerKVSyncer : public SingleVerKVSyncer {
+public:
+    void CallRecordTimeChangeOffset(void *changedOffset)
+    {
+        RecordTimeChangeOffset(changedOffset);
+    }
+};
+}
+#endif // MOCK_SINGLE_VER_KV_SYNCER_H
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_sync_task_context.h b/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_sync_task_context.h
index 81ebf2d2c82bebd8c449d9ae11595256a943d805..1bf3108764cdd45bcd138b54549aacaeddbc24a2 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_sync_task_context.h
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_sync_task_context.h
@@ -48,7 +48,7 @@ public:
 
     MOCK_CONST_METHOD0(GetRequestSessionId, uint32_t(void));
 
-    MOCK_CONST_METHOD1(GetSyncStrategy, SyncStrategy(QuerySyncObject &));
+    MOCK_CONST_METHOD1(GetSchemaSyncStatus, std::pair<bool, bool>(QuerySyncObject &));
 
     void CallCommErrHandlerFuncInner(int errCode, uint32_t sessionId)
     {
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/relational_virtual_device.h b/frameworks/libs/distributeddb/test/unittest/common/syncer/relational_virtual_device.h
index 9aed0bbf3988306eefc314a125fa7099b630db19..053855835686da92d917ba0ec317732d49ce7211 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/relational_virtual_device.h
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/relational_virtual_device.h
@@ -34,6 +34,16 @@ public:
     void SetTableInfo(const TableInfo &tableInfo);
     int Sync(SyncMode mode, bool wait) override;
     void EraseSyncData(const std::string &tableName);
+
+    template<typename T>
+    void PutDeviceData(const std::string &tableName, const std::vector<T> &data)
+    {
+        std::vector<VirtualRowData> dataList;
+        for (const auto &it : data) {
+            dataList.emplace_back(it());
+        }
+        this->PutData(tableName, dataList);
+    }
 };
 }
 #endif
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator.cpp
index d6a625f42b5446c5384824eb0e431532e87c3aaa..84361b0953a9fe8b6f6e40c600417049955df6b1 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator.cpp
@@ -87,12 +87,17 @@ int VirtualCommunicator::GetRemoteCommunicatorVersion(const std::string &deviceI
     return E_OK;
 }
 
-void VirtualCommunicator::CallbackOnMessage(const std::string &srcTarget, Message *inMsg) const
+void VirtualCommunicator::CallbackOnMessage(const std::string &srcTarget, Message *inMsg)
 {
     std::lock_guard<std::mutex> lock(onMessageLock_);
-    if (isEnable_ && onMessage_ && (srcTarget != deviceId_)) {
+    if (isEnable_ && onMessage_ && (srcTarget != deviceId_) && ((inMsg->GetMessageId() != dropMsgId_) ||
+        ((inMsg->GetMessageId() == dropMsgId_) && (dropMsgTimes_ == 0)))) {
         onMessage_(srcTarget, inMsg);
     } else {
+        LOGD("drop msg from dev=%s, localDev=%s", srcTarget.c_str(), deviceId_.c_str());
+        if (dropMsgTimes_ > 0) {
+            dropMsgTimes_--;
+        }
         delete inMsg;
         inMsg = nullptr;
     }
@@ -114,7 +119,7 @@ void VirtualCommunicator::CallbackOnConnect(const std::string &target, bool isCo
 
 uint32_t VirtualCommunicator::GetCommunicatorMtuSize() const
 {
-    return 5 * 1024 * 1024; // 5 * 1024 * 1024B
+    return mtuSize_;
 }
 
 uint32_t VirtualCommunicator::GetCommunicatorMtuSize(const std::string &target) const
@@ -122,6 +127,11 @@ uint32_t VirtualCommunicator::GetCommunicatorMtuSize(const std::string &target)
     return GetCommunicatorMtuSize();
 }
 
+void VirtualCommunicator::SetCommunicatorMtuSize(uint32_t mtuSize)
+{
+    mtuSize_ = mtuSize;
+}
+
 uint32_t VirtualCommunicator::GetTimeout() const
 {
     return timeout_;
@@ -201,7 +211,7 @@ int VirtualCommunicator::TranslateMsg(const Message *inMsg, Message *&outMsg)
 {
     int errCode = E_OK;
     std::shared_ptr<ExtendHeaderHandle> extendHandle = nullptr;
-    auto buffer = ProtocolProto::ToSerialBuffer(inMsg, errCode, extendHandle);
+    auto buffer = ProtocolProto::ToSerialBuffer(inMsg, extendHandle, false, errCode);
     if (errCode != E_OK) {
         return errCode;
     }
@@ -211,4 +221,13 @@ int VirtualCommunicator::TranslateMsg(const Message *inMsg, Message *&outMsg)
     buffer = nullptr;
     return errCode;
 }
+
+void VirtualCommunicator::SetDropMessageTypeByDevice(MessageId msgid, uint32_t dropTimes)
+{
+    dropMsgId_ = msgid;
+    dropMsgTimes_ = dropTimes;
+    if (msgid == UNKNOW_MESSAGE) {
+        dropMsgTimes_ = 0;
+    }
+}
 } // namespace DistributedDB
\ No newline at end of file
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator.h b/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator.h
index f202d1dad60b8c803240c504da624f7c6cbc74a6..e79af68791f79bb8a0143da14c4ccc6eaf94c597 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator.h
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator.h
@@ -27,6 +27,7 @@
 #include "icommunicator.h"
 #include "ref_object.h"
 #include "serial_buffer.h"
+#include "sync_types.h"
 
 namespace DistributedDB {
 class VirtualCommunicatorAggregator;
@@ -46,6 +47,7 @@ public:
 
     uint32_t GetCommunicatorMtuSize() const override;
     uint32_t GetCommunicatorMtuSize(const std::string &target) const override;
+    void SetCommunicatorMtuSize(uint32_t mtuSize);
 
     uint32_t GetTimeout() const override;
     uint32_t GetTimeout(const std::string &target) const override;
@@ -59,7 +61,7 @@ public:
 
     int GetRemoteCommunicatorVersion(const std::string &deviceId, uint16_t &version) const override;
 
-    void CallbackOnMessage(const std::string &srcTarget, Message *inMsg) const;
+    void CallbackOnMessage(const std::string &srcTarget, Message *inMsg);
 
     void CallbackOnConnect(const std::string &target, bool isConnect) const;
 
@@ -77,6 +79,8 @@ public:
 
     bool IsDeviceOnline(const std::string &device) const override;
 
+    void SetDropMessageTypeByDevice(MessageId msgid, uint32_t dropTimes = 1);
+
 private:
     int TimeSync();
     int DataSync();
@@ -101,6 +105,9 @@ private:
     VirtualCommunicatorAggregator *communicatorAggregator_;
 
     uint32_t timeout_ = 5 * 1000; // 5 * 1000ms
+    MessageId dropMsgId_ = MessageId::UNKNOW_MESSAGE;
+    uint32_t dropMsgTimes_ = 0;
+    uint32_t mtuSize_ = 5 * 1024 * 1024; // 5 * 1024 * 1024B
 };
 } // namespace DistributedDB
 
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.cpp
index 7e40b97c0bd716882010664fa9cc54e11c910ebb..0bc301134eae2c8635df496a1887250195842948 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.cpp
@@ -189,13 +189,29 @@ void VirtualCommunicatorAggregator::DispatchMessage(const std::string &srcTarget
         msg->SetTarget(srcTarget);
         RefObject::IncObjRef(communicator);
         auto onDispatch = onDispatch_;
-        std::thread thread([communicator, srcTarget, dstTarget, msg, onDispatch]() {
+        bool isNeedDelay = ((sendDelayTime_ > 0) && (delayTimes_ > 0) && (msg->GetMessageId() == delayMessageId_) &&
+            (delayDevices_.count(dstTarget) > 0) && (skipTimes_ == 0));
+        uint32_t sendDelayTime = sendDelayTime_;
+        std::thread thread([communicator, srcTarget, dstTarget, msg, isNeedDelay, sendDelayTime, onDispatch]() {
+            if (isNeedDelay) {
+                LOGD("begin to delay message for %" PRIu32 "ms dstTarget %s", sendDelayTime, dstTarget.c_str());
+                std::this_thread::sleep_for(std::chrono::milliseconds(sendDelayTime));
+            }
             if (onDispatch) {
                 onDispatch(dstTarget, msg);
             }
             communicator->CallbackOnMessage(srcTarget, msg);
             RefObject::DecObjRef(communicator);
         });
+        if ((skipTimes_ == 0) && delayTimes_ > 0 && (inMsg->GetMessageId() == delayMessageId_) &&
+            (delayDevices_.count(dstTarget) > 0)) {
+            delayTimes_--;
+        }
+        LOGI("before skipTimes_=%u", skipTimes_);
+        if (skipTimes_ > 0 && (inMsg->GetMessageId() == delayMessageId_) && (delayDevices_.count(dstTarget) > 0)) {
+            skipTimes_--;
+        }
+        LOGI("skipTimes_=%u", skipTimes_);
         thread.detach();
         CallSendEnd(E_OK, onEnd);
     } else {
@@ -258,4 +274,40 @@ void VirtualCommunicatorAggregator::SetTimeout(const std::string &deviceId, uint
         communicators_[deviceId]->SetTimeout(timeout);
     }
 }
+
+void VirtualCommunicatorAggregator::SetDropMessageTypeByDevice(const std::string &deviceId, MessageId msgid,
+    uint32_t dropTimes)
+{
+    std::lock_guard<std::mutex> lock(communicatorsLock_);
+    if (communicators_.find(deviceId) != communicators_.end()) {
+        communicators_[deviceId]->SetDropMessageTypeByDevice(msgid, dropTimes);
+    }
+}
+
+void VirtualCommunicatorAggregator::SetDeviceMtuSize(const std::string &deviceId, uint32_t mtuSize)
+{
+    std::lock_guard<std::mutex> lock(communicatorsLock_);
+    if (communicators_.find(deviceId) != communicators_.end()) {
+        communicators_[deviceId]->SetCommunicatorMtuSize(mtuSize);
+    }
+}
+
+void VirtualCommunicatorAggregator::SetSendDelayInfo(uint32_t sendDelayTime, uint32_t delayMessageId,
+    uint32_t delayTimes, uint32_t skipTimes, std::set<std::string> &delayDevices)
+{
+    sendDelayTime_ = sendDelayTime;
+    delayMessageId_ = delayMessageId;
+    delayTimes_ = delayTimes;
+    delayDevices_ = delayDevices;
+    skipTimes_ = skipTimes;
+}
+
+void VirtualCommunicatorAggregator::ResetSendDelayInfo()
+{
+    sendDelayTime_ = 0;
+    delayMessageId_ = INVALID_MESSAGE_ID;
+    delayTimes_ = 0;
+    skipTimes_ = 0;
+    delayDevices_.clear();
+}
 } // namespace DistributedDB
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.h b/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.h
index c1848a2cac9aae93f46d01890b30bc1c9742a384..5c5a0d5054213d961c1386e16ce4451b497229ea 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.h
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.h
@@ -17,6 +17,7 @@
 #define VIRTUAL_ICOMMUNICATORAGGREGATOR_H
 
 #include <cstdint>
+#include <set>
 
 #include "icommunicator_aggregator.h"
 #include "virtual_communicator.h"
@@ -72,6 +73,14 @@ public:
 
     void SetTimeout(const std::string &deviceId, uint32_t timeout);
 
+    void SetDropMessageTypeByDevice(const std::string &deviceId, MessageId msgid, uint32_t dropTimes = 1);
+
+    void SetDeviceMtuSize(const std::string &deviceId, uint32_t mtuSize);
+
+    void SetSendDelayInfo(uint32_t sendDelayTime, uint32_t DelayMessageId, uint32_t delayTimes, uint32_t skipTimes,
+        std::set<std::string> &delayDevices);
+    void ResetSendDelayInfo();
+
     ~VirtualCommunicatorAggregator() {};
     VirtualCommunicatorAggregator() {};
 
@@ -89,6 +98,12 @@ private:
     OnConnectCallback onConnect_;
     std::function<void(const std::string &target, Message *inMsg)> onDispatch_;
     std::string userId_;
+
+    uint32_t sendDelayTime_ = 0;
+    uint32_t delayMessageId_ = INVALID_MESSAGE_ID;
+    uint32_t delayTimes_ = 0; // ms
+    uint32_t skipTimes_ = 0;
+    std::set<std::string> delayDevices_;
 };
 } // namespace DistributedDB
 
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_relational_ver_sync_db_interface.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_relational_ver_sync_db_interface.cpp
index afda4562fedb4ec727905a5487b2df2244db2af5..ee6e958cf138aafa5b0ac38250552d6b0e293f78 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_relational_ver_sync_db_interface.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_relational_ver_sync_db_interface.cpp
@@ -15,6 +15,7 @@
 #ifdef RELATIONAL_STORE
 #include "db_common.h"
 #include "generic_single_ver_kv_entry.h"
+#include "platform_specific.h"
 #include "relational_remote_query_continue_token.h"
 #include "runtime_context.h"
 #include "virtual_relational_ver_sync_db_interface.h"
@@ -25,7 +26,7 @@ namespace {
     int GetEntriesFromItems(std::vector<SingleVerKvEntry *> &entries, const std::vector<DataItem> &dataItems)
     {
         int errCode = E_OK;
-        for (auto &item : dataItems) {
+        for (const auto &item : dataItems) {
             auto entry = new (std::nothrow) GenericSingleVerKvEntry();
             if (entry == nullptr) {
                 LOGE("Create entry failed.");
@@ -62,6 +63,12 @@ namespace {
     }
 }
 
+VirtualRelationalVerSyncDBInterface::VirtualRelationalVerSyncDBInterface()
+{
+    (void)OS::GetCurrentSysTimeInMicrosecond(dbCreateTime_);
+    LOGD("virtual device init db createTime");
+}
+
 int VirtualRelationalVerSyncDBInterface::PutSyncDataWithQuery(const QueryObject &object,
     const std::vector<SingleVerKvEntry *> &entries, const std::string &deviceName)
 {
@@ -129,7 +136,7 @@ int VirtualRelationalVerSyncDBInterface::GetSyncData(QueryObject &query,
     for (const auto &[hashKey, virtualData] : localData_[query.GetTableName()]) {
         if (virtualData.logInfo.timestamp < timeRange.beginTime ||
             virtualData.logInfo.timestamp >= timeRange.endTime) {
-            LOGD("ignore hashkey %s", hashKey.c_str());
+            LOGD("ignore hashkey %s", DBCommon::TransferStringToHex(hashKey));
             continue;
         }
         RowDataWithLog rowData;
@@ -163,6 +170,7 @@ void VirtualRelationalVerSyncDBInterface::SetSchemaInfo(const RelationalSchemaOb
 
 int VirtualRelationalVerSyncDBInterface::GetDatabaseCreateTimestamp(Timestamp &outTime) const
 {
+    outTime = dbCreateTime_;
     return E_OK;
 }
 
@@ -274,7 +282,7 @@ int VirtualRelationalVerSyncDBInterface::DeleteMetaDataByPrefixKey(const Key &ke
 
 int VirtualRelationalVerSyncDBInterface::GetAllMetaKeys(std::vector<Key> &keys) const
 {
-    for (auto &iter : metadata_) {
+    for (const auto &iter : metadata_) {
         keys.push_back(iter.first);
     }
     LOGD("GetAllMetaKeys size %zu", keys.size());
@@ -364,7 +372,7 @@ void VirtualRelationalVerSyncDBInterface::SetPermitCreateDistributedTable(bool p
     permitCreateDistributedTable_ = permitCreateDistributedTable;
 }
 
-void ObjectData::PutDataValue(const std::string &fieldName, const DataValue &value)
+void ObjectData::PutDataValue(const std::string &fieldName, const DataValue &value) const
 {
     fieldData[fieldName] = value;
 }
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_relational_ver_sync_db_interface.h b/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_relational_ver_sync_db_interface.h
index e42cba6be4faa482cd9010aea750c69a917cca4c..07f9a87c9beb19397b91e763e96cda7f4f5a04c5 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_relational_ver_sync_db_interface.h
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_relational_ver_sync_db_interface.h
@@ -24,7 +24,7 @@
 namespace DistributedDB {
 struct ObjectData {
 public:
-    void PutDataValue(const std::string &fieldName, const DataValue &value);
+    void PutDataValue(const std::string &fieldName, const DataValue &value) const;
     int GetDataValue(const std::string &fieldName, DataValue &value) const;
 private:
     mutable std::map<std::string, DataValue> fieldData;
@@ -37,7 +37,7 @@ struct VirtualRowData {
 
 class VirtualRelationalVerSyncDBInterface : public RelationalDBSyncInterface {
 public:
-    VirtualRelationalVerSyncDBInterface() = default;
+    VirtualRelationalVerSyncDBInterface();
     ~VirtualRelationalVerSyncDBInterface() override = default;
 
     int PutSyncDataWithQuery(const QueryObject &query, const std::vector<SingleVerKvEntry *> &entries,
@@ -133,6 +133,7 @@ private:
     RelationalDBProperties rdbProperties_;
     SecurityOption secOption_;
     bool permitCreateDistributedTable_ = true;
+    uint64_t dbCreateTime_;
 };
 }
 #endif
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_single_ver_sync_db_Interface.cpp b/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_single_ver_sync_db_Interface.cpp
index b826d4845cbf454d11337cf3b7b176c62ee97cc6..1c30be15e558a375d713c541b56b15dfd43af247 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_single_ver_sync_db_Interface.cpp
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_single_ver_sync_db_Interface.cpp
@@ -23,6 +23,7 @@
 #include "generic_single_ver_kv_entry.h"
 #include "intercepted_data_impl.h"
 #include "log_print.h"
+#include "platform_specific.h"
 #include "query_object.h"
 #include "securec.h"
 
@@ -31,7 +32,7 @@ namespace {
     int GetEntriesFromItems(std::vector<SingleVerKvEntry *> &entries, const std::vector<VirtualDataItem> &dataItems)
     {
         int errCode = E_OK;
-        for (auto &item : dataItems) {
+        for (const auto &item : dataItems) {
             auto entry = new (std::nothrow) GenericSingleVerKvEntry();
             if (entry == nullptr) {
                 LOGE("Create entry failed.");
@@ -57,6 +58,13 @@ namespace {
         return errCode;
     }
 }
+
+VirtualSingleVerSyncDBInterface::VirtualSingleVerSyncDBInterface()
+{
+    (void)OS::GetCurrentSysTimeInMicrosecond(dbCreateTime_);
+    LOGD("virtual device init db createTime");
+}
+
 int VirtualSingleVerSyncDBInterface::GetInterfaceType() const
 {
     return SYNC_SVD;
@@ -173,6 +181,15 @@ int VirtualSingleVerSyncDBInterface::RemoveDeviceData(const std::string &deviceN
 {
     std::lock_guard<std::mutex> autoLock(deviceDataLock_);
     deviceData_.erase(deviceName);
+    uint32_t devId = 0;
+    if (deviceMapping_.find(deviceName) != deviceMapping_.end()) {
+        devId = deviceMapping_[deviceName];
+    }
+    for (auto &item : dbData_) {
+        if (item.deviceId_ == devId && devId > 0) {
+            item.flag = VirtualDataItem::DELETE_FLAG;
+        }
+    }
     LOGD("RemoveDeviceData FINISH");
     return E_OK;
 }
@@ -182,6 +199,9 @@ int VirtualSingleVerSyncDBInterface::GetSyncData(const Key &key, VirtualDataItem
     auto iter = std::find_if(dbData_.begin(), dbData_.end(),
         [key](const VirtualDataItem& item) { return item.key == key; });
     if (iter != dbData_.end()) {
+        if (iter->flag == VirtualDataItem::DELETE_FLAG) {
+            return -E_NOT_FOUND;
+        }
         dataItem.key = iter->key;
         dataItem.value = iter->value;
         dataItem.timestamp = iter->timestamp;
@@ -218,7 +238,13 @@ int VirtualSingleVerSyncDBInterface::GetSyncDataNext(std::vector<SingleVerKvEntr
 int VirtualSingleVerSyncDBInterface::GetSyncData(Timestamp begin, Timestamp end, uint32_t blockSize,
     std::vector<VirtualDataItem> &dataItems, ContinueToken &continueStmtToken) const
 {
-    std::this_thread::sleep_for(std::chrono::milliseconds(getDataDelayTime_));
+    if (getDataDelayTime_ > 0) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(getDataDelayTime_));
+    }
+    int errCode = DataControl();
+    if (errCode != E_OK) {
+        return errCode;
+    }
     for (const auto &data : dbData_) {
         if (data.isLocal) {
             if (data.writeTimestamp >= begin && data.writeTimestamp < end) {
@@ -248,6 +274,11 @@ int VirtualSingleVerSyncDBInterface::GetSyncDataNext(std::vector<VirtualDataItem
 int VirtualSingleVerSyncDBInterface::PutSyncData(std::vector<VirtualDataItem>& dataItems,
     const std::string &deviceName)
 {
+    if (dataItems.size() > 0 && deviceMapping_.find(deviceName) == deviceMapping_.end()) {
+        availableDeviceId_++;
+        deviceMapping_[deviceName] = availableDeviceId_;
+        LOGD("put deviceName=%s into device map", deviceName.c_str());
+    }
     for (auto iter = dataItems.begin(); iter != dataItems.end(); ++iter) {
         LOGD("PutSyncData");
         auto dbDataIter = std::find_if(dbData_.begin(), dbData_.end(),
@@ -262,6 +293,7 @@ int VirtualSingleVerSyncDBInterface::PutSyncData(std::vector<VirtualDataItem>& d
             dbDataIter->writeTimestamp = iter->writeTimestamp;
             dbDataIter->flag = iter->flag;
             dbDataIter->isLocal = false;
+            dbDataIter->deviceId_ = deviceMapping_[deviceName];
         } else {
             LOGI("PutSyncData, use remote data %" PRIu64, iter->timestamp);
             VirtualDataItem dataItem;
@@ -271,6 +303,7 @@ int VirtualSingleVerSyncDBInterface::PutSyncData(std::vector<VirtualDataItem>& d
             dataItem.writeTimestamp = iter->writeTimestamp;
             dataItem.flag = iter->flag;
             dataItem.isLocal = false;
+            dataItem.deviceId_ = deviceMapping_[deviceName];
             dbData_.push_back(dataItem);
         }
     }
@@ -312,6 +345,7 @@ void VirtualSingleVerSyncDBInterface::NotifyRemotePushFinished(const std::string
 
 int VirtualSingleVerSyncDBInterface::GetDatabaseCreateTimestamp(Timestamp &outTime) const
 {
+    outTime = dbCreateTime_;
     return E_OK;
 }
 
@@ -319,7 +353,13 @@ int VirtualSingleVerSyncDBInterface::GetSyncData(QueryObject &query, const SyncT
     const DataSizeSpecInfo &dataSizeInfo, ContinueToken &continueStmtToken,
     std::vector<SingleVerKvEntry *> &entries) const
 {
-    std::this_thread::sleep_for(std::chrono::milliseconds(getDataDelayTime_));
+    if (getDataDelayTime_ > 0) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(getDataDelayTime_));
+    }
+    int errCode = DataControl();
+    if (errCode != E_OK) {
+        return errCode;
+    }
     const auto &startKey = query.GetPrefixKey();
     Key endKey = startKey;
     endKey.resize(DBConstant::MAX_KEY_SIZE, UCHAR_MAX);
@@ -448,4 +488,34 @@ void VirtualSingleVerSyncDBInterface::DelayGetSyncData(uint32_t milliDelayTime)
 {
     getDataDelayTime_ = milliDelayTime;
 }
+
+void VirtualSingleVerSyncDBInterface::SetGetDataErrCode(int whichTime, int errCode, bool isGetDataControl)
+{
+    countDown_ = whichTime;
+    expectedErrCode_ = errCode;
+    isGetDataControl_ = isGetDataControl;
+}
+
+int VirtualSingleVerSyncDBInterface::DataControl() const
+{
+    static int getDataTimes = 0;
+    if (countDown_ == -1) { // init -1
+        getDataTimes = 0;
+    }
+    if (isGetDataControl_ && countDown_ > 0) {
+        getDataTimes++;
+    }
+    if (isGetDataControl_ && countDown_ == getDataTimes) {
+        LOGD("virtual device get data failed = %d", expectedErrCode_);
+        getDataTimes = 0;
+        return expectedErrCode_;
+    }
+    return E_OK;
+}
+
+void VirtualSingleVerSyncDBInterface::ResetDataControl()
+{
+    countDown_ = -1;
+    expectedErrCode_ = E_OK;
+}
 }  // namespace DistributedDB
diff --git a/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_single_ver_sync_db_Interface.h b/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_single_ver_sync_db_Interface.h
index efb16751af2dfc4f062bc44651edf7c4086ac33b..d938ab238d4ab379ed434919bb475d24bbc355d1 100644
--- a/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_single_ver_sync_db_Interface.h
+++ b/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_single_ver_sync_db_Interface.h
@@ -32,11 +32,13 @@ struct VirtualDataItem {
     Timestamp writeTimestamp = 0;
     uint64_t flag = 0;
     bool isLocal = true;
+    uint32_t deviceId_ = 0; // 0: means local
     static const uint64_t DELETE_FLAG = 0x01;
     static const uint64_t LOCAL_FLAG = 0x02;
 };
 class VirtualSingleVerSyncDBInterface : public SingleVerKvDBSyncInterface {
 public:
+    VirtualSingleVerSyncDBInterface();
     int GetInterfaceType() const override;
 
     void IncRefCount() override;
@@ -131,6 +133,9 @@ public:
     void SetDbProperties(KvDBProperties &kvDBProperties);
 
     void DelayGetSyncData(uint32_t milliDelayTime);
+
+    void SetGetDataErrCode(int whichTime, int errCode, bool isGetDataControl);
+    void ResetDataControl();
 private:
     int GetSyncData(Timestamp begin, Timestamp end, uint32_t blockSize, std::vector<VirtualDataItem>& dataItems,
         ContinueToken& continueStmtToken) const;
@@ -140,8 +145,12 @@ private:
 
     int PutSyncData(std::vector<VirtualDataItem>& dataItems, const std::string &deviceName);
 
+    int DataControl() const;
+
     mutable std::map<std::vector<uint8_t>, std::vector<uint8_t>> metadata_;
     std::vector<VirtualDataItem> dbData_;
+    std::map<std::string, uint32_t> deviceMapping_; // key: deviceName, value: deviceId
+    uint32_t availableDeviceId_ = 0;
     std::string schema_;
     SchemaObject schemaObj_;
     KvDBProperties properties_;
@@ -153,6 +162,11 @@ private:
     std::map<std::string, std::map<Key, Value>> deviceData_;
     std::vector<uint8_t> identifier_;
     uint64_t getDataDelayTime_ = 0;
+    uint64_t dbCreateTime_;
+
+    int countDown_ = -1;
+    int expectedErrCode_ = E_OK;
+    bool isGetDataControl_ = true; // control get data: true, control save data : false
 };
 }  // namespace DistributedDB