diff --git a/frameworks/cj/include/relational_store_impl_rdbstore.h b/frameworks/cj/include/relational_store_impl_rdbstore.h
index 7e05d9a179b79882b292819c17dd7db5c86b82e5..82e1c425c045085636487e7beaf117f21d75f720 100644
--- a/frameworks/cj/include/relational_store_impl_rdbstore.h
+++ b/frameworks/cj/include/relational_store_impl_rdbstore.h
@@ -122,7 +122,7 @@ public:
     void ExecuteSql(const char *sql, int32_t *errCode);
     int32_t CleanDirtyData(const char *tableName, uint64_t cursor);
     CArrSyncResult Sync(int32_t mode, RdbPredicatesImpl &predicates);
-    int32_t Update(ValuesBucket valuesBucket, RdbPredicatesImpl &predicates,
+    int32_t Update(ValuesBucket &valuesBucket, RdbPredicatesImpl &predicates,
         NativeRdb::ConflictResolution conflictResolution, int32_t *errCode);
     std::shared_ptr<NativeRdb::ResultSet> QuerySql(const char *sql, ValueType *bindArgs, int64_t size);
     void ExecuteSql(const char *sql, ValueType *bindArgs, int64_t bindArgsSize, int32_t *errCode);
@@ -153,7 +153,7 @@ public:
     ModifyTime GetModifyTime(char *cTable, char *cColumnName, CArrPRIKeyType &cPrimaryKeys, int32_t &errCode);
     int32_t GetRebuilt();
     int64_t InsertEx(const char *table, ValuesBucketEx valuesBucket, int32_t conflict, int32_t *errCode);
-    int32_t UpdateEx(ValuesBucketEx valuesBucket, RdbPredicatesImpl &predicates,
+    int32_t UpdateEx(ValuesBucketEx &valuesBucket, RdbPredicatesImpl &predicates,
         NativeRdb::ConflictResolution conflictResolution, int32_t *errCode);
     int32_t BatchInsertEx(int64_t &insertNum, const char *tableName, ValuesBucketEx *valuesBuckets, int64_t valuesSize);
     std::shared_ptr<NativeRdb::ResultSet> QuerySqlEx(const char *sql, ValueTypeEx *bindArgs, int64_t size);
diff --git a/frameworks/cj/src/relational_store_impl_rdbpredicatesproxy.cpp b/frameworks/cj/src/relational_store_impl_rdbpredicatesproxy.cpp
index a16988f623694d33aaa3216953fde7ce38e7ca6f..50cc92841ee95a0db617ed1d858b28049c54b737 100644
--- a/frameworks/cj/src/relational_store_impl_rdbpredicatesproxy.cpp
+++ b/frameworks/cj/src/relational_store_impl_rdbpredicatesproxy.cpp
@@ -18,452 +18,455 @@
 
 namespace OHOS {
 namespace Relational {
-    RdbPredicatesImpl::RdbPredicatesImpl(const char* tableName)
-    {
-        if (tableName == nullptr) {
-            return;
-        }
-        std::string str = tableName;
-        predicates_ = std::make_shared<NativeRdb::RdbPredicates>(str);
+RdbPredicatesImpl::RdbPredicatesImpl(const char *tableName)
+{
+    if (tableName == nullptr) {
+        return;
     }
+    std::string str = tableName;
+    predicates_ = std::make_shared<NativeRdb::RdbPredicates>(str);
+}
 
-    RdbPredicatesImpl::RdbPredicatesImpl(std::shared_ptr<NativeRdb::RdbPredicates> predicates)
-    {
-        predicates_ = predicates;
-    }
+RdbPredicatesImpl::RdbPredicatesImpl(std::shared_ptr<NativeRdb::RdbPredicates> predicates)
+{
+    predicates_ = predicates;
+}
 
-    OHOS::FFI::RuntimeType* RdbPredicatesImpl::GetClassType()
-    {
-        static OHOS::FFI::RuntimeType runtimeType =
-            OHOS::FFI::RuntimeType::Create<OHOS::FFI::FFIData>("RdbPredicatesImpl");
-        return &runtimeType;
-    }
+OHOS::FFI::RuntimeType *RdbPredicatesImpl::GetClassType()
+{
+    static OHOS::FFI::RuntimeType runtimeType =
+        OHOS::FFI::RuntimeType::Create<OHOS::FFI::FFIData>("RdbPredicatesImpl");
+    return &runtimeType;
+}
 
-    std::shared_ptr<NativeRdb::RdbPredicates> RdbPredicatesImpl::GetPredicates()
-    {
-        return predicates_;
-    }
+std::shared_ptr<NativeRdb::RdbPredicates> RdbPredicatesImpl::GetPredicates()
+{
+    return predicates_;
+}
 
-    void RdbPredicatesImpl::InDevices(const char** devicesArray, int64_t devicesSize)
-    {
-        std::vector<std::string> devices;
-        for (int64_t i = 0; i < devicesSize; i++) {
-            devices.push_back(devicesArray[i]);
+void RdbPredicatesImpl::InDevices(const char **devicesArray, int64_t devicesSize)
+{
+    std::vector<std::string> devices;
+    for (int64_t i = 0; i < devicesSize; i++) {
+        if (devicesArray[i] == nullptr) {
+            continue;
         }
-        if (predicates_ == nullptr) {
-            return;
-        }
-        predicates_->InDevices(devices);
+        devices.push_back(devicesArray[i]);
+    }
+    if (predicates_ == nullptr) {
+        return;
     }
+    predicates_->InDevices(devices);
+}
 
-    void RdbPredicatesImpl::InAllDevices()
-    {
-        if (predicates_ == nullptr) {
-            return;
-        }
-        predicates_->InAllDevices();
+void RdbPredicatesImpl::InAllDevices()
+{
+    if (predicates_ == nullptr) {
+        return;
     }
+    predicates_->InAllDevices();
+}
 
-    void RdbPredicatesImpl::BeginWrap()
-    {
-        if (predicates_ == nullptr) {
-            return;
-        }
-        predicates_->BeginWrap();
+void RdbPredicatesImpl::BeginWrap()
+{
+    if (predicates_ == nullptr) {
+        return;
     }
+    predicates_->BeginWrap();
+}
 
-    void RdbPredicatesImpl::EndWrap()
-    {
-        if (predicates_ == nullptr) {
-            return;
-        }
-        predicates_->EndWrap();
+void RdbPredicatesImpl::EndWrap()
+{
+    if (predicates_ == nullptr) {
+        return;
     }
+    predicates_->EndWrap();
+}
 
-    void RdbPredicatesImpl::Or()
-    {
-        if (predicates_ == nullptr) {
-            return;
-        }
-        predicates_->Or();
+void RdbPredicatesImpl::Or()
+{
+    if (predicates_ == nullptr) {
+        return;
     }
+    predicates_->Or();
+}
 
-    void RdbPredicatesImpl::And()
-    {
-        if (predicates_ == nullptr) {
-            return;
-        }
-        predicates_->And();
+void RdbPredicatesImpl::And()
+{
+    if (predicates_ == nullptr) {
+        return;
     }
+    predicates_->And();
+}
 
-    void RdbPredicatesImpl::Contains(const char* field, const char* value)
-    {
-        if (field == nullptr || value == nullptr || predicates_ == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        std::string cvalue = value;
-        predicates_->Contains(cfield, cvalue);
+void RdbPredicatesImpl::Contains(const char *field, const char *value)
+{
+    if (field == nullptr || value == nullptr || predicates_ == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    std::string cvalue = value;
+    predicates_->Contains(cfield, cvalue);
+}
 
-    void RdbPredicatesImpl::BeginsWith(const char* field, const char* value)
-    {
-        if (field == nullptr || value == nullptr || predicates_ == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        std::string cvalue = value;
-        predicates_->BeginsWith(cfield, cvalue);
+void RdbPredicatesImpl::BeginsWith(const char *field, const char *value)
+{
+    if (field == nullptr || value == nullptr || predicates_ == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    std::string cvalue = value;
+    predicates_->BeginsWith(cfield, cvalue);
+}
 
-    void RdbPredicatesImpl::EndsWith(const char* field, const char* value)
-    {
-        if (field == nullptr || value == nullptr || predicates_ == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        std::string cvalue = value;
-        predicates_->EndsWith(cfield, cvalue);
+void RdbPredicatesImpl::EndsWith(const char *field, const char *value)
+{
+    if (field == nullptr || value == nullptr || predicates_ == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    std::string cvalue = value;
+    predicates_->EndsWith(cfield, cvalue);
+}
 
-    void RdbPredicatesImpl::IsNull(const char* field)
-    {
-        if (field == nullptr || predicates_ == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        predicates_->IsNull(cfield);
+void RdbPredicatesImpl::IsNull(const char *field)
+{
+    if (field == nullptr || predicates_ == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    predicates_->IsNull(cfield);
+}
 
-    void RdbPredicatesImpl::IsNotNull(const char* field)
-    {
-        if (field == nullptr || predicates_ == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        predicates_->IsNotNull(cfield);
+void RdbPredicatesImpl::IsNotNull(const char *field)
+{
+    if (field == nullptr || predicates_ == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    predicates_->IsNotNull(cfield);
+}
 
-    void RdbPredicatesImpl::Like(const char* field, const char* value)
-    {
-        if (field == nullptr || value == nullptr || predicates_ == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        std::string cvalue = value;
-        predicates_->Like(cfield, cvalue);
+void RdbPredicatesImpl::Like(const char *field, const char *value)
+{
+    if (field == nullptr || value == nullptr || predicates_ == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    std::string cvalue = value;
+    predicates_->Like(cfield, cvalue);
+}
 
-    void RdbPredicatesImpl::Glob(const char* field, const char* value)
-    {
-        if (field == nullptr || value == nullptr || predicates_ == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        std::string cvalue = value;
-        predicates_->Glob(cfield, cvalue);
+void RdbPredicatesImpl::Glob(const char *field, const char *value)
+{
+    if (field == nullptr || value == nullptr || predicates_ == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    std::string cvalue = value;
+    predicates_->Glob(cfield, cvalue);
+}
 
-    void RdbPredicatesImpl::OrderByAsc(const char* field)
-    {
-        if (field == nullptr || predicates_ == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        predicates_->OrderByAsc(cfield);
+void RdbPredicatesImpl::OrderByAsc(const char *field)
+{
+    if (field == nullptr || predicates_ == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    predicates_->OrderByAsc(cfield);
+}
 
-    void RdbPredicatesImpl::OrderByDesc(const char* field)
-    {
-        if (field == nullptr || predicates_ == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        predicates_->OrderByDesc(cfield);
+void RdbPredicatesImpl::OrderByDesc(const char *field)
+{
+    if (field == nullptr || predicates_ == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    predicates_->OrderByDesc(cfield);
+}
 
-    void RdbPredicatesImpl::Distinct()
-    {
-        if (predicates_ == nullptr) {
-            return;
-        }
-        predicates_->Distinct();
+void RdbPredicatesImpl::Distinct()
+{
+    if (predicates_ == nullptr) {
+        return;
     }
+    predicates_->Distinct();
+}
 
-    void RdbPredicatesImpl::LimitAs(int32_t value)
-    {
-        if (predicates_ == nullptr) {
-            return;
-        }
-        predicates_->Limit(value);
+void RdbPredicatesImpl::LimitAs(int32_t value)
+{
+    if (predicates_ == nullptr) {
+        return;
     }
+    predicates_->Limit(value);
+}
 
-    void RdbPredicatesImpl::OffsetAs(int32_t rowOffset)
-    {
-        if (predicates_ == nullptr) {
-            return;
-        }
-        predicates_->Offset(rowOffset);
+void RdbPredicatesImpl::OffsetAs(int32_t rowOffset)
+{
+    if (predicates_ == nullptr) {
+        return;
     }
+    predicates_->Offset(rowOffset);
+}
 
-    void RdbPredicatesImpl::GroupBy(const char** fieldsArray, int64_t fieldsSize)
-    {
-        if (fieldsArray == nullptr || predicates_ == nullptr) {
+void RdbPredicatesImpl::GroupBy(const char **fieldsArray, int64_t fieldsSize)
+{
+    if (fieldsArray == nullptr || predicates_ == nullptr) {
+        return;
+    }
+    std::vector<std::string> fields;
+    for (int64_t i = 0; i < fieldsSize; i++) {
+        if (fieldsArray[i] == nullptr) {
             return;
         }
-        std::vector<std::string> fields;
-        for (int64_t i = 0; i < fieldsSize; i++) {
-            if (fieldsArray[i] == nullptr) {
-                return;
-            }
-            fields.push_back(fieldsArray[i]);
-        }
-        predicates_->GroupBy(fields);
+        fields.push_back(fieldsArray[i]);
     }
+    predicates_->GroupBy(fields);
+}
 
-    void RdbPredicatesImpl::IndexedBy(const char* field)
-    {
-        if (field == nullptr || predicates_ == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        predicates_->IndexedBy(cfield);
+void RdbPredicatesImpl::IndexedBy(const char *field)
+{
+    if (field == nullptr || predicates_ == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    predicates_->IndexedBy(cfield);
+}
 
-    void RdbPredicatesImpl::LessThanOrEqualTo(const char* field, ValueType value)
-    {
-        if (field == nullptr || predicates_ == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        NativeRdb::ValueObject valueObject = ValueTypeToValueObject(value);
-        predicates_->LessThanOrEqualTo(cfield, valueObject);
+void RdbPredicatesImpl::LessThanOrEqualTo(const char *field, ValueType value)
+{
+    if (field == nullptr || predicates_ == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    NativeRdb::ValueObject valueObject = ValueTypeToValueObject(value);
+    predicates_->LessThanOrEqualTo(cfield, valueObject);
+}
 
-    void RdbPredicatesImpl::LessThanOrEqualToEx(const char* field, const ValueTypeEx *value)
-    {
-        if (field == nullptr || value == nullptr || predicates_ == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        NativeRdb::ValueObject valueObject = ValueTypeExToValueObject(*value);
-        predicates_->LessThanOrEqualTo(cfield, valueObject);
+void RdbPredicatesImpl::LessThanOrEqualToEx(const char *field, const ValueTypeEx *value)
+{
+    if (field == nullptr || value == nullptr || predicates_ == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    NativeRdb::ValueObject valueObject = ValueTypeExToValueObject(*value);
+    predicates_->LessThanOrEqualTo(cfield, valueObject);
+}
 
-    void RdbPredicatesImpl::EqualTo(const char* field, ValueType value)
-    {
-        if (field == nullptr || predicates_ == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        NativeRdb::ValueObject valueObject = ValueTypeToValueObject(value);
-        predicates_->EqualTo(cfield, valueObject);
+void RdbPredicatesImpl::EqualTo(const char *field, ValueType value)
+{
+    if (field == nullptr || predicates_ == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    NativeRdb::ValueObject valueObject = ValueTypeToValueObject(value);
+    predicates_->EqualTo(cfield, valueObject);
+}
 
-    void RdbPredicatesImpl::EqualToEx(const char* field, const ValueTypeEx *value)
-    {
-        if (field == nullptr || predicates_ == nullptr || value == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        NativeRdb::ValueObject valueObject = ValueTypeExToValueObject(*value);
-        predicates_->EqualTo(cfield, valueObject);
-    }
-    
-    void RdbPredicatesImpl::GreaterThanOrEqualTo(const char* field, ValueType value)
-    {
-        if (field == nullptr || predicates_ == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        NativeRdb::ValueObject valueObject = ValueTypeToValueObject(value);
-        predicates_->GreaterThanOrEqualTo(cfield, valueObject);
+void RdbPredicatesImpl::EqualToEx(const char *field, const ValueTypeEx *value)
+{
+    if (field == nullptr || predicates_ == nullptr || value == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    NativeRdb::ValueObject valueObject = ValueTypeExToValueObject(*value);
+    predicates_->EqualTo(cfield, valueObject);
+}
 
-    void RdbPredicatesImpl::GreaterThanOrEqualToEx(const char* field, const ValueTypeEx *value)
-    {
-        if (field == nullptr || predicates_ == nullptr || value == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        NativeRdb::ValueObject valueObject = ValueTypeExToValueObject(*value);
-        predicates_->GreaterThanOrEqualTo(cfield, valueObject);
+void RdbPredicatesImpl::GreaterThanOrEqualTo(const char *field, ValueType value)
+{
+    if (field == nullptr || predicates_ == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    NativeRdb::ValueObject valueObject = ValueTypeToValueObject(value);
+    predicates_->GreaterThanOrEqualTo(cfield, valueObject);
+}
 
-    void RdbPredicatesImpl::GreaterThan(const char* field, ValueType value)
-    {
-        if (field == nullptr || predicates_ == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        NativeRdb::ValueObject valueObject = ValueTypeToValueObject(value);
-        predicates_->GreaterThan(cfield, valueObject);
+void RdbPredicatesImpl::GreaterThanOrEqualToEx(const char *field, const ValueTypeEx *value)
+{
+    if (field == nullptr || predicates_ == nullptr || value == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    NativeRdb::ValueObject valueObject = ValueTypeExToValueObject(*value);
+    predicates_->GreaterThanOrEqualTo(cfield, valueObject);
+}
 
-    void RdbPredicatesImpl::GreaterThanEx(const char* field, const ValueTypeEx *value)
-    {
-        if (field == nullptr || predicates_ == nullptr || value == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        NativeRdb::ValueObject valueObject = ValueTypeExToValueObject(*value);
-        predicates_->GreaterThan(cfield, valueObject);
+void RdbPredicatesImpl::GreaterThan(const char *field, ValueType value)
+{
+    if (field == nullptr || predicates_ == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    NativeRdb::ValueObject valueObject = ValueTypeToValueObject(value);
+    predicates_->GreaterThan(cfield, valueObject);
+}
 
-    void RdbPredicatesImpl::NotBetween(const char* field, ValueType lowValue, ValueType highValue)
-    {
-        if (field == nullptr || predicates_ == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        NativeRdb::ValueObject lowValueObject = ValueTypeToValueObject(lowValue);
-        NativeRdb::ValueObject highValueObject = ValueTypeToValueObject(highValue);
-        predicates_->NotBetween(cfield, lowValueObject, highValueObject);
+void RdbPredicatesImpl::GreaterThanEx(const char *field, const ValueTypeEx *value)
+{
+    if (field == nullptr || predicates_ == nullptr || value == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    NativeRdb::ValueObject valueObject = ValueTypeExToValueObject(*value);
+    predicates_->GreaterThan(cfield, valueObject);
+}
 
-    void RdbPredicatesImpl::NotBetweenEx(const char* field, const ValueTypeEx *lowValue, const ValueTypeEx *highValue)
-    {
-        if (field == nullptr || predicates_ == nullptr || lowValue == nullptr || highValue == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        NativeRdb::ValueObject lowValueObject = ValueTypeExToValueObject(*lowValue);
-        NativeRdb::ValueObject highValueObject = ValueTypeExToValueObject(*highValue);
-        predicates_->NotBetween(cfield, lowValueObject, highValueObject);
+void RdbPredicatesImpl::NotBetween(const char *field, ValueType lowValue, ValueType highValue)
+{
+    if (field == nullptr || predicates_ == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    NativeRdb::ValueObject lowValueObject = ValueTypeToValueObject(lowValue);
+    NativeRdb::ValueObject highValueObject = ValueTypeToValueObject(highValue);
+    predicates_->NotBetween(cfield, lowValueObject, highValueObject);
+}
 
-    void RdbPredicatesImpl::Between(const char* field, ValueType lowValue, ValueType highValue)
-    {
-        if (field == nullptr || predicates_ == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        NativeRdb::ValueObject lowValueObject = ValueTypeToValueObject(lowValue);
-        NativeRdb::ValueObject highValueObject = ValueTypeToValueObject(highValue);
-        predicates_->Between(cfield, lowValueObject, highValueObject);
+void RdbPredicatesImpl::NotBetweenEx(const char *field, const ValueTypeEx *lowValue, const ValueTypeEx *highValue)
+{
+    if (field == nullptr || predicates_ == nullptr || lowValue == nullptr || highValue == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    NativeRdb::ValueObject lowValueObject = ValueTypeExToValueObject(*lowValue);
+    NativeRdb::ValueObject highValueObject = ValueTypeExToValueObject(*highValue);
+    predicates_->NotBetween(cfield, lowValueObject, highValueObject);
+}
 
-    void RdbPredicatesImpl::BetweenEx(const char* field, const ValueTypeEx *lowValue, const ValueTypeEx *highValue)
-    {
-        if (field == nullptr || predicates_ == nullptr || lowValue == nullptr || highValue == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        NativeRdb::ValueObject lowValueObject = ValueTypeExToValueObject(*lowValue);
-        NativeRdb::ValueObject highValueObject = ValueTypeExToValueObject(*highValue);
-        predicates_->Between(cfield, lowValueObject, highValueObject);
+void RdbPredicatesImpl::Between(const char *field, ValueType lowValue, ValueType highValue)
+{
+    if (field == nullptr || predicates_ == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    NativeRdb::ValueObject lowValueObject = ValueTypeToValueObject(lowValue);
+    NativeRdb::ValueObject highValueObject = ValueTypeToValueObject(highValue);
+    predicates_->Between(cfield, lowValueObject, highValueObject);
+}
 
-    void RdbPredicatesImpl::LessThan(const char* field, ValueType value)
-    {
-        if (field == nullptr || predicates_ == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        NativeRdb::ValueObject valueObject = ValueTypeToValueObject(value);
-        predicates_->LessThan(cfield, valueObject);
+void RdbPredicatesImpl::BetweenEx(const char *field, const ValueTypeEx *lowValue, const ValueTypeEx *highValue)
+{
+    if (field == nullptr || predicates_ == nullptr || lowValue == nullptr || highValue == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    NativeRdb::ValueObject lowValueObject = ValueTypeExToValueObject(*lowValue);
+    NativeRdb::ValueObject highValueObject = ValueTypeExToValueObject(*highValue);
+    predicates_->Between(cfield, lowValueObject, highValueObject);
+}
 
-    void RdbPredicatesImpl::LessThanEx(const char *field, const ValueTypeEx *value)
-    {
-        if (field == nullptr || predicates_ == nullptr || value == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        NativeRdb::ValueObject valueObject = ValueTypeExToValueObject(*value);
-        predicates_->LessThan(cfield, valueObject);
+void RdbPredicatesImpl::LessThan(const char *field, ValueType value)
+{
+    if (field == nullptr || predicates_ == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    NativeRdb::ValueObject valueObject = ValueTypeToValueObject(value);
+    predicates_->LessThan(cfield, valueObject);
+}
 
-    void RdbPredicatesImpl::In(const char* field, ValueType* values, int64_t valuesSize)
-    {
-        if (field == nullptr || predicates_ == nullptr || values == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        std::vector<NativeRdb::ValueObject> valueObjects = std::vector<NativeRdb::ValueObject>();
-        for (int64_t i = 0; i < valuesSize; i++) {
-            valueObjects.push_back(ValueTypeToValueObject(values[i]));
-        }
-        predicates_->In(cfield, valueObjects);
+void RdbPredicatesImpl::LessThanEx(const char *field, const ValueTypeEx *value)
+{
+    if (field == nullptr || predicates_ == nullptr || value == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    NativeRdb::ValueObject valueObject = ValueTypeExToValueObject(*value);
+    predicates_->LessThan(cfield, valueObject);
+}
 
-    void RdbPredicatesImpl::InEx(const char* field, ValueTypeEx* values, int64_t valuesSize)
-    {
-        if (field == nullptr || predicates_ == nullptr || values == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        std::vector<NativeRdb::ValueObject> valueObjects = std::vector<NativeRdb::ValueObject>();
-        for (int64_t i = 0; i < valuesSize; i++) {
-            valueObjects.push_back(ValueTypeExToValueObject(values[i]));
-        }
-        predicates_->In(cfield, valueObjects);
+void RdbPredicatesImpl::In(const char *field, ValueType *values, int64_t valuesSize)
+{
+    if (field == nullptr || predicates_ == nullptr || values == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    std::vector<NativeRdb::ValueObject> valueObjects = std::vector<NativeRdb::ValueObject>();
+    for (int64_t i = 0; i < valuesSize; i++) {
+        valueObjects.push_back(ValueTypeToValueObject(values[i]));
+    }
+    predicates_->In(cfield, valueObjects);
+}
 
-    void RdbPredicatesImpl::NotIn(const char* field, ValueType* values, int64_t valuesSize)
-    {
-        if (field == nullptr || predicates_ == nullptr || values == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        std::vector<NativeRdb::ValueObject> valueObjects = std::vector<NativeRdb::ValueObject>();
-        for (int64_t i = 0; i < valuesSize; i++) {
-            valueObjects.push_back(ValueTypeToValueObject(values[i]));
-        }
-        predicates_->NotIn(cfield, valueObjects);
+void RdbPredicatesImpl::InEx(const char *field, ValueTypeEx *values, int64_t valuesSize)
+{
+    if (field == nullptr || predicates_ == nullptr || values == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    std::vector<NativeRdb::ValueObject> valueObjects = std::vector<NativeRdb::ValueObject>();
+    for (int64_t i = 0; i < valuesSize; i++) {
+        valueObjects.push_back(ValueTypeExToValueObject(values[i]));
+    }
+    predicates_->In(cfield, valueObjects);
+}
 
-    void RdbPredicatesImpl::NotInEx(const char* field, ValueTypeEx* values, int64_t valuesSize)
-    {
-        if (field == nullptr || predicates_ == nullptr || values == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        std::vector<NativeRdb::ValueObject> valueObjects = std::vector<NativeRdb::ValueObject>();
-        for (int64_t i = 0; i < valuesSize; i++) {
-            valueObjects.push_back(ValueTypeExToValueObject(values[i]));
-        }
-        predicates_->NotIn(cfield, valueObjects);
+void RdbPredicatesImpl::NotIn(const char *field, ValueType *values, int64_t valuesSize)
+{
+    if (field == nullptr || predicates_ == nullptr || values == nullptr) {
+        return;
+    }
+    std::string cfield = field;
+    std::vector<NativeRdb::ValueObject> valueObjects = std::vector<NativeRdb::ValueObject>();
+    for (int64_t i = 0; i < valuesSize; i++) {
+        valueObjects.push_back(ValueTypeToValueObject(values[i]));
     }
+    predicates_->NotIn(cfield, valueObjects);
+}
 
-    void RdbPredicatesImpl::NotEqualTo(const char* field, ValueType value)
-    {
-        if (field == nullptr || predicates_ == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        NativeRdb::ValueObject valueObject = ValueTypeToValueObject(value);
-        predicates_->NotEqualTo(cfield, valueObject);
+void RdbPredicatesImpl::NotInEx(const char *field, ValueTypeEx *values, int64_t valuesSize)
+{
+    if (field == nullptr || predicates_ == nullptr || values == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    std::vector<NativeRdb::ValueObject> valueObjects = std::vector<NativeRdb::ValueObject>();
+    for (int64_t i = 0; i < valuesSize; i++) {
+        valueObjects.push_back(ValueTypeExToValueObject(values[i]));
+    }
+    predicates_->NotIn(cfield, valueObjects);
+}
 
-    void RdbPredicatesImpl::NotEqualToEx(const char* field, const ValueTypeEx *value)
-    {
-        if (field == nullptr || predicates_ == nullptr || value == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        NativeRdb::ValueObject valueObject = ValueTypeExToValueObject(*value);
-        predicates_->NotEqualTo(cfield, valueObject);
+void RdbPredicatesImpl::NotEqualTo(const char *field, ValueType value)
+{
+    if (field == nullptr || predicates_ == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    NativeRdb::ValueObject valueObject = ValueTypeToValueObject(value);
+    predicates_->NotEqualTo(cfield, valueObject);
+}
 
-    void RdbPredicatesImpl::NotContains(const char* field, const char* value)
-    {
-        if (field == nullptr || predicates_ == nullptr || value == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        std::string cvalue = value;
-        predicates_->NotContains(cfield, cvalue);
+void RdbPredicatesImpl::NotEqualToEx(const char *field, const ValueTypeEx *value)
+{
+    if (field == nullptr || predicates_ == nullptr || value == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    NativeRdb::ValueObject valueObject = ValueTypeExToValueObject(*value);
+    predicates_->NotEqualTo(cfield, valueObject);
+}
 
-    void RdbPredicatesImpl::NotLike(const char* field, const char* value)
-    {
-        if (field == nullptr || predicates_ == nullptr || value == nullptr) {
-            return;
-        }
-        std::string cfield = field;
-        std::string cvalue = value;
-        predicates_->NotLike(field, value);
+void RdbPredicatesImpl::NotContains(const char *field, const char *value)
+{
+    if (field == nullptr || predicates_ == nullptr || value == nullptr) {
+        return;
+    }
+    std::string cfield = field;
+    std::string cvalue = value;
+    predicates_->NotContains(cfield, cvalue);
+}
+
+void RdbPredicatesImpl::NotLike(const char *field, const char *value)
+{
+    if (field == nullptr || predicates_ == nullptr || value == nullptr) {
+        return;
     }
+    std::string cfield = field;
+    std::string cvalue = value;
+    predicates_->NotLike(field, value);
 }
-}
\ No newline at end of file
+} // namespace Relational
+} // namespace OHOS
\ No newline at end of file
diff --git a/frameworks/cj/src/relational_store_impl_rdbstore.cpp b/frameworks/cj/src/relational_store_impl_rdbstore.cpp
index 5a3e44c86d7070aee944a465bed769ca5b8503dd..d785374c5ac7db24c7385d6911d0a3475f6014b8 100644
--- a/frameworks/cj/src/relational_store_impl_rdbstore.cpp
+++ b/frameworks/cj/src/relational_store_impl_rdbstore.cpp
@@ -43,1100 +43,1100 @@ using namespace OHOS::FFI;
 
 namespace OHOS {
 namespace Relational {
-    RdbStoreObserverImpl::RdbStoreObserverImpl(int64_t id, FuncType type, int32_t mode)
-    {
-        callbackId = id;
-        funcType = type;
-        mode_ = mode;
-        switch (type) {
-            case NoParam: {
-                auto cFunc = reinterpret_cast<void(*)()>(callbackId);
-                func = CJLambda::Create(cFunc);
-                break;
-            }
-            case ParamArrStr: {
-                auto cFunc = reinterpret_cast<void(*)(CArrStr arr)>(callbackId);
-                carrStrFunc = [ lambda = CJLambda::Create(cFunc)](const std::vector<std::string> &devices) ->
-                    void { lambda(VectorToCArrStr(devices)); };
-                break;
-            }
-            case ParamChangeInfo: {
-                auto cFunc = reinterpret_cast<void(*)(CArrRetChangeInfo arr)>(callbackId);
-                changeInfoFunc = [ lambda = CJLambda::Create(cFunc)](const DistributedRdb::Origin &origin,
-                const PrimaryFields &fields, DistributedRdb::RdbStoreObserver::ChangeInfo &&changeInfo) ->
-                    void { lambda(ToCArrRetChangeInfo(origin, fields, std::move(changeInfo))); };
-                break;
-            }
+RdbStoreObserverImpl::RdbStoreObserverImpl(int64_t id, FuncType type, int32_t mode)
+{
+    callbackId = id;
+    funcType = type;
+    mode_ = mode;
+    switch (type) {
+        case NoParam: {
+            auto cFunc = reinterpret_cast<void(*)()>(callbackId);
+            func = CJLambda::Create(cFunc);
+            break;
+        }
+        case ParamArrStr: {
+            auto cFunc = reinterpret_cast<void(*)(CArrStr arr)>(callbackId);
+            carrStrFunc = [ lambda = CJLambda::Create(cFunc)](const std::vector<std::string> &devices) ->
+                void { lambda(VectorToCArrStr(devices)); };
+            break;
+        }
+        case ParamChangeInfo: {
+            auto cFunc = reinterpret_cast<void(*)(CArrRetChangeInfo arr)>(callbackId);
+            changeInfoFunc = [ lambda = CJLambda::Create(cFunc)](const DistributedRdb::Origin &origin,
+            const PrimaryFields &fields, DistributedRdb::RdbStoreObserver::ChangeInfo &&changeInfo) ->
+                void { lambda(ToCArrRetChangeInfo(origin, fields, std::move(changeInfo))); };
+            break;
         }
     }
+}
 
-    SyncObserverImpl::SyncObserverImpl(int64_t id)
-    {
-        callbackId = id;
-        auto cFunc = reinterpret_cast<void(*)(CProgressDetails details)>(callbackId);
-        func = [ lambda = CJLambda::Create(cFunc)](const DistributedRdb::Details &details) ->
-            void { lambda(ToCProgressDetails(details)); };
-    }
-
-    class DefaultOpenCallback : public NativeRdb::RdbOpenCallback {
-    public:
-        int OnCreate(NativeRdb::RdbStore &rdbStore) override
-        {
-            return RelationalStoreJsKit::OK;
-        }
-
-        int OnUpgrade(NativeRdb::RdbStore &rdbStore, int oldVersion, int newVersion) override
-        {
-            return RelationalStoreJsKit::OK;
-        }
-    };
+SyncObserverImpl::SyncObserverImpl(int64_t id)
+{
+    callbackId = id;
+    auto cFunc = reinterpret_cast<void(*)(CProgressDetails details)>(callbackId);
+    func = [ lambda = CJLambda::Create(cFunc)](const DistributedRdb::Details &details) ->
+        void { lambda(ToCProgressDetails(details)); };
+}
 
-    RdbStoreImpl::RdbStoreImpl(std::shared_ptr<OHOS::NativeRdb::RdbStore> rdbStore)
+class DefaultOpenCallback : public NativeRdb::RdbOpenCallback {
+public:
+    int OnCreate(NativeRdb::RdbStore &rdbStore) override
     {
-        rdbStore_ = rdbStore;
+        return RelationalStoreJsKit::OK;
     }
 
-    OHOS::FFI::RuntimeType* RdbStoreImpl::GetClassType()
+    int OnUpgrade(NativeRdb::RdbStore &rdbStore, int oldVersion, int newVersion) override
     {
-        static OHOS::FFI::RuntimeType runtimeType = OHOS::FFI::RuntimeType::Create<OHOS::FFI::FFIData>("RdbStoreImpl");
-        return &runtimeType;
+        return RelationalStoreJsKit::OK;
     }
+};
 
-    NativeRdb::ValuesBucket ConvertFromValueBucket(ValuesBucket valuesBucket)
-    {
-        int64_t mapSize = valuesBucket.size;
-        NativeRdb::ValuesBucket nativeValuesBucket = NativeRdb::ValuesBucket();
+RdbStoreImpl::RdbStoreImpl(std::shared_ptr<OHOS::NativeRdb::RdbStore> rdbStore)
+{
+    rdbStore_ = rdbStore;
+}
+
+OHOS::FFI::RuntimeType *RdbStoreImpl::GetClassType()
+{
+    static OHOS::FFI::RuntimeType runtimeType = OHOS::FFI::RuntimeType::Create<OHOS::FFI::FFIData>("RdbStoreImpl");
+    return &runtimeType;
+}
+
+NativeRdb::ValuesBucket ConvertFromValueBucket(ValuesBucket valuesBucket)
+{
+    int64_t mapSize = valuesBucket.size;
+    NativeRdb::ValuesBucket nativeValuesBucket = NativeRdb::ValuesBucket();
 
-        if (valuesBucket.value == nullptr || valuesBucket.key == nullptr) {
+    if (valuesBucket.value == nullptr || valuesBucket.key == nullptr) {
+        return nativeValuesBucket;
+    }
+    for (int64_t i = 0; i < mapSize; i++) {
+        NativeRdb::ValueObject valueObject = ValueTypeToValueObject(valuesBucket.value[i]);
+        if (valuesBucket.key[i] == nullptr) {
             return nativeValuesBucket;
         }
-        for (int64_t i = 0; i < mapSize; i++) {
-            NativeRdb::ValueObject valueObject = ValueTypeToValueObject(valuesBucket.value[i]);
-            if (valuesBucket.key[i] == nullptr) {
-                return nativeValuesBucket;
-            }
-            std::string keyStr = valuesBucket.key[i];
-            nativeValuesBucket.Put(keyStr, valueObject);
-        }
-        return nativeValuesBucket;
+        std::string keyStr = valuesBucket.key[i];
+        nativeValuesBucket.Put(keyStr, valueObject);
     }
+    return nativeValuesBucket;
+}
 
-    NativeRdb::ValuesBucket ConvertFromValueBucketEx(ValuesBucketEx valuesBucket)
-    {
-        int64_t mapSize = valuesBucket.size;
-        NativeRdb::ValuesBucket nativeValuesBucket = NativeRdb::ValuesBucket();
+NativeRdb::ValuesBucket ConvertFromValueBucketEx(ValuesBucketEx valuesBucket)
+{
+    int64_t mapSize = valuesBucket.size;
+    NativeRdb::ValuesBucket nativeValuesBucket = NativeRdb::ValuesBucket();
 
-        if (valuesBucket.value == nullptr || valuesBucket.key == nullptr) {
+    if (valuesBucket.value == nullptr || valuesBucket.key == nullptr) {
+        return nativeValuesBucket;
+    }
+    for (int64_t i = 0; i < mapSize; i++) {
+        NativeRdb::ValueObject valueObject = ValueTypeExToValueObject(valuesBucket.value[i]);
+        if (valuesBucket.key[i] == nullptr) {
             return nativeValuesBucket;
         }
-        for (int64_t i = 0; i < mapSize; i++) {
-            NativeRdb::ValueObject valueObject = ValueTypeExToValueObject(valuesBucket.value[i]);
-            if (valuesBucket.key[i] == nullptr) {
-                return nativeValuesBucket;
-            }
-            std::string keyStr = valuesBucket.key[i];
-            nativeValuesBucket.Put(keyStr, valueObject);
-        }
-        return nativeValuesBucket;
+        std::string keyStr = valuesBucket.key[i];
+        nativeValuesBucket.Put(keyStr, valueObject);
     }
+    return nativeValuesBucket;
+}
 
-    std::shared_ptr<NativeRdb::ResultSet> RdbStoreImpl::Query(RdbPredicatesImpl &predicates, char** column,
-        int64_t columnSize)
-    {
-        if (column == nullptr) {
+std::shared_ptr<NativeRdb::ResultSet> RdbStoreImpl::Query(RdbPredicatesImpl &predicates, char **column,
+    int64_t columnSize)
+{
+    if (column == nullptr || predicates.GetPredicates() == nullptr) {
+        return nullptr;
+    }
+    std::vector<std::string> columnsVector = std::vector<std::string>();
+    for (int64_t i = 0; i < columnSize; i++) {
+        if (column[i] == nullptr) {
             return nullptr;
         }
-        std::vector<std::string> columnsVector = std::vector<std::string>();
-        for (int64_t i = 0; i < columnSize; i++) {
-            if (column[i] == nullptr) {
-                return nullptr;
-            }
-            columnsVector.push_back(std::string(column[i]));
-        }
-        auto resultSet = rdbStore_->Query(*(predicates.GetPredicates()), columnsVector);
-        return resultSet;
+        columnsVector.push_back(std::string(column[i]));
     }
+    auto resultSet = rdbStore_->Query(*(predicates.GetPredicates()), columnsVector);
+    return resultSet;
+}
 
-    std::shared_ptr<NativeRdb::ResultSet> RdbStoreImpl::RemoteQuery(char* device, RdbPredicatesImpl &predicates,
-        char** column, int64_t columnSize)
-    {
-        if (column == nullptr) {
-            return nullptr;
-        }
-        std::vector<std::string> columnsVector;
-        for (int64_t i = 0; i < columnSize; i++) {
-            if (column[i] == nullptr) {
-                return nullptr;
-            }
-            columnsVector.push_back(std::string(column[i]));
-        }
-        int32_t errCode;
-        if (predicates.GetPredicates() == nullptr) {
+std::shared_ptr<NativeRdb::ResultSet> RdbStoreImpl::RemoteQuery(char *device, RdbPredicatesImpl &predicates,
+    char **column, int64_t columnSize)
+{
+    if (column == nullptr || device == nullptr) {
+        return nullptr;
+    }
+    std::vector<std::string> columnsVector;
+    for (int64_t i = 0; i < columnSize; i++) {
+        if (column[i] == nullptr) {
             return nullptr;
         }
-        auto resultSet = rdbStore_->RemoteQuery(std::string(device), *(predicates.GetPredicates()), columnsVector,
-            errCode);
-        return resultSet;
+        columnsVector.push_back(std::string(column[i]));
     }
-
-    int32_t RdbStoreImpl::Update(ValuesBucket valuesBucket, RdbPredicatesImpl &predicates,
-        NativeRdb::ConflictResolution conflictResolution, int32_t *errCode)
-    {
-        if (errCode == nullptr || rdbStore_ == nullptr || predicates.GetPredicates() == nullptr) {
-            return -1;
-        }
-        int32_t affectedRows;
-        NativeRdb::ValuesBucket nativeValuesBucket = ConvertFromValueBucket(valuesBucket);
-        *errCode = rdbStore_->UpdateWithConflictResolution(affectedRows, predicates.GetPredicates()->GetTableName(),
-            nativeValuesBucket, predicates.GetPredicates()->GetWhereClause(), predicates.GetPredicates()->GetBindArgs(),
-            conflictResolution);
-        return affectedRows;
+    int32_t errCode;
+    if (predicates.GetPredicates() == nullptr) {
+        return nullptr;
     }
+    auto resultSet = rdbStore_->RemoteQuery(std::string(device), *(predicates.GetPredicates()), columnsVector,
+        errCode);
+    return resultSet;
+}
 
-    int32_t RdbStoreImpl::UpdateEx(ValuesBucketEx valuesBucket, RdbPredicatesImpl &predicates,
-        NativeRdb::ConflictResolution conflictResolution, int32_t *errCode)
-    {
-        if (errCode == nullptr || rdbStore_ == nullptr || predicates.GetPredicates() == nullptr) {
-            return -1;
-        }
-        int32_t affectedRows;
-        NativeRdb::ValuesBucket nativeValuesBucket = ConvertFromValueBucketEx(valuesBucket);
-        *errCode = rdbStore_->UpdateWithConflictResolution(affectedRows, predicates.GetPredicates()->GetTableName(),
-            nativeValuesBucket, predicates.GetPredicates()->GetWhereClause(), predicates.GetPredicates()->GetBindArgs(),
-            conflictResolution);
-        return affectedRows;
+int32_t RdbStoreImpl::Update(ValuesBucket &valuesBucket, RdbPredicatesImpl &predicates,
+    NativeRdb::ConflictResolution conflictResolution, int32_t *errCode)
+{
+    if (errCode == nullptr || rdbStore_ == nullptr || predicates.GetPredicates() == nullptr) {
+        return -1;
+    }
+    int32_t affectedRows;
+    NativeRdb::ValuesBucket nativeValuesBucket = ConvertFromValueBucket(valuesBucket);
+    *errCode = rdbStore_->UpdateWithConflictResolution(affectedRows, predicates.GetPredicates()->GetTableName(),
+        nativeValuesBucket, predicates.GetPredicates()->GetWhereClause(), predicates.GetPredicates()->GetBindArgs(),
+        conflictResolution);
+    return affectedRows;
+}
+
+int32_t RdbStoreImpl::UpdateEx(ValuesBucketEx &valuesBucket, RdbPredicatesImpl &predicates,
+    NativeRdb::ConflictResolution conflictResolution, int32_t *errCode)
+{
+    if (errCode == nullptr || rdbStore_ == nullptr || predicates.GetPredicates() == nullptr) {
+        return -1;
+    }
+    int32_t affectedRows;
+    NativeRdb::ValuesBucket nativeValuesBucket = ConvertFromValueBucketEx(valuesBucket);
+    *errCode = rdbStore_->UpdateWithConflictResolution(affectedRows, predicates.GetPredicates()->GetTableName(),
+        nativeValuesBucket, predicates.GetPredicates()->GetWhereClause(), predicates.GetPredicates()->GetBindArgs(),
+        conflictResolution);
+    return affectedRows;
+}
+
+int RdbStoreImpl::Delete(RdbPredicatesImpl &predicates, int32_t *errCode)
+{
+    if (errCode == nullptr || rdbStore_ == nullptr || predicates.GetPredicates() == nullptr) {
+        return -1;
     }
+    int deletedRows = 0;
+    *errCode = rdbStore_->Delete(deletedRows, *(predicates.GetPredicates()));
+    return deletedRows;
+}
 
-    int RdbStoreImpl::Delete(RdbPredicatesImpl &predicates, int32_t *errCode)
-    {
-        if (errCode == nullptr || rdbStore_ == nullptr || predicates.GetPredicates() == nullptr) {
+int32_t RdbStoreImpl::SetDistributedTables(char **tables, int64_t tablesSize)
+{
+    if (tables == nullptr || rdbStore_ == nullptr) {
+        return -1;
+    }
+    std::vector<std::string> tablesVector;
+    for (int64_t i = 0; i < tablesSize; i++) {
+        if (tables[i] == nullptr) {
             return -1;
         }
-        int deletedRows = 0;
-        *errCode = rdbStore_->Delete(deletedRows, *(predicates.GetPredicates()));
-        return deletedRows;
+        tablesVector.push_back(std::string(tables[i]));
     }
+    return rdbStore_->SetDistributedTables(tablesVector, DistributedRdb::DISTRIBUTED_DEVICE,
+        DistributedRdb::DistributedConfig{false});
+}
 
-    int32_t RdbStoreImpl::SetDistributedTables(char** tables, int64_t tablesSize)
-    {
-        if (tables == nullptr || rdbStore_ == nullptr) {
+int32_t RdbStoreImpl::SetDistributedTables(char **tables, int64_t tablesSize, int32_t type)
+{
+    if (tables == nullptr || rdbStore_ == nullptr) {
+        return -1;
+    }
+    std::vector<std::string> tablesVector;
+    for (int64_t i = 0; i < tablesSize; i++) {
+        if (tables[i] == nullptr) {
             return -1;
         }
-        std::vector<std::string> tablesVector;
-        for (int64_t i = 0; i < tablesSize; i++) {
-            if (tables[i] == nullptr) {
-                return -1;
-            }
-            tablesVector.push_back(std::string(tables[i]));
-        }
-        return rdbStore_->SetDistributedTables(tablesVector, DistributedRdb::DISTRIBUTED_DEVICE,
-            DistributedRdb::DistributedConfig{false});
+        tablesVector.push_back(std::string(tables[i]));
     }
+    return rdbStore_->SetDistributedTables(tablesVector, type, DistributedRdb::DistributedConfig{false});
+}
 
-    int32_t RdbStoreImpl::SetDistributedTables(char** tables, int64_t tablesSize, int32_t type)
-    {
-        if (tables == nullptr || rdbStore_ == nullptr) {
+int32_t RdbStoreImpl::SetDistributedTables(char **tables, int64_t tablesSize, int32_t type,
+    DistributedRdb::DistributedConfig &distributedConfig)
+{
+    if (tables == nullptr || rdbStore_ == nullptr) {
+        return -1;
+    }
+    std::vector<std::string> tablesVector;
+    for (int64_t i = 0; i < tablesSize; i++) {
+        if (tables[i] == nullptr) {
             return -1;
         }
-        std::vector<std::string> tablesVector;
-        for (int64_t i = 0; i < tablesSize; i++) {
-            if (tables[i] == nullptr) {
-                return -1;
-            }
-            tablesVector.push_back(std::string(tables[i]));
-        }
-        return rdbStore_->SetDistributedTables(tablesVector, type, DistributedRdb::DistributedConfig{false});
+        tablesVector.push_back(std::string(tables[i]));
     }
+    return rdbStore_->SetDistributedTables(tablesVector, type, distributedConfig);
+}
 
-    int32_t RdbStoreImpl::SetDistributedTables(char** tables, int64_t tablesSize, int32_t type,
-        DistributedRdb::DistributedConfig &distributedConfig)
-    {
-        if (tables == nullptr || rdbStore_ == nullptr) {
-            return -1;
-        }
-        std::vector<std::string> tablesVector;
-        for (int64_t i = 0; i < tablesSize; i++) {
-            if (tables[i] == nullptr) {
-                return -1;
-            }
-            tablesVector.push_back(std::string(tables[i]));
-        }
-        return rdbStore_->SetDistributedTables(tablesVector, type, distributedConfig);
+int32_t RdbStoreImpl::RollBack()
+{
+    if (rdbStore_ == nullptr) {
+        return -1;
     }
+    return rdbStore_->RollBack();
+}
 
-    int32_t RdbStoreImpl::RollBack()
-    {
-        if (rdbStore_ == nullptr) {
-            return -1;
-        }
-        return rdbStore_->RollBack();
+int32_t RdbStoreImpl::Commit()
+{
+    if (rdbStore_ == nullptr) {
+        return -1;
     }
+    return rdbStore_->Commit();
+}
 
-    int32_t RdbStoreImpl::Commit()
-    {
-        if (rdbStore_ == nullptr) {
-            return -1;
-        }
-        return rdbStore_->Commit();
+int32_t RdbStoreImpl::BeginTransaction()
+{
+    if (rdbStore_ == nullptr) {
+        return -1;
     }
+    return rdbStore_->BeginTransaction();
+}
 
-    int32_t RdbStoreImpl::BeginTransaction()
-    {
-        if (rdbStore_ == nullptr) {
-            return -1;
-        }
-        return rdbStore_->BeginTransaction();
+int32_t RdbStoreImpl::Backup(const char *destName)
+{
+    if (rdbStore_ == nullptr || destName == nullptr) {
+        return -1;
     }
+    return rdbStore_->Backup(destName, newKey);
+}
 
-    int32_t RdbStoreImpl::Backup(const char* destName)
-    {
-        if (rdbStore_ == nullptr || destName == nullptr) {
-            return -1;
-        }
-        return rdbStore_->Backup(destName, newKey);
+int32_t RdbStoreImpl::Restore(const char *srcName)
+{
+    if (rdbStore_ == nullptr || srcName == nullptr) {
+        return -1;
     }
+    return rdbStore_->Restore(srcName, newKey);
+}
 
-    int32_t RdbStoreImpl::Restore(const char* srcName)
-    {
-        if (rdbStore_ == nullptr || srcName == nullptr) {
-            return -1;
-        }
-        return rdbStore_->Restore(srcName, newKey);
+char *RdbStoreImpl::ObtainDistributedTableName(const char *device, const char *table)
+{
+    if (rdbStore_ == nullptr || device == nullptr || table == nullptr) {
+        return nullptr;
     }
+    int errCode = RelationalStoreJsKit::E_INNER_ERROR;
+    std::string tableName = rdbStore_->ObtainDistributedTableName(device, table, errCode);
+    return MallocCString(tableName);
+}
 
-    char* RdbStoreImpl::ObtainDistributedTableName(const char* device, const char* table)
-    {
-        if (rdbStore_ == nullptr || device == nullptr || table == nullptr) {
-            return nullptr;
-        }
-        int errCode = RelationalStoreJsKit::E_INNER_ERROR;
-        std::string tableName = rdbStore_->ObtainDistributedTableName(device, table, errCode);
-        return MallocCString(tableName);
+int32_t RdbStoreImpl::Emit(const char *event)
+{
+    if (rdbStore_ == nullptr || event == nullptr) {
+        return -1;
     }
+    return rdbStore_->Notify(event);
+}
 
-    int32_t RdbStoreImpl::Emit(const char* event)
-    {
-        if (rdbStore_ == nullptr || event == nullptr) {
-            return -1;
-        }
-        return rdbStore_->Notify(event);
+int64_t RdbStoreImpl::Insert(const char *table, ValuesBucket valuesBucket, int32_t conflict, int32_t *errCode)
+{
+    if (rdbStore_ == nullptr || table == nullptr || errCode == nullptr) {
+        return -1;
+    }
+    std::string tableName = table;
+    int64_t result;
+    NativeRdb::ValuesBucket nativeValuesBucket = ConvertFromValueBucket(valuesBucket);
+    *errCode = rdbStore_->InsertWithConflictResolution(result, tableName,
+        nativeValuesBucket, NativeRdb::ConflictResolution(conflict));
+    return result;
+}
+
+int64_t RdbStoreImpl::InsertEx(const char *table, ValuesBucketEx valuesBucket, int32_t conflict, int32_t *errCode)
+{
+    if (rdbStore_ == nullptr || table == nullptr || errCode == nullptr) {
+        return -1;
+    }
+    std::string tableName = table;
+    int64_t result;
+    NativeRdb::ValuesBucket nativeValuesBucket = ConvertFromValueBucketEx(valuesBucket);
+    *errCode = rdbStore_->InsertWithConflictResolution(result, tableName,
+        nativeValuesBucket, NativeRdb::ConflictResolution(conflict));
+    return result;
+}
+
+void RdbStoreImpl::ExecuteSql(const char *sql, int32_t *errCode)
+{
+    if (rdbStore_ == nullptr || sql == nullptr || errCode == nullptr) {
+        return;
     }
+    *errCode = rdbStore_->ExecuteSql(sql, std::vector<OHOS::NativeRdb::ValueObject>());
+}
 
-    int64_t RdbStoreImpl::Insert(const char* table, ValuesBucket valuesBucket, int32_t conflict, int32_t *errCode)
-    {
-        if (rdbStore_ == nullptr || table == nullptr || errCode == nullptr) {
-            return -1;
-        }
-        std::string tableName = table;
-        int64_t result;
-        NativeRdb::ValuesBucket nativeValuesBucket = ConvertFromValueBucket(valuesBucket);
-        *errCode = rdbStore_->InsertWithConflictResolution(result, tableName,
-            nativeValuesBucket, NativeRdb::ConflictResolution(conflict));
-        return result;
+
+int32_t RdbStoreImpl::CleanDirtyData(const char *tableName, uint64_t cursor)
+{
+    if (rdbStore_ == nullptr || tableName == nullptr) {
+        return -1;
     }
+    int32_t rtnCode = rdbStore_->CleanDirtyData(tableName, cursor);
+    return rtnCode;
+}
 
-    int64_t RdbStoreImpl::InsertEx(const char* table, ValuesBucketEx valuesBucket, int32_t conflict, int32_t *errCode)
-    {
-        if (rdbStore_ == nullptr || table == nullptr || errCode == nullptr) {
-            return -1;
-        }
-        std::string tableName = table;
-        int64_t result;
-        NativeRdb::ValuesBucket nativeValuesBucket = ConvertFromValueBucketEx(valuesBucket);
-        *errCode = rdbStore_->InsertWithConflictResolution(result, tableName,
-            nativeValuesBucket, NativeRdb::ConflictResolution(conflict));
-        return result;
+int32_t RdbStoreImpl::BatchInsert(int64_t &insertNum, const char *tableName, ValuesBucket *valuesBuckets,
+    int64_t valuesSize)
+{
+    if (rdbStore_ == nullptr || tableName == nullptr || valuesBuckets == nullptr) {
+        return -1;
     }
+    std::vector<NativeRdb::ValuesBucket> valuesVector;
+    std::string tableNameStr = tableName;
+    if (tableNameStr.empty()) {
+        return RelationalStoreJsKit::E_PARAM_ERROR;
+    }
+    for (int64_t i = 0; i < valuesSize; i++) {
+        NativeRdb::ValuesBucket nativeValuesBucket = ConvertFromValueBucket(valuesBuckets[i]);
+        valuesVector.push_back(nativeValuesBucket);
+    }
+    int32_t rtnCode = rdbStore_->BatchInsert(insertNum, tableNameStr, valuesVector);
+    return rtnCode;
+}
 
-    void RdbStoreImpl::ExecuteSql(const char* sql, int32_t *errCode)
-    {
-        if (rdbStore_ == nullptr || sql == nullptr || errCode == nullptr) {
-            return;
-        }
-        *errCode = rdbStore_->ExecuteSql(sql, std::vector<OHOS::NativeRdb::ValueObject>());
+int32_t RdbStoreImpl::BatchInsertEx(int64_t &insertNum, const char *tableName, ValuesBucketEx *valuesBuckets,
+    int64_t valuesSize)
+{
+    if (rdbStore_ == nullptr || tableName == nullptr || valuesBuckets == nullptr) {
+        return -1;
+    }
+    std::vector<NativeRdb::ValuesBucket> valuesVector;
+    std::string tableNameStr = tableName;
+    if (tableNameStr.empty()) {
+        return RelationalStoreJsKit::E_PARAM_ERROR;
     }
+    for (int64_t i = 0; i < valuesSize; i++) {
+        NativeRdb::ValuesBucket nativeValuesBucket = ConvertFromValueBucketEx(valuesBuckets[i]);
+        valuesVector.push_back(nativeValuesBucket);
+    }
+    int32_t rtnCode = rdbStore_->BatchInsert(insertNum, tableNameStr, valuesVector);
+    return rtnCode;
+}
 
+CArrSyncResult RdbStoreImpl::Sync(int32_t mode, RdbPredicatesImpl &predicates)
+{
+    DistributedRdb::SyncOption option;
+    option.mode = static_cast<DistributedRdb::SyncMode>(mode);
+    option.isBlock = true;
+    DistributedRdb::SyncResult resMap;
+    if (rdbStore_ == nullptr) {
+        return CArrSyncResult{nullptr, nullptr, -1};
+    }
+    rdbStore_->Sync(option, *(predicates.GetPredicates()),
+        [&resMap](const DistributedRdb::SyncResult &result) { resMap = result; });
+    if (resMap.size() == 0) {
+        return CArrSyncResult{nullptr, nullptr, -1};
+    }
+    char **resultStr = static_cast<char**>(malloc(resMap.size() * sizeof(char*)));
+    int32_t *resultNum = static_cast<int32_t*>(malloc(resMap.size() * sizeof(int32_t)));
+    if (resultStr == nullptr || resultNum == nullptr) {
+        free(resultStr);
+        free(resultNum);
+        return CArrSyncResult{nullptr, nullptr, -1};
+    }
+    size_t i = 0;
+    for (auto it = resMap.begin(); it != resMap.end(); ++it) {
+        resultStr[i] = MallocCString(it->first);
+        resultNum[i] = it->second;
+        i++;
+    }
+    return CArrSyncResult{resultStr, resultNum, int64_t(resMap.size())};
+}
 
-    int32_t RdbStoreImpl::CleanDirtyData(const char* tableName, uint64_t cursor)
-    {
-        if (rdbStore_ == nullptr || tableName == nullptr) {
-            return -1;
-        }
-        int32_t rtnCode = rdbStore_->CleanDirtyData(tableName, cursor);
-        return rtnCode;
+std::shared_ptr<NativeRdb::ResultSet> RdbStoreImpl::QuerySql(const char *sql, ValueType *bindArgs, int64_t size)
+{
+    if (sql == nullptr || bindArgs == nullptr || rdbStore_ == nullptr) {
+        return nullptr;
     }
-
-    int32_t RdbStoreImpl::BatchInsert(int64_t &insertNum, const char* tableName, ValuesBucket* valuesBuckets,
-        int64_t valuesSize)
-    {
-        if (rdbStore_ == nullptr || tableName == nullptr || valuesBuckets == nullptr) {
-            return -1;
-        }
-        std::vector<NativeRdb::ValuesBucket> valuesVector;
-        std::string tableNameStr = tableName;
-        if (tableNameStr.empty()) {
-            return RelationalStoreJsKit::E_PARAM_ERROR;
-        }
-        for (int64_t i = 0; i < valuesSize; i++) {
-            NativeRdb::ValuesBucket nativeValuesBucket = ConvertFromValueBucket(valuesBuckets[i]);
-            valuesVector.push_back(nativeValuesBucket);
-        }
-        int32_t rtnCode = rdbStore_->BatchInsert(insertNum, tableNameStr, valuesVector);
-        return rtnCode;
+    std::string tmpSql = sql;
+    std::vector<NativeRdb::ValueObject> tmpBindArgs = std::vector<NativeRdb::ValueObject>();
+    for (int64_t i = 0; i < size; i++) {
+        tmpBindArgs.push_back(ValueTypeToValueObject(bindArgs[i]));
     }
+    auto result = rdbStore_->QueryByStep(tmpSql, tmpBindArgs);
+    return result;
+}
 
-    int32_t RdbStoreImpl::BatchInsertEx(int64_t &insertNum, const char* tableName, ValuesBucketEx* valuesBuckets,
-        int64_t valuesSize)
-    {
-        if (rdbStore_ == nullptr || tableName == nullptr || valuesBuckets == nullptr) {
-            return -1;
-        }
-        std::vector<NativeRdb::ValuesBucket> valuesVector;
-        std::string tableNameStr = tableName;
-        if (tableNameStr.empty()) {
-            return RelationalStoreJsKit::E_PARAM_ERROR;
-        }
-        for (int64_t i = 0; i < valuesSize; i++) {
-            NativeRdb::ValuesBucket nativeValuesBucket = ConvertFromValueBucketEx(valuesBuckets[i]);
-            valuesVector.push_back(nativeValuesBucket);
-        }
-        int32_t rtnCode = rdbStore_->BatchInsert(insertNum, tableNameStr, valuesVector);
-        return rtnCode;
+std::shared_ptr<NativeRdb::ResultSet> RdbStoreImpl::QuerySqlEx(const char *sql, ValueTypeEx *bindArgs, int64_t size)
+{
+    if (sql == nullptr || bindArgs == nullptr || rdbStore_ == nullptr) {
+        return nullptr;
+    }
+    std::string tmpSql = sql;
+    std::vector<NativeRdb::ValueObject> tmpBindArgs = std::vector<NativeRdb::ValueObject>();
+    for (int64_t i = 0; i < size; i++) {
+        tmpBindArgs.push_back(ValueTypeExToValueObject(bindArgs[i]));
     }
+    auto result = rdbStore_->QueryByStep(tmpSql, tmpBindArgs);
+    return result;
+}
 
-    CArrSyncResult RdbStoreImpl::Sync(int32_t mode, RdbPredicatesImpl &predicates)
-    {
-        DistributedRdb::SyncOption option;
-        option.mode = static_cast<DistributedRdb::SyncMode>(mode);
-        option.isBlock = true;
-        DistributedRdb::SyncResult resMap;
-        if (rdbStore_ == nullptr) {
-            return CArrSyncResult{nullptr, nullptr, -1};
-        }
-        rdbStore_->Sync(option, *(predicates.GetPredicates()),
-            [&resMap](const DistributedRdb::SyncResult &result) { resMap = result; });
-        if (resMap.size() == 0) {
-            return CArrSyncResult{nullptr, nullptr, -1};
-        }
-        char** resultStr = static_cast<char**>(malloc(resMap.size() * sizeof(char*)));
-        int32_t* resultNum = static_cast<int32_t*>(malloc(resMap.size() * sizeof(int32_t)));
-        if (resultStr == nullptr || resultNum == nullptr) {
-            free(resultStr);
-            free(resultNum);
-            return CArrSyncResult{nullptr, nullptr, -1};
-        }
-        size_t i = 0;
-        for (auto it = resMap.begin(); it != resMap.end(); ++it) {
-            resultStr[i] = MallocCString(it->first);
-            resultNum[i] = it->second;
-            i++;
-        }
-        return CArrSyncResult{resultStr, resultNum, int64_t(resMap.size())};
+void RdbStoreImpl::ExecuteSql(const char *sql, ValueType *bindArgs, int64_t bindArgsSize, int32_t *errCode)
+{
+    if (sql == nullptr || bindArgs == nullptr || rdbStore_ == nullptr || errCode == nullptr) {
+        return;
     }
+    std::vector<NativeRdb::ValueObject> bindArgsObjects = std::vector<NativeRdb::ValueObject>();
+    for (int64_t i = 0; i < bindArgsSize; i++) {
+        bindArgsObjects.push_back(ValueTypeToValueObject(bindArgs[i]));
+    }
+    *errCode = rdbStore_->ExecuteSql(sql, bindArgsObjects);
+}
 
-    std::shared_ptr<NativeRdb::ResultSet> RdbStoreImpl::QuerySql(const char *sql, ValueType *bindArgs, int64_t size)
-    {
-        if (sql == nullptr || bindArgs == nullptr || rdbStore_ == nullptr) {
-            return nullptr;
-        }
-        std::string tmpSql = sql;
-        std::vector<NativeRdb::ValueObject> tmpBindArgs = std::vector<NativeRdb::ValueObject>();
-        for (int64_t i = 0; i < size; i++) {
-            tmpBindArgs.push_back(ValueTypeToValueObject(bindArgs[i]));
-        }
-        auto result = rdbStore_->QueryByStep(tmpSql, tmpBindArgs);
-        return result;
+void RdbStoreImpl::ExecuteSqlEx(const char *sql, ValueTypeEx *bindArgs, int64_t bindArgsSize, int32_t *errCode)
+{
+    if (sql == nullptr || bindArgs == nullptr || rdbStore_ == nullptr || errCode == nullptr) {
+        return;
+    }
+    std::vector<NativeRdb::ValueObject> bindArgsObjects = std::vector<NativeRdb::ValueObject>();
+    for (int64_t i = 0; i < bindArgsSize; i++) {
+        bindArgsObjects.push_back(ValueTypeExToValueObject(bindArgs[i]));
     }
+    *errCode = rdbStore_->ExecuteSql(sql, bindArgsObjects);
+}
 
-    std::shared_ptr<NativeRdb::ResultSet> RdbStoreImpl::QuerySqlEx(const char *sql, ValueTypeEx *bindArgs, int64_t size)
-    {
-        if (sql == nullptr || bindArgs == nullptr || rdbStore_ == nullptr) {
-            return nullptr;
+int32_t RdbStoreImpl::RegisterObserver(const char *event, bool interProcess, int64_t callback,
+    const std::function<void()> &callbackRef)
+{
+    DistributedRdb::SubscribeOption option;
+    option.event = event;
+    interProcess ? option.mode = DistributedRdb::SubscribeMode::LOCAL_SHARED : option.mode =
+        DistributedRdb::SubscribeMode::LOCAL;
+    if (option.mode == DistributedRdb::SubscribeMode::LOCAL) {
+        return RegisteredObserver(option, localObservers_, callback, callbackRef);
+    }
+    return RegisteredObserver(option, localSharedObservers_, callback, callbackRef);
+}
+
+bool isSameFunction(int64_t f1, int64_t f2)
+{
+    return f1 == f2;
+}
+
+bool RdbStoreImpl::HasRegisteredObserver(
+    int64_t callback,
+    std::list<std::shared_ptr<RdbStoreObserverImpl>> &observers)
+{
+    for (auto &it : observers) {
+        if (it == nullptr) {
+            return false;
         }
-        std::string tmpSql = sql;
-        std::vector<NativeRdb::ValueObject> tmpBindArgs = std::vector<NativeRdb::ValueObject>();
-        for (int64_t i = 0; i < size; i++) {
-            tmpBindArgs.push_back(ValueTypeExToValueObject(bindArgs[i]));
+        if (isSameFunction(callback, it->GetCallBack())) {
+            return true;
         }
-        auto result = rdbStore_->QueryByStep(tmpSql, tmpBindArgs);
-        return result;
     }
+    return false;
+}
 
-    void RdbStoreImpl::ExecuteSql(const char* sql, ValueType* bindArgs, int64_t bindArgsSize, int32_t *errCode)
-    {
-        if (sql == nullptr || bindArgs == nullptr || rdbStore_ == nullptr || errCode == nullptr) {
-            return;
+RdbStoreObserverImpl::RdbStoreObserverImpl(int64_t callback,
+    const std::function<void()> &callbackRef)
+{
+    m_callback = callback;
+    m_callbackRef = callbackRef;
+}
+
+int64_t RdbStoreObserverImpl::GetCallBack()
+{
+    return m_callback;
+}
+
+int32_t RdbStoreImpl::RegisteredObserver(
+    DistributedRdb::SubscribeOption option,
+    std::map<std::string, std::list<std::shared_ptr<RdbStoreObserverImpl>>> &observers,
+    int64_t callback, const std::function<void()> &callbackRef)
+{
+    observers.try_emplace(option.event);
+    if (!HasRegisteredObserver(callback, observers[option.event])) {
+        auto localObserver = std::make_shared<RdbStoreObserverImpl>(callback, callbackRef);
+        if (rdbStore_ == nullptr) {
+            return -1;
         }
-        std::vector<NativeRdb::ValueObject> bindArgsObjects = std::vector<NativeRdb::ValueObject>();
-        for (int64_t i = 0; i < bindArgsSize; i++) {
-            bindArgsObjects.push_back(ValueTypeToValueObject(bindArgs[i]));
+        int32_t errCode = rdbStore_->Subscribe(option, localObserver);
+        if (errCode != NativeRdb::E_OK) {
+            return errCode;
         }
-        *errCode = rdbStore_->ExecuteSql(sql, bindArgsObjects);
+        observers[option.event].push_back(localObserver);
+        LOGI("subscribe success event: %{public}s", option.event.c_str());
+    } else {
+        LOGI("duplicate subscribe event: %{public}s", option.event.c_str());
     }
+    return RelationalStoreJsKit::OK;
+}
 
-    void RdbStoreImpl::ExecuteSqlEx(const char* sql, ValueTypeEx* bindArgs, int64_t bindArgsSize, int32_t *errCode)
-    {
-        if (sql == nullptr || bindArgs == nullptr || rdbStore_ == nullptr || errCode == nullptr) {
-            return;
-        }
-        std::vector<NativeRdb::ValueObject> bindArgsObjects = std::vector<NativeRdb::ValueObject>();
-        for (int64_t i = 0; i < bindArgsSize; i++) {
-            bindArgsObjects.push_back(ValueTypeExToValueObject(bindArgs[i]));
-        }
-        *errCode = rdbStore_->ExecuteSql(sql, bindArgsObjects);
+int32_t RdbStoreImpl::RegisterObserverArrStr(int32_t subscribeType, int64_t callbackId)
+{
+    int32_t mode = subscribeType;
+    DistributedRdb::SubscribeOption option;
+    option.mode = static_cast<DistributedRdb::SubscribeMode>(mode);
+    option.event = "dataChange";
+    auto observer = std::make_shared<RdbStoreObserverImpl>(callbackId, RdbStoreObserverImpl::ParamArrStr, mode);
+    int32_t errCode = NativeRdb::E_OK;
+    if (rdbStore_ == nullptr) {
+        return -1;
+    }
+    if (option.mode == DistributedRdb::SubscribeMode::LOCAL_DETAIL) {
+        errCode = rdbStore_->SubscribeObserver(option, observer);
+    } else {
+        errCode = rdbStore_->Subscribe(option, observer);
+    }
+    if (errCode == NativeRdb::E_OK) {
+        observers_[mode].push_back(observer);
+        LOGI("subscribe success");
+    }
+    return errCode;
+}
+
+int32_t RdbStoreImpl::RegisterObserverChangeInfo(int32_t subscribeType, int64_t callbackId)
+{
+    int32_t mode = subscribeType;
+    DistributedRdb::SubscribeOption option;
+    option.mode = static_cast<DistributedRdb::SubscribeMode>(mode);
+    option.event = "dataChange";
+    auto observer = std::make_shared<RdbStoreObserverImpl>(callbackId, RdbStoreObserverImpl::ParamChangeInfo, mode);
+    int32_t errCode = NativeRdb::E_OK;
+    if (rdbStore_ == nullptr) {
+        return -1;
+    }
+    if (option.mode == DistributedRdb::SubscribeMode::LOCAL_DETAIL) {
+        errCode = rdbStore_->SubscribeObserver(option, observer);
+    } else {
+        errCode = rdbStore_->Subscribe(option, observer);
+    }
+    if (errCode == NativeRdb::E_OK) {
+        observers_[mode].push_back(observer);
+        LOGI("subscribe success");
+    }
+    return errCode;
+}
+
+int32_t RdbStoreImpl::RegisterObserverProgressDetails(int64_t callbackId)
+{
+    auto observer = std::make_shared<SyncObserverImpl>(callbackId);
+    if (rdbStore_ == nullptr) {
+        return -1;
+    }
+    int errCode = rdbStore_->RegisterAutoSyncCallback(observer);
+    if (errCode == NativeRdb::E_OK) {
+        syncObservers_.push_back(observer);
+        LOGI("progress subscribe success");
     }
+    return errCode;
+}
 
-    int32_t RdbStoreImpl::RegisterObserver(const char *event, bool interProcess, int64_t callback,
-        const std::function<void()>& callbackRef)
-    {
-        DistributedRdb::SubscribeOption option;
-        option.event = event;
-        interProcess ? option.mode = DistributedRdb::SubscribeMode::LOCAL_SHARED : option.mode =
-            DistributedRdb::SubscribeMode::LOCAL;
-        if (option.mode == DistributedRdb::SubscribeMode::LOCAL) {
-            return RegisteredObserver(option, localObservers_, callback, callbackRef);
-        }
-        return RegisteredObserver(option, localSharedObservers_, callback, callbackRef);
+int32_t RdbStoreImpl::UnRegisterObserver(const char *event, bool interProcess, int64_t callback)
+{
+    DistributedRdb::SubscribeOption option;
+    option.event = event;
+    interProcess ? option.mode = DistributedRdb::SubscribeMode::LOCAL_SHARED : option.mode =
+        DistributedRdb::SubscribeMode::LOCAL;
+    if (option.mode == DistributedRdb::SubscribeMode::LOCAL) {
+        return UnRegisteredObserver(option, localObservers_, callback);
     }
+    return UnRegisteredObserver(option, localSharedObservers_, callback);
+}
 
-    bool isSameFunction(int64_t f1, int64_t f2)
-    {
-        return f1 == f2;
+int32_t RdbStoreImpl::UnRegisteredObserver(DistributedRdb::SubscribeOption option,
+    std::map<std::string, std::list<std::shared_ptr<RdbStoreObserverImpl>>> &observers,
+    int64_t callback)
+{
+    auto obs = observers.find(option.event);
+    if (obs == observers.end()) {
+        LOGI("observer not found, event: %{public}s", option.event.c_str());
+        return RelationalStoreJsKit::OK;
     }
 
-    bool RdbStoreImpl::HasRegisteredObserver(
-        int64_t callback,
-        std::list<std::shared_ptr<RdbStoreObserverImpl>> &observers)
-    {
-        for (auto &it : observers) {
-            if (it == nullptr) {
-                return false;
-            }
-            if (isSameFunction(callback, it->GetCallBack())) {
-                return true;
+    auto &list = obs->second;
+    for (auto it = list.begin(); it != list.end(); it++) {
+        if (isSameFunction(callback, (*it)->GetCallBack())) {
+            int errCode = rdbStore_->UnSubscribe(option, *it);
+            if (errCode != RelationalStoreJsKit::OK) {
+                return errCode;
             }
+            list.erase(it);
+            break;
         }
-        return false;
     }
-
-    RdbStoreObserverImpl::RdbStoreObserverImpl(int64_t callback,
-        const std::function<void()>& callbackRef)
-    {
-        m_callback = callback;
-        m_callbackRef = callbackRef;
+    if (list.empty()) {
+        observers.erase(option.event);
     }
+    LOGI("unsubscribe success, event: %{public}s", option.event.c_str());
+    return RelationalStoreJsKit::OK;
+}
 
-    int64_t RdbStoreObserverImpl::GetCallBack()
-    {
-        return m_callback;
+int32_t RdbStoreImpl::UnRegisterAllObserver(const char *event, bool interProcess)
+{
+    DistributedRdb::SubscribeOption option;
+    if (event == nullptr) {
+        return -1;
     }
+    option.event = event;
+    interProcess ? option.mode = DistributedRdb::SubscribeMode::LOCAL_SHARED : option.mode =
+        DistributedRdb::SubscribeMode::LOCAL;
+    if (option.mode == DistributedRdb::SubscribeMode::LOCAL) {
+        return UnRegisteredAllObserver(option, localObservers_);
+    }
+    return UnRegisteredAllObserver(option, localSharedObservers_);
+}
 
-    int32_t RdbStoreImpl::RegisteredObserver(
-        DistributedRdb::SubscribeOption option,
-        std::map<std::string, std::list<std::shared_ptr<RdbStoreObserverImpl>>> &observers,
-        int64_t callback, const std::function<void()>& callbackRef)
-    {
-        observers.try_emplace(option.event);
-        if (!HasRegisteredObserver(callback, observers[option.event])) {
-            auto localObserver = std::make_shared<RdbStoreObserverImpl>(callback, callbackRef);
-            if (rdbStore_ == nullptr) {
-                return -1;
-            }
-            int32_t errCode = rdbStore_->Subscribe(option, localObserver);
-            if (errCode != NativeRdb::E_OK) {
-                return errCode;
-            }
-            observers[option.event].push_back(localObserver);
-            LOGI("subscribe success event: %{public}s", option.event.c_str());
-        } else {
-            LOGI("duplicate subscribe event: %{public}s", option.event.c_str());
-        }
+int32_t RdbStoreImpl::UnRegisteredAllObserver(DistributedRdb::SubscribeOption option, std::map<std::string,
+    std::list<std::shared_ptr<RdbStoreObserverImpl>>> &observers)
+{
+    auto obs = observers.find(option.event);
+    if (obs == observers.end()) {
+        LOGI("observer not found, event: %{public}s", option.event.c_str());
         return RelationalStoreJsKit::OK;
     }
 
-    int32_t RdbStoreImpl::RegisterObserverArrStr(int32_t subscribeType, int64_t callbackId)
-    {
-        int32_t mode = subscribeType;
-        DistributedRdb::SubscribeOption option;
-        option.mode = static_cast<DistributedRdb::SubscribeMode>(mode);
-        option.event = "dataChange";
-        auto observer = std::make_shared<RdbStoreObserverImpl>(callbackId, RdbStoreObserverImpl::ParamArrStr, mode);
-        int32_t errCode = NativeRdb::E_OK;
-        if (rdbStore_ == nullptr) {
-            return -1;
-        }
-        if (option.mode == DistributedRdb::SubscribeMode::LOCAL_DETAIL) {
-            errCode = rdbStore_->SubscribeObserver(option, observer);
-        } else {
-            errCode = rdbStore_->Subscribe(option, observer);
-        }
-        if (errCode == NativeRdb::E_OK) {
-            observers_[mode].push_back(observer);
-            LOGI("subscribe success");
-        }
+    int errCode = rdbStore_->UnSubscribe(option, nullptr);
+    if (errCode != RelationalStoreJsKit::OK) {
         return errCode;
     }
+    observers.erase(option.event);
+    LOGI("unsubscribe success, event: %{public}s", option.event.c_str());
+    return RelationalStoreJsKit::OK;
+}
 
-    int32_t RdbStoreImpl::RegisterObserverChangeInfo(int32_t subscribeType, int64_t callbackId)
-    {
-        int32_t mode = subscribeType;
-        DistributedRdb::SubscribeOption option;
-        option.mode = static_cast<DistributedRdb::SubscribeMode>(mode);
-        option.event = "dataChange";
-        auto observer = std::make_shared<RdbStoreObserverImpl>(callbackId, RdbStoreObserverImpl::ParamChangeInfo, mode);
-        int32_t errCode = NativeRdb::E_OK;
+int32_t RdbStoreImpl::UnRegisterObserverArrStrChangeInfo(int32_t subscribeType, int64_t callbackId)
+{
+    int32_t mode = subscribeType;
+    DistributedRdb::SubscribeOption option;
+    option.mode = static_cast<DistributedRdb::SubscribeMode>(mode);
+    option.event = "dataChange";
+    for (auto it = observers_[mode].begin(); it != observers_[mode].end();) {
+        if (*it == nullptr) {
+            it = observers_[mode].erase(it);
+            continue;
+        }
+        if (((**it).GetCallBackId() != callbackId)) {
+            ++it;
+            continue;
+        }
+        int errCode = NativeRdb::E_OK;
         if (rdbStore_ == nullptr) {
             return -1;
         }
         if (option.mode == DistributedRdb::SubscribeMode::LOCAL_DETAIL) {
-            errCode = rdbStore_->SubscribeObserver(option, observer);
+            errCode = rdbStore_->UnsubscribeObserver(option, *it);
         } else {
-            errCode = rdbStore_->Subscribe(option, observer);
+            errCode = rdbStore_->UnSubscribe(option, *it);
         }
-        if (errCode == NativeRdb::E_OK) {
-            observers_[mode].push_back(observer);
-            LOGI("subscribe success");
+        if (errCode != NativeRdb::E_OK) {
+            return errCode;
         }
-        return errCode;
+        it = observers_[mode].erase(it);
     }
+    return NativeRdb::E_OK;
+}
 
-    int32_t RdbStoreImpl::RegisterObserverProgressDetails(int64_t callbackId)
-    {
-        auto observer = std::make_shared<SyncObserverImpl>(callbackId);
+int32_t RdbStoreImpl::UnRegisterObserverArrStrChangeInfoAll(int32_t subscribeType)
+{
+    int32_t mode = subscribeType;
+    DistributedRdb::SubscribeOption option;
+    option.mode = static_cast<DistributedRdb::SubscribeMode>(mode);
+    option.event = "dataChange";
+    for (auto it = observers_[mode].begin(); it != observers_[mode].end();) {
+        if (*it == nullptr) {
+            it = observers_[mode].erase(it);
+            continue;
+        }
+        int errCode = NativeRdb::E_OK;
         if (rdbStore_ == nullptr) {
             return -1;
         }
-        int errCode = rdbStore_->RegisterAutoSyncCallback(observer);
-        if (errCode == NativeRdb::E_OK) {
-            syncObservers_.push_back(observer);
-            LOGI("progress subscribe success");
+        if (option.mode == DistributedRdb::SubscribeMode::LOCAL_DETAIL) {
+            errCode = rdbStore_->UnsubscribeObserver(option, *it);
+        } else {
+            errCode = rdbStore_->UnSubscribe(option, *it);
         }
-        return errCode;
-    }
-
-    int32_t RdbStoreImpl::UnRegisterObserver(const char *event, bool interProcess, int64_t callback)
-    {
-        DistributedRdb::SubscribeOption option;
-        option.event = event;
-        interProcess ? option.mode = DistributedRdb::SubscribeMode::LOCAL_SHARED : option.mode =
-            DistributedRdb::SubscribeMode::LOCAL;
-        if (option.mode == DistributedRdb::SubscribeMode::LOCAL) {
-            return UnRegisteredObserver(option, localObservers_, callback);
+        if (errCode != NativeRdb::E_OK) {
+            return errCode;
         }
-        return UnRegisteredObserver(option, localSharedObservers_, callback);
+        it = observers_[mode].erase(it);
     }
+    return NativeRdb::E_OK;
+}
 
-    int32_t RdbStoreImpl::UnRegisteredObserver(DistributedRdb::SubscribeOption option,
-        std::map<std::string, std::list<std::shared_ptr<RdbStoreObserverImpl>>> &observers,
-        int64_t callback)
-    {
-        auto obs = observers.find(option.event);
-        if (obs == observers.end()) {
-            LOGI("observer not found, event: %{public}s", option.event.c_str());
-            return RelationalStoreJsKit::OK;
-        }
-
-        auto &list = obs->second;
-        for (auto it = list.begin(); it != list.end(); it++) {
-            if (isSameFunction(callback, (*it)->GetCallBack())) {
-                int errCode = rdbStore_->UnSubscribe(option, *it);
-                if (errCode != RelationalStoreJsKit::OK) {
-                    return errCode;
-                }
-                list.erase(it);
-                break;
-            }
+int32_t RdbStoreImpl::UnRegisterObserverProgressDetails(int64_t callbackId)
+{
+    for (auto it = syncObservers_.begin(); it != syncObservers_.end();) {
+        if (*it == nullptr) {
+            it = syncObservers_.erase(it);
+            continue;
         }
-        if (list.empty()) {
-            observers.erase(option.event);
+        if (((**it).GetCallBackId() != callbackId)) {
+            ++it;
+            continue;
         }
-        LOGI("unsubscribe success, event: %{public}s", option.event.c_str());
-        return RelationalStoreJsKit::OK;
-    }
 
-    int32_t RdbStoreImpl::UnRegisterAllObserver(const char *event, bool interProcess)
-    {
-        DistributedRdb::SubscribeOption option;
-        if (event == nullptr) {
+        if (rdbStore_ == nullptr) {
             return -1;
         }
-        option.event = event;
-        interProcess ? option.mode = DistributedRdb::SubscribeMode::LOCAL_SHARED : option.mode =
-            DistributedRdb::SubscribeMode::LOCAL;
-        if (option.mode == DistributedRdb::SubscribeMode::LOCAL) {
-            return UnRegisteredAllObserver(option, localObservers_);
-        }
-        return UnRegisteredAllObserver(option, localSharedObservers_);
-    }
-
-    int32_t RdbStoreImpl::UnRegisteredAllObserver(DistributedRdb::SubscribeOption option, std::map<std::string,
-        std::list<std::shared_ptr<RdbStoreObserverImpl>>> &observers)
-    {
-        auto obs = observers.find(option.event);
-        if (obs == observers.end()) {
-            LOGI("observer not found, event: %{public}s", option.event.c_str());
-            return RelationalStoreJsKit::OK;
-        }
-
-        int errCode = rdbStore_->UnSubscribe(option, nullptr);
-        if (errCode != RelationalStoreJsKit::OK) {
+        int32_t errCode = rdbStore_->UnregisterAutoSyncCallback(*it);
+        if (errCode != NativeRdb::E_OK) {
             return errCode;
         }
-        observers.erase(option.event);
-        LOGI("unsubscribe success, event: %{public}s", option.event.c_str());
-        return RelationalStoreJsKit::OK;
+        it = syncObservers_.erase(it);
     }
+    return NativeRdb::E_OK;
+}
 
-    int32_t RdbStoreImpl::UnRegisterObserverArrStrChangeInfo(int32_t subscribeType, int64_t callbackId)
-    {
-        int32_t mode = subscribeType;
-        DistributedRdb::SubscribeOption option;
-        option.mode = static_cast<DistributedRdb::SubscribeMode>(mode);
-        option.event = "dataChange";
-        for (auto it = observers_[mode].begin(); it != observers_[mode].end();) {
-            if (*it == nullptr) {
-                it = observers_[mode].erase(it);
-                continue;
-            }
-            if (((**it).GetCallBackId() != callbackId)) {
-                ++it;
-                continue;
-            }
-            int errCode = NativeRdb::E_OK;
-            if (rdbStore_ == nullptr) {
-                return -1;
-            }
-            if (option.mode == DistributedRdb::SubscribeMode::LOCAL_DETAIL) {
-                errCode = rdbStore_->UnsubscribeObserver(option, *it);
-            } else {
-                errCode = rdbStore_->UnSubscribe(option, *it);
-            }
-            if (errCode != NativeRdb::E_OK) {
-                return errCode;
-            }
-            it = observers_[mode].erase(it);
+int32_t RdbStoreImpl::UnRegisterObserverProgressDetailsAll()
+{
+    for (auto it = syncObservers_.begin(); it != syncObservers_.end();) {
+        if (*it == nullptr) {
+            it = syncObservers_.erase(it);
+            continue;
         }
-        return NativeRdb::E_OK;
-    }
-    
-    int32_t RdbStoreImpl::UnRegisterObserverArrStrChangeInfoAll(int32_t subscribeType)
-    {
-        int32_t mode = subscribeType;
-        DistributedRdb::SubscribeOption option;
-        option.mode = static_cast<DistributedRdb::SubscribeMode>(mode);
-        option.event = "dataChange";
-        for (auto it = observers_[mode].begin(); it != observers_[mode].end();) {
-            if (*it == nullptr) {
-                it = observers_[mode].erase(it);
-                continue;
-            }
-            int errCode = NativeRdb::E_OK;
-            if (rdbStore_ == nullptr) {
-                return -1;
-            }
-            if (option.mode == DistributedRdb::SubscribeMode::LOCAL_DETAIL) {
-                errCode = rdbStore_->UnsubscribeObserver(option, *it);
-            } else {
-                errCode = rdbStore_->UnSubscribe(option, *it);
-            }
-            if (errCode != NativeRdb::E_OK) {
-                return errCode;
-            }
-            it = observers_[mode].erase(it);
+        if (rdbStore_ == nullptr) {
+            return -1;
         }
-        return NativeRdb::E_OK;
+        int32_t errCode = rdbStore_->UnregisterAutoSyncCallback(*it);
+        if (errCode != NativeRdb::E_OK) {
+            return errCode;
+        }
+        it = syncObservers_.erase(it);
     }
+    return NativeRdb::E_OK;
+}
 
-    int32_t RdbStoreImpl::UnRegisterObserverProgressDetails(int64_t callbackId)
-    {
-        for (auto it = syncObservers_.begin(); it != syncObservers_.end();) {
-            if (*it == nullptr) {
-                it = syncObservers_.erase(it);
-                continue;
-            }
-            if (((**it).GetCallBackId() != callbackId)) {
-                ++it;
-                continue;
-            }
+int32_t RdbStoreImpl::CloudSync(int32_t mode, CArrStr tables, int64_t callbackId)
+{
+    DistributedRdb::SyncOption option;
+    option.mode = static_cast<DistributedRdb::SyncMode>(mode);
+    option.isBlock = false;
+    std::vector<std::string> arr = CArrStrToVector(tables);
+    auto cFunc = reinterpret_cast<void(*)(CProgressDetails details)>(callbackId);
+    auto async = [ lambda = CJLambda::Create(cFunc)](const DistributedRdb::Details &details) ->
+        void { lambda(ToCProgressDetails(details)); };
+    if (rdbStore_ == nullptr) {
+        return -1;
+    }
+    int32_t errCode = rdbStore_->Sync(option, arr, async);
+    return errCode;
+}
 
-            if (rdbStore_ == nullptr) {
-                return -1;
-            }
-            int32_t errCode = rdbStore_->UnregisterAutoSyncCallback(*it);
-            if (errCode != NativeRdb::E_OK) {
-                return errCode;
-            }
-            it = syncObservers_.erase(it);
-        }
-        return NativeRdb::E_OK;
+int32_t RdbStoreImpl::GetVersion(int32_t &errCode)
+{
+    int32_t version = 0;
+    if (rdbStore_ == nullptr) {
+        return -1;
     }
+    errCode = rdbStore_->GetVersion(version);
+    return version;
+}
 
-    int32_t RdbStoreImpl::UnRegisterObserverProgressDetailsAll()
-    {
-        for (auto it = syncObservers_.begin(); it != syncObservers_.end();) {
-            if (*it == nullptr) {
-                it = syncObservers_.erase(it);
-                continue;
-            }
-            if (rdbStore_ == nullptr) {
-                return -1;
-            }
-            int32_t errCode = rdbStore_->UnregisterAutoSyncCallback(*it);
-            if (errCode != NativeRdb::E_OK) {
-                return errCode;
-            }
-            it = syncObservers_.erase(it);
-        }
-        return NativeRdb::E_OK;
+void RdbStoreImpl::SetVersion(int32_t value, int32_t &errCode)
+{
+    if (rdbStore_ == nullptr) {
+        return;
     }
+    errCode = rdbStore_->SetVersion(value);
+}
 
-    int32_t RdbStoreImpl::CloudSync(int32_t mode, CArrStr tables, int64_t callbackId)
-    {
-        DistributedRdb::SyncOption option;
-        option.mode = static_cast<DistributedRdb::SyncMode>(mode);
-        option.isBlock = false;
-        std::vector<std::string> arr = CArrStrToVector(tables);
-        auto cFunc = reinterpret_cast<void(*)(CProgressDetails details)>(callbackId);
-        auto async = [ lambda = CJLambda::Create(cFunc)](const DistributedRdb::Details &details) ->
-            void { lambda(ToCProgressDetails(details)); };
-        if (rdbStore_ == nullptr) {
-            return -1;
-        }
-        int32_t errCode = rdbStore_->Sync(option, arr, async);
-        return errCode;
+ModifyTime RdbStoreImpl::GetModifyTime(char *cTables, char *cColumnName, CArrPRIKeyType &cPrimaryKeys,
+    int32_t &errCode)
+{
+    std::string tableName = cTables;
+    std::string columnName = cColumnName;
+    std::vector<NativeRdb::RdbStore::PRIKey> keys = CArrPRIKeyTypeToPRIKeyArray(cPrimaryKeys);
+    if (rdbStore_ == nullptr) {
+        return ModifyTime{0};
+    }
+    std::map<NativeRdb::RdbStore::PRIKey, NativeRdb::RdbStore::Date> map =
+        rdbStore_->GetModifyTime(tableName, columnName, keys);
+    if (map.empty()) {
+        errCode = NativeRdb::E_ERROR;
+        return ModifyTime{0};
+    }
+    return MapToModifyTime(map, errCode);
+}
+
+int32_t RdbStoreImpl::GetRebuilt()
+{
+    auto rebuilt = NativeRdb::RebuiltType::NONE;
+    if (rdbStore_ == nullptr) {
+        return -1;
     }
+    rdbStore_->GetRebuilt(rebuilt);
+    return static_cast<int32_t>(rebuilt);
+}
 
-    int32_t RdbStoreImpl::GetVersion(int32_t& errCode)
-    {
-        int32_t version = 0;
-        if (rdbStore_ == nullptr) {
-            return -1;
-        }
-        errCode = rdbStore_->GetVersion(version);
-        return version;
+int32_t GetRealPath(AppDataMgrJsKit::JSUtils::RdbConfig &rdbConfig,
+    const AppDataMgrJsKit::JSUtils::ContextParam &param,
+    std::shared_ptr<OHOS::AppDataMgrJsKit::Context> abilitycontext)
+{
+    if (rdbConfig.name.find(PATH_SPLIT) != std::string::npos) {
+        LOGE("Parameter error. The StoreConfig.name must be a file name without path.");
+        return RelationalStoreJsKit::E_PARAM_ERROR;
     }
 
-    void RdbStoreImpl::SetVersion(int32_t value, int32_t &errCode)
-    {
-        if (rdbStore_ == nullptr) {
-            return;
+    if (!rdbConfig.customDir.empty()) {
+        // determine if the first character of customDir is '/'
+        if (rdbConfig.customDir.find_first_of(PATH_SPLIT) == 0) {
+            LOGE("Parameter error. The customDir must be a relative directory.");
+            return RelationalStoreJsKit::E_PARAM_ERROR;
+        }
+        // customDir length is limited to 128 bytes
+        if (rdbConfig.customDir.length() > 128) {
+            LOGE("Parameter error. The customDir length must be less than or equal to 128 bytes.");
+            return RelationalStoreJsKit::E_PARAM_ERROR;
         }
-        errCode = rdbStore_->SetVersion(value);
     }
 
-    ModifyTime RdbStoreImpl::GetModifyTime(char *cTables, char *cColumnName, CArrPRIKeyType &cPrimaryKeys,
-        int32_t& errCode)
-    {
-        std::string tableName = cTables;
-        std::string columnName = cColumnName;
-        std::vector<NativeRdb::RdbStore::PRIKey> keys = CArrPRIKeyTypeToPRIKeyArray(cPrimaryKeys);
-        if (rdbStore_ == nullptr) {
-            return ModifyTime{0};
+    std::string baseDir = param.baseDir;
+    if (!rdbConfig.dataGroupId.empty()) {
+        if (!param.isStageMode) {
+            return RelationalStoreJsKit::E_NOT_STAGE_MODE;
         }
-        std::map<NativeRdb::RdbStore::PRIKey, NativeRdb::RdbStore::Date> map =
-            rdbStore_->GetModifyTime(tableName, columnName, keys);
-        if (map.empty()) {
-            errCode = NativeRdb::E_ERROR;
-            return ModifyTime{0};
+        std::string groupDir;
+        int errCode = abilitycontext->GetSystemDatabaseDir(rdbConfig.dataGroupId, groupDir);
+        if (errCode != NativeRdb::E_OK && groupDir.empty()) {
+            return RelationalStoreJsKit::E_DATA_GROUP_ID_INVALID;
         }
-        return MapToModifyTime(map, errCode);
+        baseDir = groupDir;
     }
 
-    int32_t RdbStoreImpl::GetRebuilt()
-    {
-        auto rebuilt = NativeRdb::RebuiltType::NONE;
-        if (rdbStore_ == nullptr) {
-            return -1;
-        }
-        rdbStore_->GetRebuilt(rebuilt);
-        return static_cast<int32_t>(rebuilt);
+    auto [realPath, errorCode] =
+        NativeRdb::RdbSqlUtils::GetDefaultDatabasePath(baseDir, rdbConfig.name, rdbConfig.customDir);
+    // realPath length is limited to 1024 bytes
+    if (errorCode != NativeRdb::E_OK || realPath.length() > 1024) {
+        LOGE("Parameter error. The database path must be a valid path.");
+        return RelationalStoreJsKit::E_PARAM_ERROR;
     }
+    rdbConfig.path = realPath;
+    return NativeRdb::E_OK;
+}
 
-    int32_t GetRealPath(AppDataMgrJsKit::JSUtils::RdbConfig &rdbConfig,
-        const AppDataMgrJsKit::JSUtils::ContextParam &param,
-        std::shared_ptr<OHOS::AppDataMgrJsKit::Context> abilitycontext)
-    {
-        if (rdbConfig.name.find(PATH_SPLIT) != std::string::npos) {
-            LOGE("Parameter error. The StoreConfig.name must be a file name without path.");
-            return RelationalStoreJsKit::E_PARAM_ERROR;
-        }
+void initContextParam(AppDataMgrJsKit::JSUtils::ContextParam &param,
+    std::shared_ptr<OHOS::AppDataMgrJsKit::Context> abilitycontext)
+{
+    param.bundleName = abilitycontext->GetBundleName();
+    param.moduleName = abilitycontext->GetModuleName();
+    param.baseDir = abilitycontext->GetDatabaseDir();
+    param.area = abilitycontext->GetArea();
+    param.isSystemApp = abilitycontext->IsSystemAppCalled();
+    param.isStageMode = abilitycontext->IsStageMode();
+}
 
-        if (!rdbConfig.customDir.empty()) {
-            // determine if the first character of customDir is '/'
-            if (rdbConfig.customDir.find_first_of(PATH_SPLIT) == 0) {
-                LOGE("Parameter error. The customDir must be a relative directory.");
-                return RelationalStoreJsKit::E_PARAM_ERROR;
-            }
-            // customDir length is limited to 128 bytes
-            if (rdbConfig.customDir.length() > 128) {
-                LOGE("Parameter error. The customDir length must be less than or equal to 128 bytes.");
-                return RelationalStoreJsKit::E_PARAM_ERROR;
-            }
-        }
+void initRdbConfig(AppDataMgrJsKit::JSUtils::RdbConfig &rdbConfig, StoreConfig &config)
+{
+    rdbConfig.isEncrypt = config.encrypt;
+    rdbConfig.isSearchable = config.isSearchable;
+    rdbConfig.isAutoClean = config.autoCleanDirtyData;
+    rdbConfig.securityLevel = static_cast<NativeRdb::SecurityLevel>(config.securityLevel);
+    rdbConfig.dataGroupId = config.dataGroupId;
+    rdbConfig.name = config.name;
+    rdbConfig.customDir = config.customDir;
+}
 
-        std::string baseDir = param.baseDir;
-        if (!rdbConfig.dataGroupId.empty()) {
-            if (!param.isStageMode) {
-                return RelationalStoreJsKit::E_NOT_STAGE_MODE;
-            }
-            std::string groupDir;
-            int errCode = abilitycontext->GetSystemDatabaseDir(rdbConfig.dataGroupId, groupDir);
-            if (errCode != NativeRdb::E_OK && groupDir.empty()) {
-                return RelationalStoreJsKit::E_DATA_GROUP_ID_INVALID;
-            }
-            baseDir = groupDir;
-        }
+void initRdbConfigEx(AppDataMgrJsKit::JSUtils::RdbConfig &rdbConfig, const StoreConfigEx &config)
+{
+    rdbConfig.isEncrypt = config.encrypt;
+    rdbConfig.isSearchable = config.isSearchable;
+    rdbConfig.isAutoClean = config.autoCleanDirtyData;
+    rdbConfig.securityLevel = static_cast<NativeRdb::SecurityLevel>(config.securityLevel);
+    rdbConfig.dataGroupId = config.dataGroupId;
+    rdbConfig.name = config.name;
+    rdbConfig.customDir = config.customDir;
+    rdbConfig.rootDir = config.rootDir;
+    rdbConfig.vector = config.vector;
+    rdbConfig.allowRebuild = config.allowRebuild;
+    rdbConfig.isReadOnly = config.isReadOnly;
+    rdbConfig.pluginLibs = CArrStrToVector(config.pluginLibs);
+    rdbConfig.cryptoParam = ToCCryptoParam(config.cryptoParam);
+    rdbConfig.tokenizer = static_cast<OHOS::NativeRdb::Tokenizer>(config.tokenizer);
+    rdbConfig.persist = config.persist;
+}
 
-        auto [realPath, errorCode] =
-            NativeRdb::RdbSqlUtils::GetDefaultDatabasePath(baseDir, rdbConfig.name, rdbConfig.customDir);
-        // realPath length is limited to 1024 bytes
-        if (errorCode != NativeRdb::E_OK || realPath.length() > 1024) {
-            LOGE("Parameter error. The database path must be a valid path.");
-            return RelationalStoreJsKit::E_PARAM_ERROR;
-        }
-        rdbConfig.path = realPath;
-        return NativeRdb::E_OK;
-    }
+NativeRdb::RdbStoreConfig getRdbStoreConfig(const AppDataMgrJsKit::JSUtils::RdbConfig &rdbConfig,
+    const AppDataMgrJsKit::JSUtils::ContextParam &param)
+{
+    NativeRdb::RdbStoreConfig rdbStoreConfig(rdbConfig.path);
+    rdbStoreConfig.SetEncryptStatus(rdbConfig.isEncrypt);
+    rdbStoreConfig.SetSearchable(rdbConfig.isSearchable);
+    rdbStoreConfig.SetIsVector(rdbConfig.vector);
+    rdbStoreConfig.SetAutoClean(rdbConfig.isAutoClean);
+    rdbStoreConfig.SetSecurityLevel(rdbConfig.securityLevel);
+    rdbStoreConfig.SetDataGroupId(rdbConfig.dataGroupId);
+    rdbStoreConfig.SetName(rdbConfig.name);
+    rdbStoreConfig.SetCustomDir(rdbConfig.customDir);
+    rdbStoreConfig.SetAllowRebuild(rdbConfig.allowRebuild);
+
+    if (!param.bundleName.empty()) {
+        rdbStoreConfig.SetBundleName(param.bundleName);
+    }
+    rdbStoreConfig.SetModuleName(param.moduleName);
+    rdbStoreConfig.SetArea(param.area);
+    return rdbStoreConfig;
+}
 
-    void initContextParam(AppDataMgrJsKit::JSUtils::ContextParam &param,
-        std::shared_ptr<OHOS::AppDataMgrJsKit::Context> abilitycontext)
-    {
-        param.bundleName = abilitycontext->GetBundleName();
-        param.moduleName = abilitycontext->GetModuleName();
-        param.baseDir = abilitycontext->GetDatabaseDir();
-        param.area = abilitycontext->GetArea();
-        param.isSystemApp = abilitycontext->IsSystemAppCalled();
-        param.isStageMode = abilitycontext->IsStageMode();
-    }
+NativeRdb::RdbStoreConfig getRdbStoreConfigEx(const AppDataMgrJsKit::JSUtils::RdbConfig &rdbConfig,
+    const AppDataMgrJsKit::JSUtils::ContextParam &param)
+{
+    NativeRdb::RdbStoreConfig rdbStoreConfig(rdbConfig.path);
+    rdbStoreConfig.SetEncryptStatus(rdbConfig.isEncrypt);
+    rdbStoreConfig.SetSearchable(rdbConfig.isSearchable);
+    rdbStoreConfig.SetIsVector(rdbConfig.vector);
+    rdbStoreConfig.SetDBType(rdbConfig.vector ? NativeRdb::DB_VECTOR : NativeRdb::DB_SQLITE);
+    rdbStoreConfig.SetStorageMode(rdbConfig.persist ? NativeRdb::StorageMode::MODE_DISK :
+        NativeRdb::StorageMode::MODE_MEMORY);
+    rdbStoreConfig.SetAutoClean(rdbConfig.isAutoClean);
+    rdbStoreConfig.SetSecurityLevel(rdbConfig.securityLevel);
+    rdbStoreConfig.SetDataGroupId(rdbConfig.dataGroupId);
+    rdbStoreConfig.SetName(rdbConfig.name);
+    rdbStoreConfig.SetCustomDir(rdbConfig.customDir);
+    rdbStoreConfig.SetAllowRebuild(rdbConfig.allowRebuild);
+    rdbStoreConfig.SetReadOnly(rdbConfig.isReadOnly);
+    rdbStoreConfig.SetIntegrityCheck(NativeRdb::IntegrityCheck::NONE);
+    rdbStoreConfig.SetTokenizer(rdbConfig.tokenizer);
+
+    if (!param.bundleName.empty()) {
+        rdbStoreConfig.SetBundleName(param.bundleName);
+    }
+    rdbStoreConfig.SetModuleName(param.moduleName);
+    rdbStoreConfig.SetArea(param.area);
+    rdbStoreConfig.SetPluginLibs(rdbConfig.pluginLibs);
+    rdbStoreConfig.SetHaMode(rdbConfig.haMode);
+
+    rdbStoreConfig.SetCryptoParam(rdbConfig.cryptoParam);
+    return rdbStoreConfig;
+}
 
-    void initRdbConfig(AppDataMgrJsKit::JSUtils::RdbConfig &rdbConfig, StoreConfig &config)
-    {
-        rdbConfig.isEncrypt = config.encrypt;
-        rdbConfig.isSearchable = config.isSearchable;
-        rdbConfig.isAutoClean = config.autoCleanDirtyData;
-        rdbConfig.securityLevel = static_cast<NativeRdb::SecurityLevel>(config.securityLevel);
-        rdbConfig.dataGroupId = config.dataGroupId;
-        rdbConfig.name = config.name;
-        rdbConfig.customDir = config.customDir;
+int64_t GetRdbStore(OHOS::AbilityRuntime::Context *context, StoreConfig config,
+    int32_t *errCode)
+{
+    if (errCode == nullptr) {
+        return -1;
     }
+    if (context == nullptr) {
+        *errCode = -1;
+        return -1;
+    }
+    auto abilitycontext = std::make_shared<AppDataMgrJsKit::Context>(context->shared_from_this());
+    AppDataMgrJsKit::JSUtils::ContextParam param;
+    initContextParam(param, abilitycontext);
+    AppDataMgrJsKit::JSUtils::RdbConfig rdbConfig;
+    initRdbConfig(rdbConfig, config);
 
-    void initRdbConfigEx(AppDataMgrJsKit::JSUtils::RdbConfig &rdbConfig, const StoreConfigEx &config)
-    {
-        rdbConfig.isEncrypt = config.encrypt;
-        rdbConfig.isSearchable = config.isSearchable;
-        rdbConfig.isAutoClean = config.autoCleanDirtyData;
-        rdbConfig.securityLevel = static_cast<NativeRdb::SecurityLevel>(config.securityLevel);
-        rdbConfig.dataGroupId = config.dataGroupId;
-        rdbConfig.name = config.name;
-        rdbConfig.customDir = config.customDir;
-        rdbConfig.rootDir = config.rootDir;
-        rdbConfig.vector = config.vector;
-        rdbConfig.allowRebuild = config.allowRebuild;
-        rdbConfig.isReadOnly = config.isReadOnly;
-        rdbConfig.pluginLibs = CArrStrToVector(config.pluginLibs);
-        rdbConfig.cryptoParam = ToCCryptoParam(config.cryptoParam);
-        rdbConfig.tokenizer = static_cast<OHOS::NativeRdb::Tokenizer>(config.tokenizer);
-        rdbConfig.persist = config.persist;
-    }
-
-    NativeRdb::RdbStoreConfig getRdbStoreConfig(const AppDataMgrJsKit::JSUtils::RdbConfig &rdbConfig,
-        const AppDataMgrJsKit::JSUtils::ContextParam &param)
-    {
-        NativeRdb::RdbStoreConfig rdbStoreConfig(rdbConfig.path);
-        rdbStoreConfig.SetEncryptStatus(rdbConfig.isEncrypt);
-        rdbStoreConfig.SetSearchable(rdbConfig.isSearchable);
-        rdbStoreConfig.SetIsVector(rdbConfig.vector);
-        rdbStoreConfig.SetAutoClean(rdbConfig.isAutoClean);
-        rdbStoreConfig.SetSecurityLevel(rdbConfig.securityLevel);
-        rdbStoreConfig.SetDataGroupId(rdbConfig.dataGroupId);
-        rdbStoreConfig.SetName(rdbConfig.name);
-        rdbStoreConfig.SetCustomDir(rdbConfig.customDir);
-        rdbStoreConfig.SetAllowRebuild(rdbConfig.allowRebuild);
-
-        if (!param.bundleName.empty()) {
-            rdbStoreConfig.SetBundleName(param.bundleName);
-        }
-        rdbStoreConfig.SetModuleName(param.moduleName);
-        rdbStoreConfig.SetArea(param.area);
-        return rdbStoreConfig;
+    *errCode = GetRealPath(rdbConfig, param, abilitycontext);
+    if (*errCode != NativeRdb::E_OK) {
+        return -1;
     }
 
-    NativeRdb::RdbStoreConfig getRdbStoreConfigEx(const AppDataMgrJsKit::JSUtils::RdbConfig &rdbConfig,
-        const AppDataMgrJsKit::JSUtils::ContextParam &param)
-    {
-        NativeRdb::RdbStoreConfig rdbStoreConfig(rdbConfig.path);
-        rdbStoreConfig.SetEncryptStatus(rdbConfig.isEncrypt);
-        rdbStoreConfig.SetSearchable(rdbConfig.isSearchable);
-        rdbStoreConfig.SetIsVector(rdbConfig.vector);
-        rdbStoreConfig.SetDBType(rdbConfig.vector ? NativeRdb::DB_VECTOR : NativeRdb::DB_SQLITE);
-        rdbStoreConfig.SetStorageMode(rdbConfig.persist ? NativeRdb::StorageMode::MODE_DISK :
-            NativeRdb::StorageMode::MODE_MEMORY);
-        rdbStoreConfig.SetAutoClean(rdbConfig.isAutoClean);
-        rdbStoreConfig.SetSecurityLevel(rdbConfig.securityLevel);
-        rdbStoreConfig.SetDataGroupId(rdbConfig.dataGroupId);
-        rdbStoreConfig.SetName(rdbConfig.name);
-        rdbStoreConfig.SetCustomDir(rdbConfig.customDir);
-        rdbStoreConfig.SetAllowRebuild(rdbConfig.allowRebuild);
-        rdbStoreConfig.SetReadOnly(rdbConfig.isReadOnly);
-        rdbStoreConfig.SetIntegrityCheck(NativeRdb::IntegrityCheck::NONE);
-        rdbStoreConfig.SetTokenizer(rdbConfig.tokenizer);
-
-        if (!param.bundleName.empty()) {
-            rdbStoreConfig.SetBundleName(param.bundleName);
-        }
-        rdbStoreConfig.SetModuleName(param.moduleName);
-        rdbStoreConfig.SetArea(param.area);
-        rdbStoreConfig.SetPluginLibs(rdbConfig.pluginLibs);
-        rdbStoreConfig.SetHaMode(rdbConfig.haMode);
+    DefaultOpenCallback callback;
+    auto rdbStore =
+        NativeRdb::RdbHelper::GetRdbStore(getRdbStoreConfig(rdbConfig, param), -1, callback, *errCode);
+    if (*errCode != 0) {
+        return -1;
+    }
+    auto nativeRdbStore = FFIData::Create<RdbStoreImpl>(rdbStore);
+    if (nativeRdbStore == nullptr) {
+        *errCode = -1;
+        return -1;
+    }
+    return nativeRdbStore->GetID();
+}
 
-        rdbStoreConfig.SetCryptoParam(rdbConfig.cryptoParam);
-        return rdbStoreConfig;
+int64_t GetRdbStoreEx(OHOS::AbilityRuntime::Context *context, const StoreConfigEx *config,
+    int32_t *errCode)
+{
+    if (errCode == nullptr) {
+        return -1;
+    }
+    if (context == nullptr) {
+        *errCode = ERROR_VALUE;
+        return ERROR_VALUE;
+    }
+    auto abilitycontext = std::make_shared<AppDataMgrJsKit::Context>(context->shared_from_this());
+    AppDataMgrJsKit::JSUtils::ContextParam param;
+    initContextParam(param, abilitycontext);
+    AppDataMgrJsKit::JSUtils::RdbConfig rdbConfig;
+    initRdbConfigEx(rdbConfig, *config);
+    if (!rdbConfig.cryptoParam.IsValid()) {
+        *errCode = RelationalStoreJsKit::E_PARAM_ERROR;
+        return ERROR_VALUE;
     }
 
-    int64_t GetRdbStore(OHOS::AbilityRuntime::Context* context, StoreConfig config,
-        int32_t *errCode)
-    {
-        if (errCode == nullptr) {
-            return -1;
-        }
-        if (context == nullptr) {
-            *errCode = -1;
-            return -1;
-        }
-        auto abilitycontext = std::make_shared<AppDataMgrJsKit::Context>(context->shared_from_this());
-        AppDataMgrJsKit::JSUtils::ContextParam param;
-        initContextParam(param, abilitycontext);
-        AppDataMgrJsKit::JSUtils::RdbConfig rdbConfig;
-        initRdbConfig(rdbConfig, config);
-
-        *errCode = GetRealPath(rdbConfig, param, abilitycontext);
-        if (*errCode != NativeRdb::E_OK) {
-            return -1;
-        }
+    *errCode = GetRealPath(rdbConfig, param, abilitycontext);
+    if (*errCode != NativeRdb::E_OK) {
+        return ERROR_VALUE;
+    }
 
-        DefaultOpenCallback callback;
-        auto rdbStore =
-            NativeRdb::RdbHelper::GetRdbStore(getRdbStoreConfig(rdbConfig, param), -1, callback, *errCode);
-        if (*errCode != 0) {
-            return -1;
-        }
-        auto nativeRdbStore = FFIData::Create<RdbStoreImpl>(rdbStore);
-        if (nativeRdbStore == nullptr) {
-            *errCode = -1;
-            return -1;
-        }
-        return nativeRdbStore->GetID();
+    DefaultOpenCallback callback;
+    auto rdbStore =
+        NativeRdb::RdbHelper::GetRdbStore(getRdbStoreConfigEx(rdbConfig, param), -1, callback, *errCode);
+    if (*errCode != 0) {
+        return ERROR_VALUE;
+    }
+    auto nativeRdbStore = FFIData::Create<RdbStoreImpl>(rdbStore);
+    if (nativeRdbStore == nullptr) {
+        *errCode = ERROR_VALUE;
+        return ERROR_VALUE;
     }
+    return nativeRdbStore->GetID();
+}
 
-    int64_t GetRdbStoreEx(OHOS::AbilityRuntime::Context* context, const StoreConfigEx *config,
-        int32_t *errCode)
-    {
-        if (errCode == nullptr) {
-            return -1;
-        }
-        if (context == nullptr) {
-            *errCode = ERROR_VALUE;
-            return ERROR_VALUE;
-        }
-        auto abilitycontext = std::make_shared<AppDataMgrJsKit::Context>(context->shared_from_this());
-        AppDataMgrJsKit::JSUtils::ContextParam param;
-        initContextParam(param, abilitycontext);
-        AppDataMgrJsKit::JSUtils::RdbConfig rdbConfig;
-        initRdbConfigEx(rdbConfig, *config);
-        if (!rdbConfig.cryptoParam.IsValid()) {
-            *errCode = RelationalStoreJsKit::E_PARAM_ERROR;
-            return ERROR_VALUE;
-        }
+void DeleteRdbStore(OHOS::AbilityRuntime::Context *context, const char *name,
+    int32_t *errCode)
+{
+    if (errCode == nullptr) {
+        return;
+    }
+    if (context == nullptr) {
+        *errCode = -1;
+        return;
+    }
+    auto abilitycontext = std::make_shared<AppDataMgrJsKit::Context>(context->shared_from_this());
+    AppDataMgrJsKit::JSUtils::ContextParam param;
+    initContextParam(param, abilitycontext);
+    AppDataMgrJsKit::JSUtils::RdbConfig rdbConfig;
+    rdbConfig.name = name;
 
-        *errCode = GetRealPath(rdbConfig, param, abilitycontext);
-        if (*errCode != NativeRdb::E_OK) {
-            return ERROR_VALUE;
-        }
+    *errCode = GetRealPath(rdbConfig, param, abilitycontext);
+    if (*errCode != NativeRdb::E_OK) {
+        return;
+    }
+    *errCode = NativeRdb::RdbHelper::DeleteRdbStore(rdbConfig.path, false);
+    return;
+}
 
-        DefaultOpenCallback callback;
-        auto rdbStore =
-            NativeRdb::RdbHelper::GetRdbStore(getRdbStoreConfigEx(rdbConfig, param), -1, callback, *errCode);
-        if (*errCode != 0) {
-            return ERROR_VALUE;
-        }
-        auto nativeRdbStore = FFIData::Create<RdbStoreImpl>(rdbStore);
-        if (nativeRdbStore == nullptr) {
-            *errCode = ERROR_VALUE;
-            return ERROR_VALUE;
-        }
-        return nativeRdbStore->GetID();
+void DeleteRdbStoreConfig(OHOS::AbilityRuntime::Context *context, StoreConfig config,
+    int32_t *errCode)
+{
+    if (errCode == nullptr) {
+        return;
+    }
+    if (context == nullptr) {
+        *errCode = -1;
+        return;
     }
+    auto abilitycontext = std::make_shared<AppDataMgrJsKit::Context>(context->shared_from_this());
+    AppDataMgrJsKit::JSUtils::ContextParam param;
+    initContextParam(param, abilitycontext);
+    AppDataMgrJsKit::JSUtils::RdbConfig rdbConfig;
+    initRdbConfig(rdbConfig, config);
 
-    void DeleteRdbStore(OHOS::AbilityRuntime::Context* context, const char* name,
-        int32_t *errCode)
-    {
-        if (errCode == nullptr) {
-            return;
-        }
-        if (context == nullptr) {
-            *errCode = -1;
-            return;
-        }
-        auto abilitycontext = std::make_shared<AppDataMgrJsKit::Context>(context->shared_from_this());
-        AppDataMgrJsKit::JSUtils::ContextParam param;
-        initContextParam(param, abilitycontext);
-        AppDataMgrJsKit::JSUtils::RdbConfig rdbConfig;
-        rdbConfig.name = name;
-
-        *errCode = GetRealPath(rdbConfig, param, abilitycontext);
-        if (*errCode != NativeRdb::E_OK) {
-            return;
-        }
-        *errCode = NativeRdb::RdbHelper::DeleteRdbStore(rdbConfig.path, false);
+    *errCode = GetRealPath(rdbConfig, param, abilitycontext);
+    if (*errCode != NativeRdb::E_OK) {
         return;
     }
+    *errCode = NativeRdb::RdbHelper::DeleteRdbStore(rdbConfig.path, false);
+    return;
+}
 
-    void DeleteRdbStoreConfig(OHOS::AbilityRuntime::Context* context, StoreConfig config,
-        int32_t *errCode)
-    {
-        if (errCode == nullptr) {
-            return;
-        }
-        if (context == nullptr) {
-            *errCode = -1;
-            return;
-        }
-        auto abilitycontext = std::make_shared<AppDataMgrJsKit::Context>(context->shared_from_this());
-        AppDataMgrJsKit::JSUtils::ContextParam param;
-        initContextParam(param, abilitycontext);
-        AppDataMgrJsKit::JSUtils::RdbConfig rdbConfig;
-        initRdbConfig(rdbConfig, config);
-
-        *errCode = GetRealPath(rdbConfig, param, abilitycontext);
-        if (*errCode != NativeRdb::E_OK) {
-            return;
-        }
-        *errCode = NativeRdb::RdbHelper::DeleteRdbStore(rdbConfig.path, false);
+void DeleteRdbStoreConfigEx(OHOS::AbilityRuntime::Context *context, const StoreConfigEx *config,
+    int32_t *errCode)
+{
+    if (errCode == nullptr) {
         return;
     }
+    if (context == nullptr || config == nullptr) {
+        *errCode = ERROR_VALUE;
+        return;
+    }
+    auto abilitycontext = std::make_shared<AppDataMgrJsKit::Context>(context->shared_from_this());
+    AppDataMgrJsKit::JSUtils::ContextParam param;
+    initContextParam(param, abilitycontext);
+    AppDataMgrJsKit::JSUtils::RdbConfig rdbConfig;
+    initRdbConfigEx(rdbConfig, *config);
 
-    void DeleteRdbStoreConfigEx(OHOS::AbilityRuntime::Context* context, const StoreConfigEx *config,
-        int32_t *errCode)
-    {
-        if (errCode == nullptr) {
-            return;
-        }
-        if (context == nullptr || config == nullptr) {
-            *errCode = ERROR_VALUE;
-            return;
-        }
-        auto abilitycontext = std::make_shared<AppDataMgrJsKit::Context>(context->shared_from_this());
-        AppDataMgrJsKit::JSUtils::ContextParam param;
-        initContextParam(param, abilitycontext);
-        AppDataMgrJsKit::JSUtils::RdbConfig rdbConfig;
-        initRdbConfigEx(rdbConfig, *config);
-
-        *errCode = GetRealPath(rdbConfig, param, abilitycontext);
-        if (*errCode != NativeRdb::E_OK) {
-            return;
-        }
-        *errCode = NativeRdb::RdbHelper::DeleteRdbStore(rdbConfig.path, false);
+    *errCode = GetRealPath(rdbConfig, param, abilitycontext);
+    if (*errCode != NativeRdb::E_OK) {
         return;
     }
+    *errCode = NativeRdb::RdbHelper::DeleteRdbStore(rdbConfig.path, false);
+    return;
 }
-}
\ No newline at end of file
+} // namespace Relational
+} // namespace OHOS
\ No newline at end of file
diff --git a/frameworks/cj/src/relational_store_impl_resultsetproxy.cpp b/frameworks/cj/src/relational_store_impl_resultsetproxy.cpp
index 531d0159bbd293cf7278333151e3f984ca786e47..319b47f7efcc9467ae0ae3b88f8e9c536ef0b307 100644
--- a/frameworks/cj/src/relational_store_impl_resultsetproxy.cpp
+++ b/frameworks/cj/src/relational_store_impl_resultsetproxy.cpp
@@ -23,431 +23,431 @@
 
 namespace OHOS {
 namespace Relational {
-    static const int E_OK = 0;
+static const int E_OK = 0;
 
-    ResultSetImpl::ResultSetImpl(std::shared_ptr<NativeRdb::ResultSet> resultSet)
-    {
-        resultSetValue = resultSet;
-    }
+ResultSetImpl::ResultSetImpl(std::shared_ptr<NativeRdb::ResultSet> resultSet)
+{
+    resultSetValue = resultSet;
+}
 
-    OHOS::FFI::RuntimeType* ResultSetImpl::GetClassType()
-    {
-        static OHOS::FFI::RuntimeType runtimeType = OHOS::FFI::RuntimeType::Create<OHOS::FFI::FFIData>("ResultSetImpl");
-        return &runtimeType;
-    }
+OHOS::FFI::RuntimeType *ResultSetImpl::GetClassType()
+{
+    static OHOS::FFI::RuntimeType runtimeType = OHOS::FFI::RuntimeType::Create<OHOS::FFI::FFIData>("ResultSetImpl");
+    return &runtimeType;
+}
 
-    CArrStr ResultSetImpl::GetAllColumnNames()
-    {
-        std::vector<std::string> colNames;
-        if (resultSetValue == nullptr) {
-            return CArrStr{nullptr, 0};
-        }
-        int errCode = resultSetValue->GetAllColumnNames(colNames);
-        if (errCode != RelationalStoreJsKit::OK) {
-            LOGE("GetAllColumnNames failed code: %{public}d", errCode);
-            return CArrStr{nullptr, 0};
-        }
-        if (colNames.size() == 0) {
-            return CArrStr{nullptr, 0};
-        }
-        char** result = static_cast<char**>(malloc(colNames.size() * sizeof(char*)));
-        if (result == nullptr) {
-            return CArrStr{nullptr, -1};
-        }
-        for (size_t i = 0; i < colNames.size(); i++) {
-            result[i] = MallocCString(colNames[i]);
-            if (result[i] == nullptr) {
-                for (size_t j = 0; j < i; j++) {
-                    free(result[j]);
-                }
-                free(result);
-                return CArrStr{nullptr, -1};
+CArrStr ResultSetImpl::GetAllColumnNames()
+{
+    std::vector<std::string> colNames;
+    if (resultSetValue == nullptr) {
+        return CArrStr{nullptr, 0};
+    }
+    int errCode = resultSetValue->GetAllColumnNames(colNames);
+    if (errCode != RelationalStoreJsKit::OK) {
+        LOGE("GetAllColumnNames failed code: %{public}d", errCode);
+        return CArrStr{nullptr, 0};
+    }
+    if (colNames.size() == 0) {
+        return CArrStr{nullptr, 0};
+    }
+    char **result = static_cast<char**>(malloc(colNames.size() * sizeof(char*)));
+    if (result == nullptr) {
+        return CArrStr{nullptr, -1};
+    }
+    for (size_t i = 0; i < colNames.size(); i++) {
+        result[i] = MallocCString(colNames[i]);
+        if (result[i] == nullptr) {
+            for (size_t j = 0; j < i; j++) {
+                free(result[j]);
             }
+            free(result);
+            return CArrStr{nullptr, -1};
         }
-        return CArrStr{result, int64_t(colNames.size())};
     }
+    return CArrStr{result, int64_t(colNames.size())};
+}
 
-    int32_t ResultSetImpl::GetColumnCount()
-    {
-        int32_t count = 0;
-        if (resultSetValue == nullptr) {
-            return count;
-        }
-        int errCode = resultSetValue->GetColumnCount(count);
-        if (errCode != RelationalStoreJsKit::OK) {
-            LOGE("GetColumnCount failed code:%{public}d", errCode);
-        }
+int32_t ResultSetImpl::GetColumnCount()
+{
+    int32_t count = 0;
+    if (resultSetValue == nullptr) {
         return count;
     }
+    int errCode = resultSetValue->GetColumnCount(count);
+    if (errCode != RelationalStoreJsKit::OK) {
+        LOGE("GetColumnCount failed code:%{public}d", errCode);
+    }
+    return count;
+}
 
-    int32_t ResultSetImpl::GetRowCount()
-    {
-        int32_t result;
-        if (resultSetValue == nullptr) {
-            return -1;
-        }
-        int errCode = resultSetValue->GetRowCount(result);
-        if (errCode != RelationalStoreJsKit::OK) {
-            LOGE("GetRowCount failed code:%{public}d", errCode);
-        }
-        return result;
+int32_t ResultSetImpl::GetRowCount()
+{
+    int32_t result;
+    if (resultSetValue == nullptr) {
+        return -1;
+    }
+    int errCode = resultSetValue->GetRowCount(result);
+    if (errCode != RelationalStoreJsKit::OK) {
+        LOGE("GetRowCount failed code:%{public}d", errCode);
     }
+    return result;
+}
 
-    int32_t ResultSetImpl::GetRowIndex()
-    {
-        int32_t result;
-        if (resultSetValue == nullptr) {
-            return -1;
-        }
-        int errCode = resultSetValue->GetRowIndex(result);
-        if (errCode != RelationalStoreJsKit::OK) {
-            LOGE("GetRowIndex failed code:%{public}d", errCode);
-        }
-        return result;
+int32_t ResultSetImpl::GetRowIndex()
+{
+    int32_t result;
+    if (resultSetValue == nullptr) {
+        return -1;
     }
+    int errCode = resultSetValue->GetRowIndex(result);
+    if (errCode != RelationalStoreJsKit::OK) {
+        LOGE("GetRowIndex failed code:%{public}d", errCode);
+    }
+    return result;
+}
 
-    bool ResultSetImpl::IsAtFirstRow()
-    {
-        bool result = false;
-        if (resultSetValue == nullptr) {
-            return result;
-        }
-        int errCode = resultSetValue->IsAtFirstRow(result);
-        if (errCode != RelationalStoreJsKit::OK) {
-            LOGE("IsAtFirstRow failed code:%{public}d", errCode);
-        }
+bool ResultSetImpl::IsAtFirstRow()
+{
+    bool result = false;
+    if (resultSetValue == nullptr) {
         return result;
     }
+    int errCode = resultSetValue->IsAtFirstRow(result);
+    if (errCode != RelationalStoreJsKit::OK) {
+        LOGE("IsAtFirstRow failed code:%{public}d", errCode);
+    }
+    return result;
+}
 
-    bool ResultSetImpl::IsAtLastRow()
-    {
-        bool result = false;
-        if (resultSetValue == nullptr) {
-            return result;
-        }
-        int errCode = resultSetValue->IsAtLastRow(result);
-        if (errCode != RelationalStoreJsKit::OK) {
-            LOGE("IsAtLastRow failed code:%{public}d", errCode);
-        }
+bool ResultSetImpl::IsAtLastRow()
+{
+    bool result = false;
+    if (resultSetValue == nullptr) {
         return result;
     }
+    int errCode = resultSetValue->IsAtLastRow(result);
+    if (errCode != RelationalStoreJsKit::OK) {
+        LOGE("IsAtLastRow failed code:%{public}d", errCode);
+    }
+    return result;
+}
 
-    bool ResultSetImpl::IsEnded()
-    {
-        bool result = false;
-        if (resultSetValue == nullptr) {
-            return result;
-        }
-        int errCode = resultSetValue->IsEnded(result);
-        if (errCode != RelationalStoreJsKit::OK) {
-            LOGE("IsEnded failed code:%{public}d", errCode);
-            result = true;
-        }
+bool ResultSetImpl::IsEnded()
+{
+    bool result = false;
+    if (resultSetValue == nullptr) {
         return result;
     }
+    int errCode = resultSetValue->IsEnded(result);
+    if (errCode != RelationalStoreJsKit::OK) {
+        LOGE("IsEnded failed code:%{public}d", errCode);
+        result = true;
+    }
+    return result;
+}
 
-    bool ResultSetImpl::IsStarted()
-    {
-        bool result = false;
-        if (resultSetValue == nullptr) {
-            return result;
-        }
-        int errCode = resultSetValue->IsStarted(result);
-        if (errCode != RelationalStoreJsKit::OK) {
-            LOGE("IsBegin failed code:%{public}d", errCode);
-        }
+bool ResultSetImpl::IsStarted()
+{
+    bool result = false;
+    if (resultSetValue == nullptr) {
         return result;
     }
+    int errCode = resultSetValue->IsStarted(result);
+    if (errCode != RelationalStoreJsKit::OK) {
+        LOGE("IsBegin failed code:%{public}d", errCode);
+    }
+    return result;
+}
 
-    bool ResultSetImpl::IsClosed()
-    {
-        if (resultSetValue == nullptr) {
-            return false;
-        }
-        return resultSetValue->IsClosed();
+bool ResultSetImpl::IsClosed()
+{
+    if (resultSetValue == nullptr) {
+        return false;
     }
+    return resultSetValue->IsClosed();
+}
 
-    double ResultSetImpl::GetDouble(int32_t columnIndex, int32_t* rtnCode)
-    {
-        double result = 0.0;
-        if (resultSetValue == nullptr || rtnCode == nullptr) {
-            return result;
-        }
-        *rtnCode = resultSetValue->GetDouble(columnIndex, result);
+double ResultSetImpl::GetDouble(int32_t columnIndex, int32_t *rtnCode)
+{
+    double result = 0.0;
+    if (resultSetValue == nullptr || rtnCode == nullptr) {
         return result;
     }
+    *rtnCode = resultSetValue->GetDouble(columnIndex, result);
+    return result;
+}
 
-    bool ResultSetImpl::GoToRow(int32_t position, int32_t* rtnCode)
-    {
-        if (resultSetValue == nullptr || rtnCode == nullptr) {
-            return false;
-        }
-        *rtnCode = resultSetValue->GoToRow(position);
-        return *rtnCode == RelationalStoreJsKit::OK;
+bool ResultSetImpl::GoToRow(int32_t position, int32_t *rtnCode)
+{
+    if (resultSetValue == nullptr || rtnCode == nullptr) {
+        return false;
     }
+    *rtnCode = resultSetValue->GoToRow(position);
+    return *rtnCode == RelationalStoreJsKit::OK;
+}
 
-    bool ResultSetImpl::GoToPreviousRow(int32_t* rtnCode)
-    {
-        if (resultSetValue == nullptr || rtnCode == nullptr) {
-            return false;
-        }
-        *rtnCode = resultSetValue->GoToPreviousRow();
-        return *rtnCode == RelationalStoreJsKit::OK;
+bool ResultSetImpl::GoToPreviousRow(int32_t *rtnCode)
+{
+    if (resultSetValue == nullptr || rtnCode == nullptr) {
+        return false;
     }
+    *rtnCode = resultSetValue->GoToPreviousRow();
+    return *rtnCode == RelationalStoreJsKit::OK;
+}
 
-    bool ResultSetImpl::GoToLastRow(int32_t* rtnCode)
-    {
-        if (resultSetValue == nullptr || rtnCode == nullptr) {
-            return false;
-        }
-        *rtnCode = resultSetValue->GoToLastRow();
-        return *rtnCode == RelationalStoreJsKit::OK;
+bool ResultSetImpl::GoToLastRow(int32_t *rtnCode)
+{
+    if (resultSetValue == nullptr || rtnCode == nullptr) {
+        return false;
     }
+    *rtnCode = resultSetValue->GoToLastRow();
+    return *rtnCode == RelationalStoreJsKit::OK;
+}
 
-    char* ResultSetImpl::GetColumnName(int32_t columnIndex, int32_t* rtnCode)
-    {
-        std::string result;
-        if (resultSetValue == nullptr || rtnCode == nullptr) {
-            return nullptr;
-        }
-        *rtnCode = resultSetValue->GetColumnName(columnIndex, result);
-        if (*rtnCode != RelationalStoreJsKit::OK) {
-            LOGE("IsAtLastRow failed code:%{public}d", *rtnCode);
-        }
-        return MallocCString(result);
+char *ResultSetImpl::GetColumnName(int32_t columnIndex, int32_t *rtnCode)
+{
+    std::string result;
+    if (resultSetValue == nullptr || rtnCode == nullptr) {
+        return nullptr;
+    }
+    *rtnCode = resultSetValue->GetColumnName(columnIndex, result);
+    if (*rtnCode != RelationalStoreJsKit::OK) {
+        LOGE("IsAtLastRow failed code:%{public}d", *rtnCode);
     }
+    return MallocCString(result);
+}
 
-    bool ResultSetImpl::IsColumnNull(int32_t columnIndex, int32_t* rtnCode)
-    {
-        bool result;
-        if (resultSetValue == nullptr || rtnCode == nullptr) {
-            return false;
-        }
-        *rtnCode = resultSetValue->IsColumnNull(columnIndex, result);
-        return result;
+bool ResultSetImpl::IsColumnNull(int32_t columnIndex, int32_t *rtnCode)
+{
+    bool result;
+    if (resultSetValue == nullptr || rtnCode == nullptr) {
+        return false;
     }
+    *rtnCode = resultSetValue->IsColumnNull(columnIndex, result);
+    return result;
+}
 
-    Asset ResultSetImpl::GetAsset(int32_t columnIndex, int32_t* rtnCode)
-    {
-        NativeRdb::ValueObject::Asset asset;
-        if (resultSetValue == nullptr || rtnCode == nullptr) {
-            return Asset{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, 0};
-        }
-        *rtnCode = resultSetValue->GetAsset(columnIndex, asset);
-        if (*rtnCode != RelationalStoreJsKit::OK) {
-            return Asset{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, 0};
-        }
-        Asset result = {
-            .name= MallocCString(asset.name),
-            .uri= MallocCString(asset.uri),
-            .path= MallocCString(asset.path),
-            .createTime= MallocCString(asset.createTime),
-            .modifyTime= MallocCString(asset.modifyTime),
-            .size= MallocCString(asset.size),
-            .status= (int32_t)asset.status
-        };
-        return result;
+Asset ResultSetImpl::GetAsset(int32_t columnIndex, int32_t *rtnCode)
+{
+    NativeRdb::ValueObject::Asset asset;
+    if (resultSetValue == nullptr || rtnCode == nullptr) {
+        return Asset{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, 0};
     }
+    *rtnCode = resultSetValue->GetAsset(columnIndex, asset);
+    if (*rtnCode != RelationalStoreJsKit::OK) {
+        return Asset{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, 0};
+    }
+    Asset result = {
+        .name= MallocCString(asset.name),
+        .uri= MallocCString(asset.uri),
+        .path= MallocCString(asset.path),
+        .createTime= MallocCString(asset.createTime),
+        .modifyTime= MallocCString(asset.modifyTime),
+        .size= MallocCString(asset.size),
+        .status= (int32_t)asset.status
+    };
+    return result;
+}
 
-    int32_t ResultSetImpl::Close()
-    {
-        if (resultSetValue == nullptr) {
-            return -1;
-        }
-        return resultSetValue->Close();
+int32_t ResultSetImpl::Close()
+{
+    if (resultSetValue == nullptr) {
+        return -1;
     }
+    return resultSetValue->Close();
+}
 
-    int32_t ResultSetImpl::GetColumnIndex(char* columnName, int32_t* rtnCode)
-    {
-        int32_t result = -1;
-        if (resultSetValue == nullptr || rtnCode == nullptr || columnName == nullptr) {
-            return result;
-        }
-        *rtnCode = resultSetValue->GetColumnIndex(columnName, result);
-        // If the API version is less than 13, directly return.
-        if (AppDataMgrJsKit::JSUtils::GetHapVersion() < 13 || (*rtnCode == NativeRdb::E_INVALID_ARGS)) {
-            *rtnCode = E_OK;
-        }
+int32_t ResultSetImpl::GetColumnIndex(char *columnName, int32_t *rtnCode)
+{
+    int32_t result = -1;
+    if (resultSetValue == nullptr || rtnCode == nullptr || columnName == nullptr) {
         return result;
     }
-
-    char* ResultSetImpl::GetString(int32_t columnIndex, int32_t* rtnCode)
-    {
-        std::string result;
-        if (resultSetValue == nullptr || rtnCode == nullptr) {
-            return nullptr;
-        }
-        *rtnCode = resultSetValue->GetString(columnIndex, result);
-        return MallocCString(result);
+    *rtnCode = resultSetValue->GetColumnIndex(columnName, result);
+    // If the API version is less than 13, directly return.
+    if (AppDataMgrJsKit::JSUtils::GetHapVersion() < 13 || (*rtnCode == NativeRdb::E_INVALID_ARGS)) {
+        *rtnCode = E_OK;
     }
+    return result;
+}
 
-    bool ResultSetImpl::GoToFirstRow(int32_t* rtnCode)
-    {
-        if (resultSetValue == nullptr || rtnCode == nullptr) {
-            return false;
-        }
-        *rtnCode = resultSetValue->GoToFirstRow();
-        return *rtnCode == RelationalStoreJsKit::OK;
+char *ResultSetImpl::GetString(int32_t columnIndex, int32_t *rtnCode)
+{
+    std::string result;
+    if (resultSetValue == nullptr || rtnCode == nullptr) {
+        return nullptr;
     }
+    *rtnCode = resultSetValue->GetString(columnIndex, result);
+    return MallocCString(result);
+}
 
-    int64_t ResultSetImpl::GetLong(int32_t columnIndex, int32_t* rtnCode)
-    {
-        if (resultSetValue == nullptr || rtnCode == nullptr) {
-            return -1;
-        }
-        int64_t result;
-        *rtnCode = resultSetValue->GetLong(columnIndex, result);
-        return result;
+bool ResultSetImpl::GoToFirstRow(int32_t *rtnCode)
+{
+    if (resultSetValue == nullptr || rtnCode == nullptr) {
+        return false;
     }
+    *rtnCode = resultSetValue->GoToFirstRow();
+    return *rtnCode == RelationalStoreJsKit::OK;
+}
 
-    bool ResultSetImpl::GoToNextRow(int32_t* rtnCode)
-    {
-        if (resultSetValue == nullptr || rtnCode == nullptr) {
-            return false;
-        }
-        *rtnCode = resultSetValue->GoToNextRow();
-        return *rtnCode == RelationalStoreJsKit::OK;
+int64_t ResultSetImpl::GetLong(int32_t columnIndex, int32_t *rtnCode)
+{
+    if (resultSetValue == nullptr || rtnCode == nullptr) {
+        return -1;
     }
+    int64_t result;
+    *rtnCode = resultSetValue->GetLong(columnIndex, result);
+    return result;
+}
 
-    CArrUI8 ResultSetImpl::GetBlob(int32_t columnIndex, int32_t* rtnCode)
-    {
-        std::vector<uint8_t> vec;
-        if (resultSetValue == nullptr || rtnCode == nullptr) {
-            return CArrUI8{nullptr, 0};
-        }
-        *rtnCode = resultSetValue->GetBlob(columnIndex, vec);
-        if (*rtnCode != RelationalStoreJsKit::OK || vec.size() == 0) {
-            return CArrUI8{nullptr, 0};
-        }
-        uint8_t* result = static_cast<uint8_t*>(malloc(vec.size() * sizeof(uint8_t)));
-        if (result == nullptr) {
-            return CArrUI8{nullptr, -1};
-        }
-        for (size_t i = 0; i < vec.size(); i++) {
-            result[i] = vec[i];
-        }
-        return CArrUI8{result, int64_t(vec.size())};
+bool ResultSetImpl::GoToNextRow(int32_t *rtnCode)
+{
+    if (resultSetValue == nullptr || rtnCode == nullptr) {
+        return false;
     }
+    *rtnCode = resultSetValue->GoToNextRow();
+    return *rtnCode == RelationalStoreJsKit::OK;
+}
 
-    bool ResultSetImpl::GoTo(int32_t offset, int32_t* rtnCode)
-    {
-        if (resultSetValue == nullptr || rtnCode == nullptr) {
-            return false;
-        }
-        *rtnCode = resultSetValue->GoTo(offset);
-        return *rtnCode == RelationalStoreJsKit::OK;
+CArrUI8 ResultSetImpl::GetBlob(int32_t columnIndex, int32_t *rtnCode)
+{
+    std::vector<uint8_t> vec;
+    if (resultSetValue == nullptr || rtnCode == nullptr) {
+        return CArrUI8{nullptr, 0};
+    }
+    *rtnCode = resultSetValue->GetBlob(columnIndex, vec);
+    if (*rtnCode != RelationalStoreJsKit::OK || vec.size() == 0) {
+        return CArrUI8{nullptr, 0};
+    }
+    uint8_t *result = static_cast<uint8_t*>(malloc(vec.size() * sizeof(uint8_t)));
+    if (result == nullptr) {
+        return CArrUI8{nullptr, -1};
+    }
+    for (size_t i = 0; i < vec.size(); i++) {
+        result[i] = vec[i];
     }
+    return CArrUI8{result, int64_t(vec.size())};
+}
 
-    Assets ResultSetImpl::GetAssets(int32_t columnIndex, int32_t* rtnCode)
-    {
-        std::vector<NativeRdb::ValueObject::Asset> assets;
-        if (resultSetValue == nullptr || rtnCode == nullptr) {
-            return Assets{nullptr, 0};
-        }
-        *rtnCode = resultSetValue->GetAssets(columnIndex, assets);
-        if (*rtnCode != RelationalStoreJsKit::OK || assets.size() == 0) {
-            return Assets{nullptr, 0};
-        }
-        Asset* result = static_cast<Asset*>(malloc(assets.size() * sizeof(Asset)));
-        if (result == nullptr) {
-            return Assets{nullptr, -1};
-        }
-        for (size_t i = 0; i < assets.size(); i++) {
-            result[i] = Asset {
-                .name= MallocCString(assets[i].name),
-                .uri= MallocCString(assets[i].uri),
-                .path= MallocCString(assets[i].path),
-                .createTime= MallocCString(assets[i].createTime),
-                .modifyTime= MallocCString(assets[i].modifyTime),
-                .size= MallocCString(assets[i].size),
-                .status= (int32_t)assets[i].status
-            };
-        }
-        return Assets{.head = result, .size = (int64_t)(assets.size())};
+bool ResultSetImpl::GoTo(int32_t offset, int32_t *rtnCode)
+{
+    if (resultSetValue == nullptr || rtnCode == nullptr) {
+        return false;
     }
+    *rtnCode = resultSetValue->GoTo(offset);
+    return *rtnCode == RelationalStoreJsKit::OK;
+}
 
-    ValuesBucket ResultSetImpl::GetRow(int32_t* rtnCode)
-    {
-        NativeRdb::RowEntity rowEntity;
-        if (resultSetValue == nullptr || rtnCode == nullptr) {
-            return ValuesBucket{nullptr, nullptr, 0};
-        }
-        *rtnCode = resultSetValue->GetRow(rowEntity);
-        if (*rtnCode != E_OK) {
-            return ValuesBucket{nullptr, nullptr, 0};
-        }
-        const std::map<std::string, NativeRdb::ValueObject> map = rowEntity.Get();
-        size_t size = map.size();
-        if (size == 0) {
-            return ValuesBucket{nullptr, nullptr, 0};
-        }
-        ValuesBucket result = ValuesBucket {
-            .key = static_cast<char**>(malloc(sizeof(char*) * size)),
-            .value = static_cast<ValueType*>(malloc(sizeof(ValueType) * size)),
-            .size = size
+Assets ResultSetImpl::GetAssets(int32_t columnIndex, int32_t *rtnCode)
+{
+    std::vector<NativeRdb::ValueObject::Asset> assets;
+    if (resultSetValue == nullptr || rtnCode == nullptr) {
+        return Assets{nullptr, 0};
+    }
+    *rtnCode = resultSetValue->GetAssets(columnIndex, assets);
+    if (*rtnCode != RelationalStoreJsKit::OK || assets.size() == 0) {
+        return Assets{nullptr, 0};
+    }
+    Asset *result = static_cast<Asset*>(malloc(assets.size() * sizeof(Asset)));
+    if (result == nullptr) {
+        return Assets{nullptr, -1};
+    }
+    for (size_t i = 0; i < assets.size(); i++) {
+        result[i] = Asset {
+            .name = MallocCString(assets[i].name),
+            .uri = MallocCString(assets[i].uri),
+            .path = MallocCString(assets[i].path),
+            .createTime = MallocCString(assets[i].createTime),
+            .modifyTime = MallocCString(assets[i].modifyTime),
+            .size = MallocCString(assets[i].size),
+            .status = (int32_t)assets[i].status
         };
-        if (result.key == nullptr || result.value == nullptr) {
-            free(result.key);
-            free(result.value);
-            return ValuesBucket{nullptr, nullptr, -1};
-        }
-        int64_t i = 0;
-        for (auto &t : map) {
-            result.key[i] = MallocCString(t.first);
-            result.value[i] = ValueObjectToValueType(t.second);
-            i++;
-        }
-        return result;
     }
+    return Assets{.head = result, .size = (int64_t)(assets.size())};
+}
 
-    ValuesBucketEx ResultSetImpl::GetRowEx(int32_t* rtnCode)
-    {
-        NativeRdb::RowEntity rowEntity;
-        if (resultSetValue == nullptr || rtnCode == nullptr) {
-            return ValuesBucketEx{nullptr, nullptr, 0};
-        }
-        *rtnCode = resultSetValue->GetRow(rowEntity);
-        if (*rtnCode != E_OK) {
-            return ValuesBucketEx{nullptr, nullptr, 0};
-        }
-        const std::map<std::string, NativeRdb::ValueObject> map = rowEntity.Get();
-        size_t size = map.size();
-        if (size == 0) {
-            return ValuesBucketEx{nullptr, nullptr, 0};
-        }
-        ValuesBucketEx result = ValuesBucketEx {
-            .key = static_cast<char**>(malloc(sizeof(char*) * size)),
-            .value = static_cast<ValueTypeEx*>(malloc(sizeof(ValueTypeEx) * size)),
-            .size = size
-        };
-        if (result.key == nullptr || result.value == nullptr) {
-            free(result.key);
-            free(result.value);
-            return ValuesBucketEx{nullptr, nullptr, ERROR_VALUE};
-        }
-        int64_t i = 0;
-        for (auto &t : map) {
-            result.key[i] = MallocCString(t.first);
-            result.value[i] = ValueObjectToValueTypeEx(t.second);
-            i++;
-        }
-        return result;
+ValuesBucket ResultSetImpl::GetRow(int32_t *rtnCode)
+{
+    NativeRdb::RowEntity rowEntity;
+    if (resultSetValue == nullptr || rtnCode == nullptr) {
+        return ValuesBucket{nullptr, nullptr, 0};
+    }
+    *rtnCode = resultSetValue->GetRow(rowEntity);
+    if (*rtnCode != E_OK) {
+        return ValuesBucket{nullptr, nullptr, 0};
     }
+    const std::map<std::string, NativeRdb::ValueObject> map = rowEntity.Get();
+    size_t size = map.size();
+    if (size == 0) {
+        return ValuesBucket{nullptr, nullptr, 0};
+    }
+    ValuesBucket result = ValuesBucket {
+        .key = static_cast<char**>(malloc(sizeof(char*) * size)),
+        .value = static_cast<ValueType*>(malloc(sizeof(ValueType) * size)),
+        .size = size
+    };
+    if (result.key == nullptr || result.value == nullptr) {
+        free(result.key);
+        free(result.value);
+        return ValuesBucket{nullptr, nullptr, -1};
+    }
+    int64_t i = 0;
+    for (auto &t : map) {
+        result.key[i] = MallocCString(t.first);
+        result.value[i] = ValueObjectToValueType(t.second);
+        i++;
+    }
+    return result;
+}
 
-    ValueTypeEx ResultSetImpl::GetValue(int32_t columnIndex, int32_t* rtnCode)
-    {
-        NativeRdb::ValueObject object;
-        if (resultSetValue == nullptr || rtnCode == nullptr) {
-            return ValueTypeEx{ 0 };
-        }
-        *rtnCode = NativeRdb::E_ALREADY_CLOSED;
-        if (resultSetValue != nullptr) {
-            *rtnCode = resultSetValue->Get(columnIndex, object);
-        }
-        if (*rtnCode != E_OK) {
-            return ValueTypeEx{ 0 };
-        }
-        return ValueObjectToValueTypeEx(object);
+ValuesBucketEx ResultSetImpl::GetRowEx(int32_t *rtnCode)
+{
+    NativeRdb::RowEntity rowEntity;
+    if (resultSetValue == nullptr || rtnCode == nullptr) {
+        return ValuesBucketEx{nullptr, nullptr, 0};
+    }
+    *rtnCode = resultSetValue->GetRow(rowEntity);
+    if (*rtnCode != E_OK) {
+        return ValuesBucketEx{nullptr, nullptr, 0};
+    }
+    const std::map<std::string, NativeRdb::ValueObject> map = rowEntity.Get();
+    size_t size = map.size();
+    if (size == 0) {
+        return ValuesBucketEx{nullptr, nullptr, 0};
+    }
+    ValuesBucketEx result = ValuesBucketEx {
+        .key = static_cast<char**>(malloc(sizeof(char*) * size)),
+        .value = static_cast<ValueTypeEx*>(malloc(sizeof(ValueTypeEx) * size)),
+        .size = size
+    };
+    if (result.key == nullptr || result.value == nullptr) {
+        free(result.key);
+        free(result.value);
+        return ValuesBucketEx{nullptr, nullptr, ERROR_VALUE};
+    }
+    int64_t i = 0;
+    for (auto &t : map) {
+        result.key[i] = MallocCString(t.first);
+        result.value[i] = ValueObjectToValueTypeEx(t.second);
+        i++;
+    }
+    return result;
+}
+
+ValueTypeEx ResultSetImpl::GetValue(int32_t columnIndex, int32_t *rtnCode)
+{
+    NativeRdb::ValueObject object;
+    if (resultSetValue == nullptr || rtnCode == nullptr) {
+        return ValueTypeEx{0};
+    }
+    *rtnCode = NativeRdb::E_ALREADY_CLOSED;
+    if (resultSetValue != nullptr) {
+        *rtnCode = resultSetValue->Get(columnIndex, object);
+    }
+    if (*rtnCode != E_OK) {
+        return ValueTypeEx{0};
     }
+    return ValueObjectToValueTypeEx(object);
 }
-}
\ No newline at end of file
+} // namespace Relational
+} // namespace OHOS
\ No newline at end of file
diff --git a/frameworks/cj/src/relational_store_utils.cpp b/frameworks/cj/src/relational_store_utils.cpp
index 35bb53e778827ce231070ee9b72fca6ee555754c..a8eac09ab6ce778b9b65fcfc59200e6d34273ecf 100644
--- a/frameworks/cj/src/relational_store_utils.cpp
+++ b/frameworks/cj/src/relational_store_utils.cpp
@@ -22,700 +22,700 @@ const int64_t BITNUMOFUI64 = 64;
 
 namespace OHOS {
 namespace Relational {
-    OHOS::NativeRdb::RdbStoreConfig::CryptoParam ToCCryptoParam(CryptoParam param)
-    {
-        auto cryptoParam = OHOS::NativeRdb::RdbStoreConfig::CryptoParam();
-        cryptoParam.iterNum = param.iterNum;
-        cryptoParam.encryptAlgo = param.encryptAlgo;
-        cryptoParam.hmacAlgo = param.hmacAlgo;
-        cryptoParam.kdfAlgo = param.kdfAlgo;
-        cryptoParam.cryptoPageSize = param.cryptoPageSize;
-        cryptoParam.encryptKey_ = CArrUI8ToVector(param.encryptKey);
-        return cryptoParam;
-    }
+OHOS::NativeRdb::RdbStoreConfig::CryptoParam ToCCryptoParam(CryptoParam param)
+{
+    auto cryptoParam = OHOS::NativeRdb::RdbStoreConfig::CryptoParam();
+    cryptoParam.iterNum = param.iterNum;
+    cryptoParam.encryptAlgo = param.encryptAlgo;
+    cryptoParam.hmacAlgo = param.hmacAlgo;
+    cryptoParam.kdfAlgo = param.kdfAlgo;
+    cryptoParam.cryptoPageSize = param.cryptoPageSize;
+    cryptoParam.encryptKey_ = CArrUI8ToVector(param.encryptKey);
+    return cryptoParam;
+}
 
-    char* MallocCString(const std::string& origin)
-    {
-        if (origin.empty()) {
-            return nullptr;
-        }
-        auto len = origin.length() + 1;
-        char* res = static_cast<char*>(malloc(sizeof(char) * len));
-        if (res == nullptr) {
-            return nullptr;
-        }
-        return std::char_traits<char>::copy(res, origin.c_str(), len);
+char *MallocCString(const std::string &origin)
+{
+    if (origin.empty()) {
+        return nullptr;
+    }
+    auto len = origin.length() + 1;
+    char *res = static_cast<char*>(malloc(sizeof(char) * len));
+    if (res == nullptr) {
+        return nullptr;
     }
+    return std::char_traits<char>::copy(res, origin.c_str(), len);
+}
 
-    NativeRdb::ValueObject ValueTypeToValueObjectBlob(const ValueType& value)
-    {
-        std::vector<uint8_t> blob = std::vector<uint8_t>();
-        if (value.Uint8Array.head == nullptr) {
-            return NativeRdb::ValueObject(blob);
-        }
-        for (int64_t j = 0; j < value.Uint8Array.size; j++) {
-            blob.push_back(value.Uint8Array.head[j]);
-        }
+NativeRdb::ValueObject ValueTypeToValueObjectBlob(const ValueType &value)
+{
+    std::vector<uint8_t> blob = std::vector<uint8_t>();
+    if (value.Uint8Array.head == nullptr) {
         return NativeRdb::ValueObject(blob);
     }
+    for (int64_t j = 0; j < value.Uint8Array.size; j++) {
+        blob.push_back(value.Uint8Array.head[j]);
+    }
+    return NativeRdb::ValueObject(blob);
+}
+
+NativeRdb::ValueObject ValueTypeToValueObjectAsset(const ValueType &value)
+{
+    std::string modifyTime = value.asset.modifyTime;
+    std::string size = value.asset.size;
+    NativeRdb::ValueObject::Asset asset = {
+        .status = value.asset.status,
+        .name = value.asset.name,
+        .uri = value.asset.uri,
+        .createTime = value.asset.createTime,
+        .modifyTime = modifyTime,
+        .size = size,
+        .hash = modifyTime + "_" + size,
+        .path = value.asset.path
+    };
+    return NativeRdb::ValueObject(asset);
+}
 
-    NativeRdb::ValueObject ValueTypeToValueObjectAsset(const ValueType& value)
-    {
-        std::string modifyTime = value.asset.modifyTime;
-        std::string size = value.asset.size;
-        NativeRdb::ValueObject::Asset asset = {
-            .status = value.asset.status,
-            .name = value.asset.name,
-            .uri = value.asset.uri,
-            .createTime = value.asset.createTime,
+NativeRdb::ValueObject ValueTypeToValueObjectAssets(const ValueType &value)
+{
+    std::vector<NativeRdb::ValueObject::Asset> assets = std::vector<NativeRdb::ValueObject::Asset>();
+    if (value.assets.head == nullptr) {
+        return assets;
+    }
+    for (int64_t j = 0; j < value.assets.size; j++) {
+        Asset asset = value.assets.head[j];
+        std::string modifyTime = asset.modifyTime;
+        std::string size = asset.size;
+        NativeRdb::ValueObject::Asset nativeAsset = {
+            .status = asset.status,
+            .name = asset.name,
+            .uri = asset.uri,
+            .createTime = asset.createTime,
             .modifyTime = modifyTime,
             .size = size,
             .hash = modifyTime + "_" + size,
-            .path = value.asset.path
+            .path = asset.path
         };
-        return NativeRdb::ValueObject(asset);
-    }
-
-    NativeRdb::ValueObject ValueTypeToValueObjectAssets(const ValueType& value)
-    {
-        std::vector<NativeRdb::ValueObject::Asset> assets = std::vector<NativeRdb::ValueObject::Asset>();
-        if (value.assets.head == nullptr) {
-            return assets;
-        }
-        for (int64_t j = 0; j < value.assets.size; j++) {
-            Asset asset = value.assets.head[j];
-            std::string modifyTime = asset.modifyTime;
-            std::string size = asset.size;
-            NativeRdb::ValueObject::Asset nativeAsset = {
-                .status = asset.status,
-                .name = asset.name,
-                .uri = asset.uri,
-                .createTime = asset.createTime,
-                .modifyTime = modifyTime,
-                .size = size,
-                .hash = modifyTime + "_" + size,
-                .path = asset.path
-            };
-            assets.push_back(nativeAsset);
-        }
-        return NativeRdb::ValueObject(assets);
+        assets.push_back(nativeAsset);
     }
+    return NativeRdb::ValueObject(assets);
+}
 
-    NativeRdb::ValueObject ValueTypeToValueObject(const ValueType& value)
-    {
-        NativeRdb::ValueObject valueObject;
-        switch (value.tag) {
-            case TYPE_NULL: {
-                valueObject = NativeRdb::ValueObject();
-                break;
-            }
-            case TYPE_INT: {
-                valueObject = NativeRdb::ValueObject(value.integer);
-                break;
-            }
-            case TYPE_DOU: {
-                valueObject = NativeRdb::ValueObject(value.dou);
-                break;
-            }
-            case TYPE_STR: {
-                if (value.string == nullptr) {
-                    LOGE("string value is nullptr");
-                    break;
-                }
-                valueObject = NativeRdb::ValueObject(value.string);
-                break;
-            }
-            case TYPE_BOOL: {
-                valueObject = NativeRdb::ValueObject(value.boolean);
+NativeRdb::ValueObject ValueTypeToValueObject(const ValueType &value)
+{
+    NativeRdb::ValueObject valueObject;
+    switch (value.tag) {
+        case TYPE_NULL: {
+            valueObject = NativeRdb::ValueObject();
+            break;
+        }
+        case TYPE_INT: {
+            valueObject = NativeRdb::ValueObject(value.integer);
+            break;
+        }
+        case TYPE_DOU: {
+            valueObject = NativeRdb::ValueObject(value.dou);
+            break;
+        }
+        case TYPE_STR: {
+            if (value.string == nullptr) {
+                LOGE("string value is nullptr");
                 break;
             }
-            case TYPE_BLOB: {
-                valueObject = ValueTypeToValueObjectBlob(value);
-                break;
-            }
-            case TYPE_ASSET: {
-                valueObject = ValueTypeToValueObjectAsset(value);
-                break;
-            }
-            case TYPE_ASSETS: {
-                valueObject = ValueTypeToValueObjectAssets(value);
-                break;
-            }
-            default:
-                valueObject = NativeRdb::ValueObject();
-                break;
+            valueObject = NativeRdb::ValueObject(value.string);
+            break;
         }
-        return valueObject;
-    }
-
-    NativeRdb::ValueObject ValueTypeExToValueObjectBlob(const ValueTypeEx& value)
-    {
-        std::vector<uint8_t> blob = std::vector<uint8_t>();
-        if (value.uint8Array.head == nullptr) {
-            LOGE("the array head is nullptr");
-            return NativeRdb::ValueObject(blob);
+        case TYPE_BOOL: {
+            valueObject = NativeRdb::ValueObject(value.boolean);
+            break;
         }
-        for (int64_t j = 0; j < value.uint8Array.size; j++) {
-            blob.push_back(value.uint8Array.head[j]);
+        case TYPE_BLOB: {
+            valueObject = ValueTypeToValueObjectBlob(value);
+            break;
         }
+        case TYPE_ASSET: {
+            valueObject = ValueTypeToValueObjectAsset(value);
+            break;
+        }
+        case TYPE_ASSETS: {
+            valueObject = ValueTypeToValueObjectAssets(value);
+            break;
+        }
+        default:
+            valueObject = NativeRdb::ValueObject();
+            break;
+    }
+    return valueObject;
+}
+
+NativeRdb::ValueObject ValueTypeExToValueObjectBlob(const ValueTypeEx &value)
+{
+    std::vector<uint8_t> blob = std::vector<uint8_t>();
+    if (value.uint8Array.head == nullptr) {
+        LOGE("the array head is nullptr");
         return NativeRdb::ValueObject(blob);
     }
+    for (int64_t j = 0; j < value.uint8Array.size; j++) {
+        blob.push_back(value.uint8Array.head[j]);
+    }
+    return NativeRdb::ValueObject(blob);
+}
+
+NativeRdb::ValueObject ValueTypeExToValueObjectAsset(const ValueTypeEx &value)
+{
+    std::string modifyTime = value.asset.modifyTime;
+    std::string size = value.asset.size;
+    NativeRdb::ValueObject::Asset asset = {
+        .status = value.asset.status,
+        .name = value.asset.name,
+        .uri = value.asset.uri,
+        .createTime = value.asset.createTime,
+        .modifyTime = modifyTime,
+        .size = size,
+        .hash = modifyTime + "_" + size,
+        .path = value.asset.path
+    };
+    return NativeRdb::ValueObject(asset);
+}
 
-    NativeRdb::ValueObject ValueTypeExToValueObjectAsset(const ValueTypeEx& value)
-    {
-        std::string modifyTime = value.asset.modifyTime;
-        std::string size = value.asset.size;
-        NativeRdb::ValueObject::Asset asset = {
-            .status = value.asset.status,
-            .name = value.asset.name,
-            .uri = value.asset.uri,
-            .createTime = value.asset.createTime,
+NativeRdb::ValueObject ValueTypeExToValueObjectAssets(const ValueTypeEx &value)
+{
+    std::vector<NativeRdb::ValueObject::Asset> assets = std::vector<NativeRdb::ValueObject::Asset>();
+    if (value.assets.head == nullptr) {
+        LOGE("the assets head is nullptr");
+        return NativeRdb::ValueObject(assets);
+    }
+    for (int64_t j = 0; j < value.assets.size; j++) {
+        Asset asset = value.assets.head[j];
+        std::string modifyTime = asset.modifyTime;
+        std::string size = asset.size;
+        NativeRdb::ValueObject::Asset nativeAsset = {
+            .status = asset.status,
+            .name = asset.name,
+            .uri = asset.uri,
+            .createTime = asset.createTime,
             .modifyTime = modifyTime,
             .size = size,
             .hash = modifyTime + "_" + size,
-            .path = value.asset.path
+            .path = asset.path
         };
-        return NativeRdb::ValueObject(asset);
-    }
-
-    NativeRdb::ValueObject ValueTypeExToValueObjectAssets(const ValueTypeEx& value)
-    {
-        std::vector<NativeRdb::ValueObject::Asset> assets = std::vector<NativeRdb::ValueObject::Asset>();
-        if (value.assets.head == nullptr) {
-            LOGE("the assets head is nullptr");
-            return NativeRdb::ValueObject(assets);
-        }
-        for (int64_t j = 0; j < value.assets.size; j++) {
-            Asset asset = value.assets.head[j];
-            std::string modifyTime = asset.modifyTime;
-            std::string size = asset.size;
-            NativeRdb::ValueObject::Asset nativeAsset = {
-                .status = asset.status,
-                .name = asset.name,
-                .uri = asset.uri,
-                .createTime = asset.createTime,
-                .modifyTime = modifyTime,
-                .size = size,
-                .hash = modifyTime + "_" + size,
-                .path = asset.path
-            };
-            assets.push_back(nativeAsset);
-        }
-        return NativeRdb::ValueObject(assets);
+        assets.push_back(nativeAsset);
     }
+    return NativeRdb::ValueObject(assets);
+}
 
-    NativeRdb::ValueObject ValueTypeExToValueObjectFloatArr(const ValueTypeEx& value)
-    {
-        std::vector<float> arr = std::vector<float>();
-        if (value.floatArray.head == nullptr) {
-            LOGE("the floatArray head is nullptr");
-            return NativeRdb::ValueObject(arr);
-        }
-        for (int64_t j = 0; j < value.floatArray.size; j++) {
-            arr.push_back(value.floatArray.head[j]);
-        }
+NativeRdb::ValueObject ValueTypeExToValueObjectFloatArr(const ValueTypeEx &value)
+{
+    std::vector<float> arr = std::vector<float>();
+    if (value.floatArray.head == nullptr) {
+        LOGE("the floatArray head is nullptr");
         return NativeRdb::ValueObject(arr);
     }
+    for (int64_t j = 0; j < value.floatArray.size; j++) {
+        arr.push_back(value.floatArray.head[j]);
+    }
+    return NativeRdb::ValueObject(arr);
+}
 
-    NativeRdb::ValueObject ValueTypeExToValueObjectBigInt(const ValueTypeEx& value)
-    {
-        std::vector<uint64_t> arr = std::vector<uint64_t>();
-        int64_t firstSize = (value.bigInt.value.size % UI64TOUI8 == 0) ? UI64TOUI8 :
-            (value.bigInt.value.size % UI64TOUI8);
-        for (int64_t i = 0; i < ((value.bigInt.value.size + UI64TOUI8 - 1) / UI64TOUI8); i++) {
-            uint64_t tempValue = 0;
-            if (i == 0) {
-                for (int64_t j = 0; j < firstSize; j++) {
-                    tempValue |=
-                        (static_cast<uint64_t>(value.bigInt.value.head[j]) << (UI64TOUI8 * (firstSize -j - 1)));
-                }
-            } else {
-                for (int64_t j = 0; j < UI64TOUI8; j++) {
-                    tempValue |=
-                        (static_cast<uint64_t>(value.bigInt.value.head[UI64TOUI8 * (i - 1) + firstSize + j]) <<
-                        (UI64TOUI8 * ((value.bigInt.value.size - (UI64TOUI8 * (i - 1) + firstSize + j) - 1) %
-                        UI64TOUI8)));
-                }
+NativeRdb::ValueObject ValueTypeExToValueObjectBigInt(const ValueTypeEx &value)
+{
+    std::vector<uint64_t> arr = std::vector<uint64_t>();
+    int64_t firstSize = (value.bigInt.value.size % UI64TOUI8 == 0) ? UI64TOUI8 :
+        (value.bigInt.value.size % UI64TOUI8);
+    for (int64_t i = 0; i < ((value.bigInt.value.size + UI64TOUI8 - 1) / UI64TOUI8); i++) {
+        uint64_t tempValue = 0;
+        if (i == 0) {
+            for (int64_t j = 0; j < firstSize; j++) {
+                tempValue |=
+                    (static_cast<uint64_t>(value.bigInt.value.head[j]) << (UI64TOUI8 * (firstSize -j - 1)));
+            }
+        } else {
+            for (int64_t j = 0; j < UI64TOUI8; j++) {
+                tempValue |=
+                    (static_cast<uint64_t>(value.bigInt.value.head[UI64TOUI8 * (i - 1) + firstSize + j]) <<
+                    (UI64TOUI8 * ((value.bigInt.value.size - (UI64TOUI8 * (i - 1) + firstSize + j) - 1) %
+                    UI64TOUI8)));
             }
-            arr.push_back(tempValue);
         }
-        return NativeRdb::ValueObject(NativeRdb::ValueObject::BigInt(static_cast<int32_t>(value.bigInt.sign),
-            std::move(arr)));
+        arr.push_back(tempValue);
     }
+    return NativeRdb::ValueObject(NativeRdb::ValueObject::BigInt(static_cast<int32_t>(value.bigInt.sign),
+        std::move(arr)));
+}
 
-    NativeRdb::ValueObject ValueTypeExToValueObject(const ValueTypeEx& value)
-    {
-        NativeRdb::ValueObject valueObject;
-        switch (value.tag) {
-            case TYPE_NULL: {
-                valueObject = NativeRdb::ValueObject();
-                break;
-            }
-            case TYPE_INT: {
-                valueObject = NativeRdb::ValueObject(value.integer);
-                break;
-            }
-            case TYPE_DOU: {
-                valueObject = NativeRdb::ValueObject(value.dou);
-                break;
-            }
-            case TYPE_STR: {
-                valueObject = NativeRdb::ValueObject(value.string);
-                break;
-            }
-            case TYPE_BOOL: {
-                valueObject = NativeRdb::ValueObject(value.boolean);
-                break;
-            }
-            case TYPE_BLOB: {
-                valueObject = ValueTypeExToValueObjectBlob(value);
-                break;
-            }
-            case TYPE_ASSET: {
-                valueObject = ValueTypeExToValueObjectAsset(value);
-                break;
-            }
-            case TYPE_ASSETS: {
-                valueObject = ValueTypeExToValueObjectAssets(value);
-                break;
-            }
-            case TYPE_FLOATARR: {
-                valueObject = ValueTypeExToValueObjectFloatArr(value);
-                break;
-            }
-            case TYPE_BIGINT: {
-                valueObject = ValueTypeExToValueObjectBigInt(value);
-                break;
-            }
-            default:
-                valueObject = NativeRdb::ValueObject();
-                break;
+NativeRdb::ValueObject ValueTypeExToValueObject(const ValueTypeEx &value)
+{
+    NativeRdb::ValueObject valueObject;
+    switch (value.tag) {
+        case TYPE_NULL: {
+            valueObject = NativeRdb::ValueObject();
+            break;
+        }
+        case TYPE_INT: {
+            valueObject = NativeRdb::ValueObject(value.integer);
+            break;
+        }
+        case TYPE_DOU: {
+            valueObject = NativeRdb::ValueObject(value.dou);
+            break;
+        }
+        case TYPE_STR: {
+            valueObject = NativeRdb::ValueObject(value.string);
+            break;
+        }
+        case TYPE_BOOL: {
+            valueObject = NativeRdb::ValueObject(value.boolean);
+            break;
+        }
+        case TYPE_BLOB: {
+            valueObject = ValueTypeExToValueObjectBlob(value);
+            break;
+        }
+        case TYPE_ASSET: {
+            valueObject = ValueTypeExToValueObjectAsset(value);
+            break;
         }
-        return valueObject;
-    }
-
-    ValueType ValueObjectToValueTypeAsset(const NativeRdb::ValueObject& object)
-    {
-        NativeRdb::ValueObject::Asset val;
-        object.GetAsset(val);
-        Asset asset = Asset {
-            .name = MallocCString(val.name),
-            .uri = MallocCString(val.uri),
-            .path = MallocCString(val.path),
-            .createTime = MallocCString(val.createTime),
-            .modifyTime = MallocCString(val.modifyTime),
-            .size = MallocCString(val.size),
-            .status = val.status
+        case TYPE_ASSETS: {
+            valueObject = ValueTypeExToValueObjectAssets(value);
+            break;
+        }
+        case TYPE_FLOATARR: {
+            valueObject = ValueTypeExToValueObjectFloatArr(value);
+            break;
+        }
+        case TYPE_BIGINT: {
+            valueObject = ValueTypeExToValueObjectBigInt(value);
+            break;
+        }
+        default:
+            valueObject = NativeRdb::ValueObject();
+            break;
+    }
+    return valueObject;
+}
+
+ValueType ValueObjectToValueTypeAsset(const NativeRdb::ValueObject &object)
+{
+    NativeRdb::ValueObject::Asset val;
+    object.GetAsset(val);
+    Asset asset = Asset {
+        .name = MallocCString(val.name),
+        .uri = MallocCString(val.uri),
+        .path = MallocCString(val.path),
+        .createTime = MallocCString(val.createTime),
+        .modifyTime = MallocCString(val.modifyTime),
+        .size = MallocCString(val.size),
+        .status = val.status
+    };
+    return ValueType {.asset = asset, .tag = TYPE_ASSET};
+}
+
+ValueType ValueObjectToValueTypeAssets(const NativeRdb::ValueObject &object)
+{
+    NativeRdb::ValueObject::Assets val;
+    object.GetAssets(val);
+    if (val.size() == 0) {
+        return ValueType {.assets = Assets{nullptr, -1}, .tag = TYPE_ASSETS};
+    }
+    Assets assets = Assets {.head = static_cast<Asset*>(malloc(val.size() * sizeof(Asset))), .size = val.size()};
+    if (assets.head == nullptr) {
+        return ValueType {.assets = Assets{nullptr, -1}, .tag = TYPE_ASSETS};
+    }
+    for (std::size_t i = 0; i < val.size(); i++) {
+        assets.head[i] = Asset {
+            .name = MallocCString(val[i].name),
+            .uri = MallocCString(val[i].uri),
+            .path = MallocCString(val[i].path),
+            .createTime = MallocCString(val[i].createTime),
+            .modifyTime = MallocCString(val[i].modifyTime),
+            .size = MallocCString(val[i].size),
+            .status = static_cast<int32_t>(val[i].status)
         };
-        return ValueType {.asset = asset, .tag = TYPE_ASSET};
-    }
-
-    ValueType ValueObjectToValueTypeAssets(const NativeRdb::ValueObject& object)
-    {
-        NativeRdb::ValueObject::Assets val;
-        object.GetAssets(val);
-        if (val.size() == 0) {
-            return ValueType {.assets = Assets{nullptr, -1}, .tag = TYPE_ASSETS};
-        }
-        Assets assets = Assets {.head = static_cast<Asset*>(malloc(val.size() * sizeof(Asset))), .size = val.size()};
-        if (assets.head == nullptr) {
-            return ValueType {.assets = Assets{nullptr, -1}, .tag = TYPE_ASSETS};
-        }
-        for (std::size_t i = 0; i < val.size(); i++) {
-            assets.head[i] = Asset {
-                .name = MallocCString(val[i].name),
-                .uri = MallocCString(val[i].uri),
-                .path = MallocCString(val[i].path),
-                .createTime = MallocCString(val[i].createTime),
-                .modifyTime = MallocCString(val[i].modifyTime),
-                .size = MallocCString(val[i].size),
-                .status = static_cast<int32_t>(val[i].status)
-            };
-        }
-        return ValueType {.assets = assets, .tag = TYPE_ASSETS};
-    }
-
-    ValueType ValueObjectToValueType(const NativeRdb::ValueObject& object)
-    {
-        switch (object.GetType()) {
-            case NativeRdb::ValueObject::TYPE_NULL:
-                return ValueType {.tag = TYPE_NULL};
-            case NativeRdb::ValueObject::TYPE_INT: {
-                int64_t val;
-                object.GetLong(val);
-                return ValueType {.integer = val, .tag = TYPE_INT};
-            }
-            case NativeRdb::ValueObject::TYPE_DOUBLE: {
-                double val;
-                object.GetDouble(val);
-                return ValueType {.dou = val, .tag = TYPE_DOU};
-            }
-            case NativeRdb::ValueObject::TYPE_STRING: {
-                std::string val;
-                object.GetString(val);
-                return ValueType {.string = MallocCString(val), .tag = TYPE_STR};
-            }
-            case NativeRdb::ValueObject::TYPE_BOOL: {
-                bool val;
-                object.GetBool(val);
-                return ValueType {.boolean = val, .tag = TYPE_BOOL};
-            }
-            case NativeRdb::ValueObject::TYPE_BLOB: {
-                std::vector<uint8_t> val;
-                object.GetBlob(val);
-                if (val.size() == 0) {
-                    return ValueType {.Uint8Array = CArrUI8 {nullptr, -1}, .tag = TYPE_BLOB};
-                }
-                CArrUI8 arr = CArrUI8 {.head = static_cast<uint8_t*>(malloc(val.size() * sizeof(uint8_t))),
-                    .size = val.size()};
-                if (arr.head == nullptr) {
-                    return ValueType {.Uint8Array = CArrUI8 {nullptr, -1}, .tag = TYPE_BLOB};
-                }
-                return ValueType {.Uint8Array = arr, .tag = TYPE_BLOB};
-            }
-            case NativeRdb::ValueObject::TYPE_ASSET: {
-                return ValueObjectToValueTypeAsset(object);
-            }
-            case NativeRdb::ValueObject::TYPE_ASSETS: {
-                return ValueObjectToValueTypeAssets(object);
-            }
-            case NativeRdb::ValueObject::TYPE_BUTT:
-                return ValueType {.tag = 128};
-            default:
-                return ValueType {.tag = TYPE_NULL};
-        }
-    }
-
-    ValueTypeEx ValueObjectToValueTypeExBlob(const NativeRdb::ValueObject& object)
-    {
-        std::vector<uint8_t> val = static_cast<std::vector<uint8_t>>(object);
-        auto size = val.size();
-        if (size == 0) {
-            return ValueTypeEx {.uint8Array = CArrUI8 {nullptr, ERROR_VALUE}, .tag = TYPE_BLOB};
-        }
-        CArrUI8 arr = CArrUI8 {.head = static_cast<uint8_t*>(malloc(size * sizeof(uint8_t))),
-            .size = size};
-        if (arr.head == nullptr) {
-            return ValueTypeEx {.uint8Array = CArrUI8 {nullptr, ERROR_VALUE}, .tag = TYPE_BLOB};
-        }
-        for (size_t i = 0; i < size; i++) {
-            arr.head[i] = val[i];
-        }
-        return ValueTypeEx {.uint8Array = arr, .tag = TYPE_BLOB};
-    }
-
-    ValueTypeEx ValueObjectToValueTypeExAsset(const NativeRdb::ValueObject& object)
-    {
-        NativeRdb::ValueObject::Asset val = static_cast<NativeRdb::ValueObject::Asset>(object);
-        Asset asset = Asset {
-            .name = MallocCString(val.name),
-            .uri = MallocCString(val.uri),
-            .path = MallocCString(val.path),
-            .createTime = MallocCString(val.createTime),
-            .modifyTime = MallocCString(val.modifyTime),
-            .size = MallocCString(val.size),
-            .status = val.status
+    }
+    return ValueType {.assets = assets, .tag = TYPE_ASSETS};
+}
+
+ValueType ValueObjectToValueType(const NativeRdb::ValueObject &object)
+{
+    switch (object.GetType()) {
+        case NativeRdb::ValueObject::TYPE_NULL:
+            return ValueType {.tag = TYPE_NULL};
+        case NativeRdb::ValueObject::TYPE_INT: {
+            int64_t val;
+            object.GetLong(val);
+            return ValueType {.integer = val, .tag = TYPE_INT};
+        }
+        case NativeRdb::ValueObject::TYPE_DOUBLE: {
+            double val;
+            object.GetDouble(val);
+            return ValueType {.dou = val, .tag = TYPE_DOU};
+        }
+        case NativeRdb::ValueObject::TYPE_STRING: {
+            std::string val;
+            object.GetString(val);
+            return ValueType {.string = MallocCString(val), .tag = TYPE_STR};
+        }
+        case NativeRdb::ValueObject::TYPE_BOOL: {
+            bool val;
+            object.GetBool(val);
+            return ValueType {.boolean = val, .tag = TYPE_BOOL};
+        }
+        case NativeRdb::ValueObject::TYPE_BLOB: {
+            std::vector<uint8_t> val;
+            object.GetBlob(val);
+            if (val.size() == 0) {
+                return ValueType {.Uint8Array = CArrUI8 {nullptr, -1}, .tag = TYPE_BLOB};
+            }
+            CArrUI8 arr = CArrUI8 {.head = static_cast<uint8_t*>(malloc(val.size() * sizeof(uint8_t))),
+                .size = val.size()};
+            if (arr.head == nullptr) {
+                return ValueType {.Uint8Array = CArrUI8 {nullptr, -1}, .tag = TYPE_BLOB};
+            }
+            return ValueType {.Uint8Array = arr, .tag = TYPE_BLOB};
+        }
+        case NativeRdb::ValueObject::TYPE_ASSET: {
+            return ValueObjectToValueTypeAsset(object);
+        }
+        case NativeRdb::ValueObject::TYPE_ASSETS: {
+            return ValueObjectToValueTypeAssets(object);
+        }
+        case NativeRdb::ValueObject::TYPE_BUTT:
+            return ValueType {.tag = 128};
+        default:
+            return ValueType {.tag = TYPE_NULL};
+    }
+}
+
+ValueTypeEx ValueObjectToValueTypeExBlob(const NativeRdb::ValueObject &object)
+{
+    std::vector<uint8_t> val = static_cast<std::vector<uint8_t>>(object);
+    auto size = val.size();
+    if (size == 0) {
+        return ValueTypeEx {.uint8Array = CArrUI8 {nullptr, ERROR_VALUE}, .tag = TYPE_BLOB};
+    }
+    CArrUI8 arr = CArrUI8 {.head = static_cast<uint8_t*>(malloc(size * sizeof(uint8_t))),
+        .size = size};
+    if (arr.head == nullptr) {
+        return ValueTypeEx {.uint8Array = CArrUI8 {nullptr, ERROR_VALUE}, .tag = TYPE_BLOB};
+    }
+    for (size_t i = 0; i < size; i++) {
+        arr.head[i] = val[i];
+    }
+    return ValueTypeEx {.uint8Array = arr, .tag = TYPE_BLOB};
+}
+
+ValueTypeEx ValueObjectToValueTypeExAsset(const NativeRdb::ValueObject &object)
+{
+    NativeRdb::ValueObject::Asset val = static_cast<NativeRdb::ValueObject::Asset>(object);
+    Asset asset = Asset {
+        .name = MallocCString(val.name),
+        .uri = MallocCString(val.uri),
+        .path = MallocCString(val.path),
+        .createTime = MallocCString(val.createTime),
+        .modifyTime = MallocCString(val.modifyTime),
+        .size = MallocCString(val.size),
+        .status = val.status
+    };
+    return ValueTypeEx {.asset = asset, .tag = TYPE_ASSET};
+}
+
+ValueTypeEx ValueObjectToValueTypeExAssets(const NativeRdb::ValueObject &object)
+{
+    NativeRdb::ValueObject::Assets val = static_cast<NativeRdb::ValueObject::Assets>(object);
+    if (val.size() == 0) {
+        return ValueTypeEx {.assets = Assets{nullptr, ERROR_VALUE}, .tag = TYPE_ASSETS};
+    }
+    Assets assets = Assets {.head = static_cast<Asset*>(malloc(val.size() * sizeof(Asset))), .size = val.size()};
+    if (assets.head == nullptr) {
+        return ValueTypeEx {.assets = Assets{nullptr, ERROR_VALUE}, .tag = TYPE_ASSETS};
+    }
+    for (std::size_t i = 0; i < val.size(); i++) {
+        assets.head[i] = Asset {
+            .name = MallocCString(val[i].name),
+            .uri = MallocCString(val[i].uri),
+            .path = MallocCString(val[i].path),
+            .createTime = MallocCString(val[i].createTime),
+            .modifyTime = MallocCString(val[i].modifyTime),
+            .size = MallocCString(val[i].size),
+            .status = static_cast<int32_t>(val[i].status)
         };
-        return ValueTypeEx {.asset = asset, .tag = TYPE_ASSET};
-    }
-
-    ValueTypeEx ValueObjectToValueTypeExAssets(const NativeRdb::ValueObject& object)
-    {
-        NativeRdb::ValueObject::Assets val = static_cast<NativeRdb::ValueObject::Assets>(object);
-        if (val.size() == 0) {
-            return ValueTypeEx {.assets = Assets{nullptr, ERROR_VALUE}, .tag = TYPE_ASSETS};
-        }
-        Assets assets = Assets {.head = static_cast<Asset*>(malloc(val.size() * sizeof(Asset))), .size = val.size()};
-        if (assets.head == nullptr) {
-            return ValueTypeEx {.assets = Assets{nullptr, ERROR_VALUE}, .tag = TYPE_ASSETS};
-        }
-        for (std::size_t i = 0; i < val.size(); i++) {
-            assets.head[i] = Asset {
-                .name = MallocCString(val[i].name),
-                .uri = MallocCString(val[i].uri),
-                .path = MallocCString(val[i].path),
-                .createTime = MallocCString(val[i].createTime),
-                .modifyTime = MallocCString(val[i].modifyTime),
-                .size = MallocCString(val[i].size),
-                .status = static_cast<int32_t>(val[i].status)
-            };
-        }
-        return ValueTypeEx {.assets = assets, .tag = TYPE_ASSETS};
-    }
-
-    ValueTypeEx ValueObjectToValueTypeExFloatArray(const NativeRdb::ValueObject& object)
-    {
-        std::vector<float> val = static_cast<std::vector<float>>(object);
-        auto size = val.size();
-        if (size == 0) {
-            return ValueTypeEx {.floatArray = CArrFloat {nullptr, ERROR_VALUE}, .tag = TYPE_FLOATARR};
-        }
-        CArrFloat arr = CArrFloat {.head = static_cast<float*>(malloc(size * sizeof(float))),
-            .size = size};
-        if (arr.head == nullptr) {
-            return ValueTypeEx {.floatArray = CArrFloat {nullptr, ERROR_VALUE}, .tag = TYPE_FLOATARR};
-        }
-        for (size_t i = 0; i < size; i++) {
-            arr.head[i] = val[i];
-        }
-        return ValueTypeEx {.floatArray = arr, .tag = TYPE_FLOATARR};
-    }
-
-    ValueTypeEx ValueObjectToValueTypeExBigInt(const NativeRdb::ValueObject& object)
-    {
-        NativeRdb::ValueObject::BigInt bigInt = static_cast<NativeRdb::ValueObject::BigInt>(object);
-        int32_t sign = bigInt.Sign();
-        std::vector<uint64_t> value = bigInt.Value();
-        size_t size = value.size();
-        if (size == 0) {
-            return ValueTypeEx {.bigInt = BigInt {CArrUI8 {nullptr, ERROR_VALUE}, ERROR_VALUE}, .tag = TYPE_BIGINT};
-        }
-        uint8_t *head = static_cast<uint8_t*>(calloc(UI64TOUI8 * size, sizeof(uint8_t)));
-        if (head == nullptr) {
-            return ValueTypeEx {.bigInt = BigInt {CArrUI8 {nullptr, ERROR_VALUE}, ERROR_VALUE}, .tag = TYPE_BIGINT};
-        }
-        for (size_t i = 0; i < size; i++) {
-            for (size_t j = 0; j < UI64TOUI8; j++) {
-                head[UI64TOUI8 * i + j] |= (value[i] >> (BITNUMOFUI64 - (UI64TOUI8 * (j + 1))));
-            }
-        }
-        return ValueTypeEx {.bigInt = BigInt {CArrUI8 {head, UI64TOUI8 * size}, sign}, .tag = TYPE_BIGINT};
     }
+    return ValueTypeEx {.assets = assets, .tag = TYPE_ASSETS};
+}
 
-    ValueTypeEx ValueObjectToValueTypeEx(const NativeRdb::ValueObject& object)
-    {
-        switch (object.GetType()) {
-            case NativeRdb::ValueObject::TYPE_NULL:
-                return ValueTypeEx {.tag = TYPE_NULL};
-            case NativeRdb::ValueObject::TYPE_INT: {
-                return ValueTypeEx {.integer = static_cast<int64_t>(object), .tag = TYPE_INT};
-            }
-            case NativeRdb::ValueObject::TYPE_DOUBLE: {
-                return ValueTypeEx {.dou = static_cast<double>(object), .tag = TYPE_DOU};
-            }
-            case NativeRdb::ValueObject::TYPE_STRING: {
-                return ValueTypeEx {.string = MallocCString(static_cast<std::string>(object)), .tag = TYPE_STR};
-            }
-            case NativeRdb::ValueObject::TYPE_BOOL: {
-                return ValueTypeEx {.boolean = static_cast<bool>(object), .tag = TYPE_BOOL};
-            }
-            case NativeRdb::ValueObject::TYPE_BLOB: {
-                return ValueObjectToValueTypeExBlob(object);
-            }
-            case NativeRdb::ValueObject::TYPE_ASSET: {
-                return ValueObjectToValueTypeExAsset(object);
-            }
-            case NativeRdb::ValueObject::TYPE_ASSETS: {
-                return ValueObjectToValueTypeExAssets(object);
-            }
-            case NativeRdb::ValueObject::TYPE_VECS: {
-                return ValueObjectToValueTypeExFloatArray(object);
-            }
-            case NativeRdb::ValueObject::TYPE_BIGINT: {
-                return ValueObjectToValueTypeExBigInt(object);
-            }
-            case NativeRdb::ValueObject::TYPE_BUTT:
-                return ValueTypeEx {.tag = 128};
-            default:
-                return ValueTypeEx {.tag = TYPE_NULL};
+ValueTypeEx ValueObjectToValueTypeExFloatArray(const NativeRdb::ValueObject &object)
+{
+    std::vector<float> val = static_cast<std::vector<float>>(object);
+    auto size = val.size();
+    if (size == 0) {
+        return ValueTypeEx {.floatArray = CArrFloat {nullptr, ERROR_VALUE}, .tag = TYPE_FLOATARR};
+    }
+    CArrFloat arr = CArrFloat {.head = static_cast<float*>(malloc(size * sizeof(float))),
+        .size = size};
+    if (arr.head == nullptr) {
+        return ValueTypeEx {.floatArray = CArrFloat {nullptr, ERROR_VALUE}, .tag = TYPE_FLOATARR};
+    }
+    for (size_t i = 0; i < size; i++) {
+        arr.head[i] = val[i];
+    }
+    return ValueTypeEx {.floatArray = arr, .tag = TYPE_FLOATARR};
+}
+
+ValueTypeEx ValueObjectToValueTypeExBigInt(const NativeRdb::ValueObject &object)
+{
+    NativeRdb::ValueObject::BigInt bigInt = static_cast<NativeRdb::ValueObject::BigInt>(object);
+    int32_t sign = bigInt.Sign();
+    std::vector<uint64_t> value = bigInt.Value();
+    size_t size = value.size();
+    if (size == 0) {
+        return ValueTypeEx {.bigInt = BigInt {CArrUI8 {nullptr, ERROR_VALUE}, ERROR_VALUE}, .tag = TYPE_BIGINT};
+    }
+    uint8_t *head = static_cast<uint8_t*>(calloc(UI64TOUI8 * size, sizeof(uint8_t)));
+    if (head == nullptr) {
+        return ValueTypeEx {.bigInt = BigInt {CArrUI8 {nullptr, ERROR_VALUE}, ERROR_VALUE}, .tag = TYPE_BIGINT};
+    }
+    for (size_t i = 0; i < size; i++) {
+        for (size_t j = 0; j < UI64TOUI8; j++) {
+            head[UI64TOUI8 * i + j] |= (value[i] >> (BITNUMOFUI64 - (UI64TOUI8 * (j + 1))));
         }
     }
+    return ValueTypeEx {.bigInt = BigInt {CArrUI8 {head, UI64TOUI8 * size}, sign}, .tag = TYPE_BIGINT};
+}
 
-    CArrStr VectorToCArrStr(const std::vector<std::string> &devices)
-    {
-        CArrStr cArrStr{0};
-        if (devices.size() == 0) {
-            return cArrStr;
+ValueTypeEx ValueObjectToValueTypeEx(const NativeRdb::ValueObject &object)
+{
+    switch (object.GetType()) {
+        case NativeRdb::ValueObject::TYPE_NULL:
+            return ValueTypeEx {.tag = TYPE_NULL};
+        case NativeRdb::ValueObject::TYPE_INT: {
+            return ValueTypeEx {.integer = static_cast<int64_t>(object), .tag = TYPE_INT};
         }
-        cArrStr.head = static_cast<char**>(malloc(sizeof(char*) * devices.size()));
-        if (cArrStr.head == nullptr) {
-            return cArrStr;
+        case NativeRdb::ValueObject::TYPE_DOUBLE: {
+            return ValueTypeEx {.dou = static_cast<double>(object), .tag = TYPE_DOU};
         }
-        for (size_t i = 0; i < devices.size(); i++) {
-            cArrStr.head[i] = MallocCString(devices[i]);
+        case NativeRdb::ValueObject::TYPE_STRING: {
+            return ValueTypeEx {.string = MallocCString(static_cast<std::string>(object)), .tag = TYPE_STR};
         }
-        cArrStr.size = static_cast<int64_t>(devices.size());
-        return cArrStr;
+        case NativeRdb::ValueObject::TYPE_BOOL: {
+            return ValueTypeEx {.boolean = static_cast<bool>(object), .tag = TYPE_BOOL};
+        }
+        case NativeRdb::ValueObject::TYPE_BLOB: {
+            return ValueObjectToValueTypeExBlob(object);
+        }
+        case NativeRdb::ValueObject::TYPE_ASSET: {
+            return ValueObjectToValueTypeExAsset(object);
+        }
+        case NativeRdb::ValueObject::TYPE_ASSETS: {
+            return ValueObjectToValueTypeExAssets(object);
+        }
+        case NativeRdb::ValueObject::TYPE_VECS: {
+            return ValueObjectToValueTypeExFloatArray(object);
+        }
+        case NativeRdb::ValueObject::TYPE_BIGINT: {
+            return ValueObjectToValueTypeExBigInt(object);
+        }
+        case NativeRdb::ValueObject::TYPE_BUTT:
+            return ValueTypeEx {.tag = 128};
+        default:
+            return ValueTypeEx {.tag = TYPE_NULL};
     }
+}
 
-    std::vector<std::string> CArrStrToVector(CArrStr carr)
-    {
-        std::vector<std::string> arr;
-        for (int i = 0; i < carr.size; i++) {
-            if (carr.head[i] != nullptr) {
-                arr.push_back(carr.head[i]);
-            } else {
-                arr.push_back(std::string());
-            }
-        }
-        return arr;
+CArrStr VectorToCArrStr(const std::vector<std::string> &devices)
+{
+    CArrStr cArrStr{0};
+    if (devices.size() == 0) {
+        return cArrStr;
+    }
+    cArrStr.head = static_cast<char**>(malloc(sizeof(char*) * devices.size()));
+    if (cArrStr.head == nullptr) {
+        return cArrStr;
+    }
+    for (size_t i = 0; i < devices.size(); i++) {
+        cArrStr.head[i] = MallocCString(devices[i]);
     }
+    cArrStr.size = static_cast<int64_t>(devices.size());
+    return cArrStr;
+}
 
-    std::vector<uint8_t> CArrUI8ToVector(CArrUI8 carr)
-    {
-        std::vector<std::uint8_t> arr;
-        for (int i = 0; i < carr.size; i++) {
+std::vector<std::string> CArrStrToVector(CArrStr carr)
+{
+    std::vector<std::string> arr;
+    for (int i = 0; i < carr.size; i++) {
+        if (carr.head[i] != nullptr) {
             arr.push_back(carr.head[i]);
-        }
-        return arr;
-    }
-
-    std::variant<std::monostate, std::string, int64_t, double> RetPRIKeyTypeToVariant(RetPRIKeyType &value)
-    {
-        switch (value.tag) {
-            case NativeRdb::ValueObject::TYPE_INT:
-                return std::variant<std::monostate, std::string, int64_t, double>(value.integer);
-            case NativeRdb::ValueObject::TYPE_DOUBLE:
-                return std::variant<std::monostate, std::string, int64_t, double>(value.dou);
-            case NativeRdb::ValueObject::TYPE_STRING:
-                return std::variant<std::monostate, std::string, int64_t, double>(value.string);
-            default:
-                return std::variant<std::monostate, std::string, int64_t, double>(0);
-        }
-    }
-
-    RetPRIKeyType VariantToRetPRIKeyType(const std::variant<std::monostate, std::string, int64_t, double> &value)
-    {
-        if (std::holds_alternative<int64_t>(value)) {
-            return RetPRIKeyType{ .integer = std::get<int64_t>(value), .dou = 0.0,
-                .string = nullptr, .tag = NativeRdb::ValueObject::TYPE_INT };
-        } else if (std::holds_alternative<double>(value)) {
-            return RetPRIKeyType{ .integer = 0, .dou = std::get<double>(value),
-                .string = nullptr, .tag = NativeRdb::ValueObject::TYPE_DOUBLE };
-        } else if (std::holds_alternative<std::string>(value)) {
-            return RetPRIKeyType{ .integer = 0, .dou = 0.0,
-                .string = MallocCString(std::get<std::string>(value)), .tag = NativeRdb::ValueObject::TYPE_STRING };
         } else {
-            return RetPRIKeyType{0};
+            arr.push_back(std::string());
         }
     }
+    return arr;
+}
 
-    std::vector<NativeRdb::RdbStore::PRIKey> CArrPRIKeyTypeToPRIKeyArray(CArrPRIKeyType &cPrimaryKeys)
-    {
-        std::vector<NativeRdb::RdbStore::PRIKey> res = std::vector<NativeRdb::RdbStore::PRIKey>();
-        for (int64_t i = 0; i < cPrimaryKeys.size; i++) {
-            res.push_back(RetPRIKeyTypeToVariant(cPrimaryKeys.head[i]));
-        }
-        return res;
+std::vector<uint8_t> CArrUI8ToVector(CArrUI8 carr)
+{
+    std::vector<std::uint8_t> arr;
+    for (int i = 0; i < carr.size; i++) {
+        arr.push_back(carr.head[i]);
     }
+    return arr;
+}
 
-    ModifyTime MapToModifyTime(std::map<NativeRdb::RdbStore::PRIKey, NativeRdb::RdbStore::Date> &map, int32_t &errCode)
-    {
-        ModifyTime modifyTime{0};
-        modifyTime.size = static_cast<int64_t>(map.size());
-        if (modifyTime.size == 0) {
-            return ModifyTime{0};
-        }
-        modifyTime.key = static_cast<RetPRIKeyType*>(malloc(sizeof(RetPRIKeyType) * modifyTime.size));
-        modifyTime.value = static_cast<uint64_t*>(malloc(sizeof(uint64_t) * modifyTime.size));
-        if (modifyTime.key == nullptr || modifyTime.value == nullptr) {
-            free(modifyTime.key);
-            free(modifyTime.value);
-            errCode = -1;
-            return ModifyTime{0};
-        }
-        int64_t index = 0;
-        for (auto it = map.begin(); it != map.end(); ++it) {
-            modifyTime.key[index] = VariantToRetPRIKeyType(it->first);
-            modifyTime.value[index] = static_cast<uint64_t>((it->second).date);
-            index++;
-        }
-        return modifyTime;
+std::variant<std::monostate, std::string, int64_t, double> RetPRIKeyTypeToVariant(RetPRIKeyType &value)
+{
+    switch (value.tag) {
+        case NativeRdb::ValueObject::TYPE_INT:
+            return std::variant<std::monostate, std::string, int64_t, double>(value.integer);
+        case NativeRdb::ValueObject::TYPE_DOUBLE:
+            return std::variant<std::monostate, std::string, int64_t, double>(value.dou);
+        case NativeRdb::ValueObject::TYPE_STRING:
+            return std::variant<std::monostate, std::string, int64_t, double>(value.string);
+        default:
+            return std::variant<std::monostate, std::string, int64_t, double>(0);
     }
+}
 
-    CArrPRIKeyType VectorToCArrPRIKeyType(std::vector<DistributedRdb::RdbStoreObserver::PrimaryKey> arr)
-    {
-        CArrPRIKeyType types{0};
-        if (arr.size() == 0) {
-            return types;
-        }
-        types.head = static_cast<RetPRIKeyType*>(malloc(sizeof(RetPRIKeyType) * arr.size()));
-        if (types.head == nullptr) {
-            return types;
-        }
-        for (size_t i = 0; i < arr.size(); i++) {
-            types.head[i] = VariantToRetPRIKeyType(arr[i]);
-        }
-        types.size = static_cast<int64_t>(arr.size());
-        return types;
+RetPRIKeyType VariantToRetPRIKeyType(const std::variant<std::monostate, std::string, int64_t, double> &value)
+{
+    if (std::holds_alternative<int64_t>(value)) {
+        return RetPRIKeyType{ .integer = std::get<int64_t>(value), .dou = 0.0,
+            .string = nullptr, .tag = NativeRdb::ValueObject::TYPE_INT };
+    } else if (std::holds_alternative<double>(value)) {
+        return RetPRIKeyType{ .integer = 0, .dou = std::get<double>(value),
+            .string = nullptr, .tag = NativeRdb::ValueObject::TYPE_DOUBLE };
+    } else if (std::holds_alternative<std::string>(value)) {
+        return RetPRIKeyType{ .integer = 0, .dou = 0.0,
+            .string = MallocCString(std::get<std::string>(value)), .tag = NativeRdb::ValueObject::TYPE_STRING };
+    } else {
+        return RetPRIKeyType{0};
     }
+}
 
-    RetChangeInfo ToRetChangeInfo(const DistributedRdb::Origin &origin,
-        DistributedRdb::RdbStoreObserver::ChangeInfo::iterator info)
-    {
-        RetChangeInfo retInfo{0};
-        retInfo.table = MallocCString(info->first);
-        retInfo.type = origin.dataType;
-        retInfo.inserted = VectorToCArrPRIKeyType(info->
-            second[DistributedRdb::RdbStoreObserver::ChangeType::CHG_TYPE_INSERT]);
-        retInfo.updated = VectorToCArrPRIKeyType(info->
-            second[DistributedRdb::RdbStoreObserver::ChangeType::CHG_TYPE_UPDATE]);
-        retInfo.deleted = VectorToCArrPRIKeyType(info->
-            second[DistributedRdb::RdbStoreObserver::ChangeType::CHG_TYPE_DELETE]);
-        return retInfo;
-    }
-
-    CArrRetChangeInfo ToCArrRetChangeInfo(const DistributedRdb::Origin &origin,
-        const DistributedRdb::RdbStoreObserver::PrimaryFields &fields,
-        DistributedRdb::RdbStoreObserver::ChangeInfo &&changeInfo)
-    {
-        CArrRetChangeInfo infos{0};
-        if (changeInfo.size() == 0) {
-            return infos;
-        }
-        infos.head = static_cast<RetChangeInfo*>(malloc(sizeof(RetChangeInfo) * changeInfo.size()));
-        if (infos.head == nullptr) {
-            return CArrRetChangeInfo{0};
-        }
-        int64_t index = 0;
-        for (auto it = changeInfo.begin(); it != changeInfo.end(); ++it) {
-            infos.head[index] = ToRetChangeInfo(origin, it);
-            index++;
-        }
-        infos.size = static_cast<int64_t>(changeInfo.size());
-        return infos;
+std::vector<NativeRdb::RdbStore::PRIKey> CArrPRIKeyTypeToPRIKeyArray(CArrPRIKeyType &cPrimaryKeys)
+{
+    std::vector<NativeRdb::RdbStore::PRIKey> res = std::vector<NativeRdb::RdbStore::PRIKey>();
+    for (int64_t i = 0; i < cPrimaryKeys.size; i++) {
+        res.push_back(RetPRIKeyTypeToVariant(cPrimaryKeys.head[i]));
     }
+    return res;
+}
 
-    CStatistic ToStatistic(DistributedRdb::Statistic statistic)
-    {
-        return CStatistic{ .total = statistic.total, .successful = statistic.success,
-            .failed = statistic.failed, .remained = statistic.untreated };
-    }
+ModifyTime MapToModifyTime(std::map<NativeRdb::RdbStore::PRIKey, NativeRdb::RdbStore::Date> &map, int32_t &errCode)
+{
+    ModifyTime modifyTime{0};
+    modifyTime.size = static_cast<int64_t>(map.size());
+    if (modifyTime.size == 0) {
+        return ModifyTime{0};
+    }
+    modifyTime.key = static_cast<RetPRIKeyType*>(malloc(sizeof(RetPRIKeyType) * modifyTime.size));
+    modifyTime.value = static_cast<uint64_t*>(malloc(sizeof(uint64_t) * modifyTime.size));
+    if (modifyTime.key == nullptr || modifyTime.value == nullptr) {
+        free(modifyTime.key);
+        free(modifyTime.value);
+        errCode = -1;
+        return ModifyTime{0};
+    }
+    int64_t index = 0;
+    for (auto it = map.begin(); it != map.end(); ++it) {
+        modifyTime.key[index] = VariantToRetPRIKeyType(it->first);
+        modifyTime.value[index] = static_cast<uint64_t>((it->second).date);
+        index++;
+    }
+    return modifyTime;
+}
 
-    CTableDetails ToCTableDetails(DistributedRdb::TableDetail detail)
-    {
-        return CTableDetails{ .upload = ToStatistic(detail.upload), .download = ToStatistic(detail.download) };
+CArrPRIKeyType VectorToCArrPRIKeyType(std::vector<DistributedRdb::RdbStoreObserver::PrimaryKey> arr)
+{
+    CArrPRIKeyType types{0};
+    if (arr.size() == 0) {
+        return types;
+    }
+    types.head = static_cast<RetPRIKeyType*>(malloc(sizeof(RetPRIKeyType) * arr.size()));
+    if (types.head == nullptr) {
+        return types;
+    }
+    for (size_t i = 0; i < arr.size(); i++) {
+        types.head[i] = VariantToRetPRIKeyType(arr[i]);
     }
+    types.size = static_cast<int64_t>(arr.size());
+    return types;
+}
 
-    CDetails ToCDetails(DistributedRdb::TableDetails details)
-    {
-        if (details.size() == 0) {
-            return CDetails{0};
-        }
-        char** key = static_cast<char**>(malloc(sizeof(char*) * details.size()));
-        CTableDetails* value = static_cast<CTableDetails*>(malloc(sizeof(CTableDetails) * details.size()));
-        if (key == nullptr || value == nullptr) {
-            free(key);
-            free(value);
-            return CDetails{0};
-        }
-        int64_t index = 0;
-        for (auto it = details.begin(); it != details.end(); ++it) {
-            key[index] = MallocCString(it->first);
-            value[index] = ToCTableDetails(it->second);
-            index++;
-        }
-        return CDetails{ .key = key, .value = value, .size = details.size() };
+RetChangeInfo ToRetChangeInfo(const DistributedRdb::Origin &origin,
+    DistributedRdb::RdbStoreObserver::ChangeInfo::iterator info)
+{
+    RetChangeInfo retInfo{0};
+    retInfo.table = MallocCString(info->first);
+    retInfo.type = origin.dataType;
+    retInfo.inserted = VectorToCArrPRIKeyType(info->
+        second[DistributedRdb::RdbStoreObserver::ChangeType::CHG_TYPE_INSERT]);
+    retInfo.updated = VectorToCArrPRIKeyType(info->
+        second[DistributedRdb::RdbStoreObserver::ChangeType::CHG_TYPE_UPDATE]);
+    retInfo.deleted = VectorToCArrPRIKeyType(info->
+        second[DistributedRdb::RdbStoreObserver::ChangeType::CHG_TYPE_DELETE]);
+    return retInfo;
+}
+
+CArrRetChangeInfo ToCArrRetChangeInfo(const DistributedRdb::Origin &origin,
+    const DistributedRdb::RdbStoreObserver::PrimaryFields &fields,
+    DistributedRdb::RdbStoreObserver::ChangeInfo &&changeInfo)
+{
+    CArrRetChangeInfo infos{0};
+    if (changeInfo.size() == 0) {
+        return infos;
+    }
+    infos.head = static_cast<RetChangeInfo*>(malloc(sizeof(RetChangeInfo) * changeInfo.size()));
+    if (infos.head == nullptr) {
+        return CArrRetChangeInfo{0};
+    }
+    int64_t index = 0;
+    for (auto it = changeInfo.begin(); it != changeInfo.end(); ++it) {
+        infos.head[index] = ToRetChangeInfo(origin, it);
+        index++;
     }
+    infos.size = static_cast<int64_t>(changeInfo.size());
+    return infos;
+}
 
-    CProgressDetails ToCProgressDetails(const  DistributedRdb::Details &details)
-    {
-        if (details.empty()) {
-            return CProgressDetails{0};
-        }
-        DistributedRdb::ProgressDetail detail = details.begin() ->second;
-        return CProgressDetails{ .schedule = detail.progress, .code = detail.code,
-            .details = ToCDetails(detail.details) };
+CStatistic ToStatistic(DistributedRdb::Statistic statistic)
+{
+    return CStatistic{ .total = statistic.total, .successful = statistic.success,
+        .failed = statistic.failed, .remained = statistic.untreated };
+}
+
+CTableDetails ToCTableDetails(DistributedRdb::TableDetail detail)
+{
+    return CTableDetails{ .upload = ToStatistic(detail.upload), .download = ToStatistic(detail.download) };
+}
+
+CDetails ToCDetails(DistributedRdb::TableDetails details)
+{
+    if (details.size() == 0) {
+        return CDetails{0};
+    }
+    char **key = static_cast<char**>(malloc(sizeof(char*) * details.size()));
+    CTableDetails *value = static_cast<CTableDetails*>(malloc(sizeof(CTableDetails) * details.size()));
+    if (key == nullptr || value == nullptr) {
+        free(key);
+        free(value);
+        return CDetails{0};
+    }
+    int64_t index = 0;
+    for (auto it = details.begin(); it != details.end(); ++it) {
+        key[index] = MallocCString(it->first);
+        value[index] = ToCTableDetails(it->second);
+        index++;
+    }
+    return CDetails{ .key = key, .value = value, .size = details.size() };
+}
+
+CProgressDetails ToCProgressDetails(const  DistributedRdb::Details &details)
+{
+    if (details.empty()) {
+        return CProgressDetails{0};
     }
+    DistributedRdb::ProgressDetail detail = details.begin() ->second;
+    return CProgressDetails{ .schedule = detail.progress, .code = detail.code,
+        .details = ToCDetails(detail.details) };
 }
-}
\ No newline at end of file
+} // namespace Relational
+} // namespace OHOS
\ No newline at end of file