diff --git a/frameworks/innerkitsimpl/distributeddatafwk/include/cov_util.h b/frameworks/innerkitsimpl/distributeddatafwk/include/cov_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..ec99a90430841291a32f70e2f8f3cc77203d3c86
--- /dev/null
+++ b/frameworks/innerkitsimpl/distributeddatafwk/include/cov_util.h
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_DISTRIBUTED_DATA_FRAMEWORKS_INNERKITSIMPL_NATIVE_PREFERENCES_INCLUDE_COV_UTIL_H
+#define OHOS_DISTRIBUTED_DATA_FRAMEWORKS_INNERKITSIMPL_NATIVE_PREFERENCES_INCLUDE_COV_UTIL_H
+
+#include <string>
+#include <variant>
+#include <set>
+#include "data_query.h"
+
+namespace OHOS {
+namespace DistributedKv {
+class CovUtil final {
+public:
+    template<typename _VTp, typename _TTp, typename _First>
+    static auto FillField(const std::string &field, const _VTp &data, _TTp &target)
+    {
+        return target();
+    }
+
+    template<typename _VTp, typename _TTp, typename _First, typename _Second, typename ..._Rest>
+    static auto FillField(const std::string &field, const _VTp &data, _TTp &target)
+    {
+        if ((sizeof ...(_Rest) + 1) == data.index()) {
+            return target(field, std::get<(sizeof ...(_Rest) + 1)>(data));
+        }
+        return FillField<_VTp, _TTp, _Second, _Rest...>(field, data, target);
+    }
+
+    template<typename _TTp, typename ..._Types>
+    static auto FillField(const std::string &field, const std::variant<_Types...> &data, _TTp &target)
+    {
+        return FillField<decltype(data), _TTp, _Types...>(field, data, target);
+    }
+};
+
+enum class QueryType {
+    EQUAL = 0,
+    NOT_EQUAL = 1,
+    GREATER = 2,
+    LESS = 3,
+    GREATER_OR_EQUAL = 4,
+    LESS_OR_EQUAL = 5,
+    IN = 6,
+    NOT_IN = 7
+};
+
+class Querys {
+public:
+    Querys(OHOS::DistributedKv::DataQuery *dataQuery, QueryType type) : dataQuery_(dataQuery), type_(type) {};
+    template<typename T>
+    int operator()(const std::string &field, const T &value)
+    {
+        if (type_ == QueryType::EQUAL) {
+            dataQuery_->EqualTo(field, value);
+        } else if (type_ == QueryType::NOT_EQUAL) {
+            dataQuery_->NotEqualTo(field, value);
+        } else if (type_ == QueryType::GREATER) {
+            dataQuery_->GreaterThan(field, value);
+        } else if (type_ == QueryType::LESS) {
+            dataQuery_->LessThan(field, value);
+        } else if (type_ == QueryType::GREATER_OR_EQUAL) {
+            dataQuery_->GreaterThanOrEqualTo(field, value);
+        } else if (type_ == QueryType::LESS_OR_EQUAL) {
+            dataQuery_->LessThanOrEqualTo(field, value);
+        }
+        return 0;
+    }
+
+    template<typename T>
+    int operator()(const std::string &field, const std::vector<T> &value)
+    {
+        return 0;
+    }
+
+    int operator()()
+    {
+        return 0;
+    }
+
+private:
+    OHOS::DistributedKv::DataQuery *dataQuery_;
+    QueryType type_;
+};
+
+class InOrNotIn {
+public:
+    InOrNotIn(OHOS::DistributedKv::DataQuery *dataQuery, QueryType type) : dataQuery_(dataQuery), type_(type)  {};
+    template<typename T>
+    int operator()(const std::string &field, const T &value)
+    {
+        return 0;
+    }
+    template<typename T>
+    int operator()(const std::string &field, const std::vector<T> &value)
+    {
+        if (type_ == QueryType::IN) {
+            dataQuery_->In(field, value);
+        } else if (type_ == QueryType::NOT_IN) {
+            dataQuery_->NotIn(field, value);
+        }
+        return 0;
+    }
+
+    int operator()()
+    {
+        return 0;
+    }
+
+private:
+    OHOS::DistributedKv::DataQuery *dataQuery_;
+    QueryType type_;
+};
+
+// class In  {
+// public:
+//     In(OHOS::DistributedKv::DataQuery *dataQuery) : dataQuery_(dataQuery) {};
+//     template<typename T>
+//     int operator()(const std::string &field, const T &value)
+//     {
+//         return 0;
+//     }
+//     template<typename T>
+//     int operator()(const std::string &field, const std::vector<T> &value)
+//     {
+//         dataQuery_->In(field, value);
+//         return 0;
+//     }
+
+//     int operator()()
+//     {
+//         return 0;
+//     }
+// private:
+//     OHOS::DistributedKv::DataQuery *dataQuery_;
+// };
+
+// class NotIn  {
+// public:
+//     NotIn(OHOS::DistributedKv::DataQuery *dataQuery) : dataQuery_(dataQuery) {};
+//     template<typename T>
+//     int operator()(const std::string &field, const T &value)
+//     {
+//         return 0;
+//     }
+//     template<typename T>
+//     int operator()(const std::string &field, const std::vector<T> &value)
+//     {
+//         dataQuery_->In(field, value);
+//         return 0;
+//     }
+
+//     int operator()()
+//     {
+//         return 0;
+//     }
+// private:
+//     OHOS::DistributedKv::DataQuery *dataQuery_;
+// };
+}
+}
+
+#endif // OHOS_DISTRIBUTED_DATA_FRAMEWORKS_INNERKITSIMPL_NATIVE_PREFERENCES_INCLUDE_COV_UTIL_H
diff --git a/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_datashare_result_set.h b/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_datashare_bridge.h
similarity index 70%
rename from frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_datashare_result_set.h
rename to frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_datashare_bridge.h
index bbfa619b198cdeeb139a61d8b5c62658e9c274d8..a121fed11c4b369b018119445dcb008eba8f2bb3 100644
--- a/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_datashare_result_set.h
+++ b/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_datashare_bridge.h
@@ -13,8 +13,8 @@
  * limitations under the License.
  */
 
-#ifndef KVSTORE_DATASHARE_RESULT_SET_H
-#define KVSTORE_DATASHARE_RESULT_SET_H
+#ifndef KVSTORE_DATASHARE_BRIDGE_H
+#define KVSTORE_DATASHARE_BRIDGE_H
 
 #include "kvstore_result_set.h"
 #include "single_kvstore.h"
@@ -23,17 +23,17 @@
 
 namespace OHOS {
 namespace DistributedKv {
-class KvStoreDataShareResultSet : public DataShare::ResultSetBridge {
+class KvStoreDataShareBridge : public DataShare::ResultSetBridge {
 public:
-    KvStoreDataShareResultSet(std::shared_ptr<KvStoreResultSet> kvResultSet);
+    KvStoreDataShareBridge(std::shared_ptr<KvStoreResultSet> kvResultSet);
 
-    ~KvStoreDataShareResultSet() = default;
+    ~KvStoreDataShareBridge() = default;
 
     int GetRowCount(int32_t &count) override;
 
-    int GetAllColumnNames(std::vector<std::string> &columnsName) override;
+    int GetAllColumnNames(std::vector<std::string> &columnNames) override;
     
-    bool OnGo(int32_t start, int32_t target, DataShare::ResultSetBridge::Writer &writer) override;
+    bool OnGo(int32_t startRowIndex, int32_t targetRowIndex, DataShare::ResultSetBridge::Writer &writer) override;
   
 private:
     int Count();
@@ -45,8 +45,7 @@ private:
     int32_t resultRowCount {INVALID_COUNT};
 
     std::shared_ptr<KvStoreResultSet> kvResultSet_;
-
 };
 } // namespace DistributedKv
 } // namespace OHOS
-#endif // KVSTORE_DATASHARE_RESULT_SET_H
+#endif // KVSTORE_DATASHARE_BRIDGE_H
diff --git a/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_predicates.h b/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_predicates.h
deleted file mode 100644
index 5f5fbdeda891233766d3110eb50937612f8c68d6..0000000000000000000000000000000000000000
--- a/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_predicates.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * Copyright (c) 2022 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef KVSTORE_PREDICATE_H
-#define KVSTORE_PREDICATE_H
-
-#include <map>
-#include "data_query.h"
-#include "types.h"
-#include "datashare_predicates.h"
-
-namespace OHOS {
-namespace DistributedKv {
-class KvStorePredicates {
-public:
-    struct Context {
-        int intValue;
-        int64_t longValue;
-        double doubleValue;
-        bool boolValue;
-        std::string field;
-        std::string stringValue;
-        std::vector<int> intList;
-        std::vector<int64_t> longList;
-        std::vector<double> doubleList;
-        std::vector<std::string> stringList;
-        DataShare::DataSharePredicatesObjectType innerType;
-    };
-    KvStorePredicates() = default;
-    ~KvStorePredicates() = default;
-    Status ToQuery(const DataShare::DataSharePredicates &predicates, DataQuery &query);
-    Status GetKeys(const DataShare::DataSharePredicates &predicates, std::vector<Key> &keys);
-private:
-    Status EqualTo(const DataShare::OperationItem &oper, DataQuery &query);
-    Status NotEqualTo(const DataShare::OperationItem &oper, DataQuery &query);
-    Status GreaterThan(const DataShare::OperationItem &oper, DataQuery &query);
-    Status LessThan(const DataShare::OperationItem &oper, DataQuery &query);
-    Status GreaterThanOrEqualTo(const DataShare::OperationItem &oper, DataQuery &query);
-    Status LessThanOrEqualTo(const DataShare::OperationItem &oper, DataQuery &query);
-    Status And(const DataShare::OperationItem &oper, DataQuery &query);
-    Status Or(const DataShare::OperationItem &oper, DataQuery &query);
-    Status IsNull(const DataShare::OperationItem &oper, DataQuery &query);
-    Status IsNotNull(const DataShare::OperationItem &oper, DataQuery &query);
-    Status In(const DataShare::OperationItem &oper, DataQuery &query);
-    Status NotIn(const DataShare::OperationItem &oper, DataQuery &query);
-    Status Like(const DataShare::OperationItem &oper, DataQuery &query);
-    Status Unlike(const DataShare::OperationItem &oper, DataQuery &query);
-    Status OrderByAsc(const DataShare::OperationItem &oper, DataQuery &query);
-    Status OrderByDesc(const DataShare::OperationItem &oper, DataQuery &query);
-    Status Limit(const DataShare::OperationItem &oper, DataQuery &query);
-    Status InKeys(const DataShare::OperationItem &oper, DataQuery &query);
-    Status KeyPrefix(const DataShare::OperationItem &oper, DataQuery &query);
-    Status GetContext(const DataShare::OperationItem &oper, Context &context);
-    using QueryHandler = Status (KvStorePredicates::*)(const DataShare::OperationItem &, DataQuery &);
-    static constexpr QueryHandler HANDLERS[DataShare::LAST_TYPE] = {
-            [DataShare::EQUAL_TO] = &KvStorePredicates::EqualTo,
-            [DataShare::NOT_EQUAL_TO] = &KvStorePredicates::NotEqualTo,
-            [DataShare::GREATER_THAN] = &KvStorePredicates::GreaterThan,
-            [DataShare::LESS_THAN] = &KvStorePredicates::LessThan,
-            [DataShare::GREATER_THAN_OR_EQUAL_TO] = &KvStorePredicates::GreaterThanOrEqualTo,
-            [DataShare::LESS_THAN_OR_EQUAL_TO] = &KvStorePredicates::LessThanOrEqualTo,
-            [DataShare::AND] = &KvStorePredicates::And,
-            [DataShare::OR] = &KvStorePredicates::Or,
-            [DataShare::IS_NULL] = &KvStorePredicates::IsNull,
-            [DataShare::IS_NOT_NULL] = &KvStorePredicates::IsNotNull,
-            [DataShare::NOT_IN] = &KvStorePredicates::NotIn,
-            [DataShare::LIKE] = &KvStorePredicates::Like,
-            [DataShare::UNLIKE] = &KvStorePredicates::Unlike,
-            [DataShare::ORDER_BY_ASC] = &KvStorePredicates::OrderByAsc,
-            [DataShare::ORDER_BY_DESC] = &KvStorePredicates::OrderByDesc,
-            [DataShare::LIMIT] = &KvStorePredicates::Limit,
-            [DataShare::IN_KEY] = &KvStorePredicates::InKeys,
-            [DataShare::KEY_PREFIX] = &KvStorePredicates::KeyPrefix,
-            [DataShare::IN] = &KvStorePredicates::In,
-            };
-};
-}// namespace DistributedKv
-}//namespace 
-
-#endif  // KVSTORE_PREDICATE_H
-
-
diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp
index 39e05924fb3e8cc870b74f164f751b05aa134901..d0348924b8abc73782b1e9aebb50d44f15ad0da3 100644
--- a/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp
+++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp
@@ -16,40 +16,43 @@
 #define LOG_TAG "KvUtils"
 
 #include "kv_utils.h"
-#include "kvstore_datashare_result_set.h"
-#include "kvstore_predicates.h"
+#include "cov_util.h"
 #include "log_print.h"
 #include "data_query.h"
+#include "kvstore_datashare_bridge.h"
 
 namespace OHOS {
 namespace DistributedKv {
 using namespace DataShare;
+using namespace DistributedData;
 const std::string KvUtils::KEY = "key";
 const std::string KvUtils::VALUE = "value";
+constexpr KvUtils::QueryHandler KvUtils::HANDLERS[LAST_TYPE];
+
 std::shared_ptr<ResultSetBridge> KvUtils::ToResultSetBridge(std::shared_ptr<KvStoreResultSet> resultSet)
 {
     if (resultSet == nullptr) {
         ZLOGE("param error, kvResultSet nullptr");
         return nullptr;
     }
-    return std::make_shared<KvStoreDataShareResultSet>(resultSet);
+    return std::make_shared<KvStoreDataShareBridge>(resultSet);
 }
 
 Status KvUtils::ToQuery(const DataSharePredicates &predicates, DataQuery &query)
 {
-  
-    auto kvPredicates = std::make_shared<KvStorePredicates>();
-    Status status = kvPredicates->ToQuery(predicates, query);
-    if (status != Status::SUCCESS) {
-        ZLOGE("ToQuery failed: %{public}d", status);
-        return status;
+    std::list<OperationItem> operations = predicates.GetOperationList();
+    for (const auto &oper : operations) {
+        if (oper.operation < 0 || oper.operation >= LAST_TYPE) {
+            ZLOGE("operation param error");
+            return Status::NOT_SUPPORT;
+        }
+        (*HANDLERS[oper.operation])(oper, query);
     }
-    return status;
+    return Status::SUCCESS;
 }
 
 std::vector<Entry> KvUtils::ToEntries(const std::vector<DataShareValuesBucket> &valueBuckets)
 {
-
     std::vector<Entry> entries;
     for (const auto &val : valueBuckets) {
         Entry entry = ToEntry(val);
@@ -80,7 +83,30 @@ Entry KvUtils::ToEntry(const DataShareValuesBucket &valueBucket)
     return entry;
 }
 
-Status KvUtils::ToEntryData(const std::map<std::string, DataShareValueObject> &valuesMap, const std::string field, Blob &kv)
+Status KvUtils::GetKeys(const DataSharePredicates &predicates, std::vector<Key> &keys)
+{
+    std::list<OperationItem> operations = predicates.GetOperationList();
+    if (operations.empty()) {
+        ZLOGE("operations is null");
+        return Status::ERROR;
+    }
+
+    std::vector<std::string> myKeys;
+    for (const auto &oper : operations) {
+        if (oper.operation != IN_KEY) {
+            ZLOGE("find operation failed");
+            return Status::NOT_SUPPORT;
+        }
+        std::vector<std::string> val = oper.para1;
+        myKeys.insert(myKeys.end(), val.begin(), val.end());
+    }
+    for (const auto &it : myKeys) {
+        keys.push_back(it.c_str());
+    }
+    return Status::SUCCESS;
+}
+
+Status KvUtils::ToEntryData(const std::map<std::string, DataShareValueObject> &valuesMap, const std::string field, Blob &blob)
 {
     auto it = valuesMap.find(field);
     if (it == valuesMap.end()) {
@@ -88,18 +114,143 @@ Status KvUtils::ToEntryData(const std::map<std::string, DataShareValueObject> &v
         return Status::ERROR;
     }
     DataShareValueObjectType type = it->second.GetType();
-    if (type != DataShareValueObjectType::TYPE_BLOB) {
-        ZLOGE("key type is not TYPE_BLOB");
-        return Status::ERROR;
-    }
-    std::vector<uint8_t> data;
-    int status = it->second.GetBlob(data); 
-    if (status != Status::SUCCESS) {
-        ZLOGE("GetBlob failed: %{public}d", status);
-        return Status::ERROR;
+
+    std::vector<uint8_t> uData;
+    if (type == DataShareValueObjectType::TYPE_BLOB) {
+        ZLOGE("Value bucket type blob");
+        std::vector<uint8_t> data = it->second;
+        uData.push_back(KvUtils::BYTE_ARRAY);
+        uData.insert(uData.end(), data.begin(), data.end());
+    } else if (type == DataShareValueObjectType::TYPE_INT) {
+        ZLOGE("Value bucket type int");
+        int64_t data = it->second;
+        uint64_t data64 = htobe64(*reinterpret_cast<uint64_t*>(&data));
+        uint8_t *dataU8 = reinterpret_cast<uint8_t*>(&data64);
+        uData.push_back(KvUtils::INTEGER);
+        uData.insert(uData.end(), dataU8, dataU8 + sizeof(int64_t) / sizeof(uint8_t));
+    } else if (type == DataShareValueObjectType::TYPE_DOUBLE) {
+        ZLOGE("Value bucket type double");
+        double data = it->second;
+        uint64_t data64 = htobe64(*reinterpret_cast<uint64_t*>(&data));
+        uint8_t *dataU8 = reinterpret_cast<uint8_t*>(&data64);
+        uData.push_back(KvUtils::DOUBLE);
+        uData.insert(uData.end(), dataU8, dataU8 + sizeof(double) / sizeof(uint8_t));
+    } else if (type == DataShareValueObjectType::TYPE_BOOL) {
+        ZLOGE("Value bucket type bool");
+        bool data = it->second;
+        uData.push_back(KvUtils::BOOLEAN);
+        uData.push_back(static_cast<uint8_t>(data));
+    } else if (type == DataShareValueObjectType::TYPE_STRING) {
+        ZLOGE("Value bucket type string");
+        std::string data = it->second;
+        uData.push_back(KvUtils::STRING);
+        uData.assign(data.begin(), data.end());
     }
-    kv = data;
+    blob = Blob(uData);
     return Status::SUCCESS;
 }
+
+void KvUtils::InKeys(const OperationItem &oper, DataQuery &query)
+{
+    query.InKeys(oper.para1);
+}
+
+void KvUtils::KeyPrefix(const OperationItem &oper, DataQuery &query)
+{
+    query.KeyPrefix(oper.para1);
+}
+
+void KvUtils::EqualTo(const OperationItem &oper, DataQuery &query)
+{
+    Querys equal(&query, QueryType::EQUAL);
+    CovUtil::FillField(oper.para1, oper.para2.value, equal);
+}
+
+void KvUtils::NotEqualTo(const OperationItem &oper, DataQuery &query)
+{
+    Querys notEqual(&query, QueryType::NOT_EQUAL);
+    CovUtil::FillField(oper.para1, oper.para2.value, notEqual);
+}
+
+void KvUtils::GreaterThan(const OperationItem &oper, DataQuery &query)
+{
+    Querys greater(&query, QueryType::GREATER);
+    CovUtil::FillField(oper.para1, oper.para2.value, greater);
+}
+
+void KvUtils::LessThan(const OperationItem &oper, DataQuery &query)
+{
+    Querys less(&query, QueryType::LESS);
+    CovUtil::FillField(oper.para1, oper.para2.value, less);
+}
+
+void KvUtils::GreaterThanOrEqualTo(const OperationItem &oper, DataQuery &query)
+{
+    Querys greaterOrEqual(&query, QueryType::GREATER_OR_EQUAL);
+    CovUtil::FillField(oper.para1, oper.para2.value, greaterOrEqual);
+}
+
+void KvUtils::LessThanOrEqualTo(const OperationItem &oper, DataQuery &query)
+{
+    Querys lessOrEqual(&query, QueryType::LESS_OR_EQUAL);
+    CovUtil::FillField(oper.para1, oper.para2.value, lessOrEqual);
+}
+
+void KvUtils::And(const OperationItem &oper, DataQuery &query)
+{
+    query.And();
+}
+
+void KvUtils::Or(const OperationItem &oper, DataQuery &query)
+{
+    query.Or();
+}
+
+void KvUtils::IsNull(const OperationItem &oper, DataQuery &query)
+{
+    query.IsNull(oper.para1);
+}
+
+void KvUtils::IsNotNull(const OperationItem &oper, DataQuery &query)
+{
+    query.IsNotNull(oper.para1);
+}
+
+void KvUtils::In(const OperationItem &oper, DataQuery &query)
+{
+    InOrNotIn in(&query, QueryType::IN);
+    CovUtil::FillField(oper.para1, oper.para2.value, in);
+}
+
+void KvUtils::NotIn(const OperationItem &oper, DataQuery &query)
+{
+    InOrNotIn notIn(&query, QueryType::NOT_IN);
+    CovUtil::FillField(oper.para1, oper.para2.value, notIn);
+}
+
+void KvUtils::Like(const OperationItem &oper, DataQuery &query)
+{
+    query.Like(oper.para1, oper.para2);
+}
+
+void KvUtils::Unlike(const OperationItem &oper, DataQuery &query)
+{
+    query.Unlike(oper.para1, oper.para2);
+}
+
+void KvUtils::OrderByAsc(const OperationItem &oper, DataQuery &query)
+{
+    query.OrderByAsc(oper.para1);
+}
+
+void KvUtils::OrderByDesc(const OperationItem &oper, DataQuery &query)
+{
+    query.OrderByDesc(oper.para1);
+}
+
+void KvUtils::Limit(const OperationItem &oper, DataQuery &query)
+{
+    query.Limit(oper.para1, oper.para2);
+}
 } // namespace DistributedKv
 } // namespace OHOS
\ No newline at end of file
diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_bridge.cpp
similarity index 77%
rename from frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp
rename to frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_bridge.cpp
index 0730e00f6b475315f0780688fb6b2dc1f8d80ead..a26471a786083165ea7f60f2ca34cb4ce880af3d 100644
--- a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp
+++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_bridge.cpp
@@ -13,30 +13,31 @@
  * limitations under the License.
  */
 
-#define LOG_TAG "KvStoreDataShareResultSet"
+#define LOG_TAG "KvStoreDataShareBridge"
 
 #include "constant.h"
 #include "log_print.h"
-#include "kvstore_datashare_result_set.h"
+#include "kvstore_datashare_bridge.h"
 
 namespace OHOS {
 namespace DistributedKv {
 using namespace DataShare;
-KvStoreDataShareResultSet::KvStoreDataShareResultSet(std::shared_ptr<KvStoreResultSet> kvResultSet)
+KvStoreDataShareBridge::KvStoreDataShareBridge(std::shared_ptr<KvStoreResultSet> kvResultSet)
     :kvResultSet_(kvResultSet) {};
 
-int KvStoreDataShareResultSet::GetRowCount(int32_t &count)
+int KvStoreDataShareBridge::GetRowCount(int32_t &count)
 {
     count = Count();
     return count == INVALID_COUNT ? E_ERROR : E_OK;
 }
 
-int KvStoreDataShareResultSet::GetAllColumnNames(std::vector<std::string> &columnsName)
+int KvStoreDataShareBridge::GetAllColumnNames(std::vector<std::string> &columnsName)
 {
     columnsName = { "key", "value" };
     return E_OK;
 }
-bool KvStoreDataShareResultSet::FillBlock(int pos, ResultSetBridge::Writer &writer)
+
+bool KvStoreDataShareBridge::FillBlock(int pos, ResultSetBridge::Writer &writer)
 {
     if (kvResultSet_ == nullptr) {
         ZLOGE("kvResultSet_ nullptr");
@@ -58,12 +59,12 @@ bool KvStoreDataShareResultSet::FillBlock(int pos, ResultSetBridge::Writer &writ
         ZLOGE("SharedBlock is full: %{public}d", statusAlloc);
         return false;
     }
-    int keyStatus = writer.Write(0, (uint8_t *)&entry.key.Data(), entry.key.Size());
-    if (keyStatus != E_OK) { 
+    int keyStatus = writer.Write(0, entry.key.ToString().c_str(), entry.key.Size() + 1);
+    if (keyStatus != E_OK) {
         ZLOGE("WriteBlob key error: %{public}d", keyStatus);
         return false;
     }
-    int valueStatus = writer.Write(1, (uint8_t *)&entry.value.Data(), entry.value.Size());
+    int valueStatus = writer.Write(1, entry.value.ToString().c_str(), entry.value.Size() + 1);
     if (valueStatus != E_OK) {
         ZLOGE("WriteBlob value error: %{public}d", valueStatus);
         return false;
@@ -71,7 +72,7 @@ bool KvStoreDataShareResultSet::FillBlock(int pos, ResultSetBridge::Writer &writ
     return true;
 }
 
-int KvStoreDataShareResultSet::Count()
+int KvStoreDataShareBridge::Count()
 {
     if (kvResultSet_ == nullptr) {
         ZLOGE("kvResultSet_ nullptr");
@@ -88,7 +89,7 @@ int KvStoreDataShareResultSet::Count()
     resultRowCount = count;
     return count;
 }
-bool KvStoreDataShareResultSet::OnGo(int32_t start, int32_t target, ResultSetBridge::Writer &writer) 
+bool KvStoreDataShareBridge::OnGo(int32_t start, int32_t target, ResultSetBridge::Writer &writer)
 {
     if ((start < 0) || (target < 0) || (start > target) || (target >= Count())) {
         ZLOGE("nowRowIndex out of line: %{public}d", target);
diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/single_kvstore_client.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/single_kvstore_client.cpp
index ec5d411957b9f85041b954f6a1c3a7a36a0308dd..a716ab272cbaf58eecb24c7506b808a7c0225991 100644
--- a/frameworks/innerkitsimpl/distributeddatafwk/src/single_kvstore_client.cpp
+++ b/frameworks/innerkitsimpl/distributeddatafwk/src/single_kvstore_client.cpp
@@ -96,7 +96,11 @@ Status SingleKvStoreClient::GetResultSet(const Key &prefix, std::shared_ptr<KvSt
         ZLOGE("resultSetTmp is nullptr.");
         return statusTmp;
     }
-    resultSet = std::make_shared<KvStoreResultSetClient>(std::move(resultSetTmp));
+    ZLOGE("GetResultSet~~");
+    resultSet = std::shared_ptr<KvStoreResultSetClient>(new KvStoreResultSetClient(resultSetTmp), [proxy = kvStoreProxy_] (auto result) {
+        ZLOGE("kvstore proxy ResultSet closed.");
+        proxy->CloseResultSet(result->GetKvStoreResultSetProxy());   
+    });
     return statusTmp;
 }
 
@@ -129,7 +133,10 @@ Status SingleKvStoreClient::GetResultSetWithQuery(const std::string &query,
         return statusTmp;
     }
     ZLOGE("GetResultSetWithQuery");
-    resultSet = std::make_shared<KvStoreResultSetClient>(std::move(resultSetTmp));
+    resultSet = std::shared_ptr<KvStoreResultSetClient>(new KvStoreResultSetClient(resultSetTmp), [proxy = kvStoreProxy_] (auto result) {
+        ZLOGE("kvstore proxy ResultSetwithquery closed.");
+        proxy->CloseResultSet(result->GetKvStoreResultSetProxy());   
+    });
     return statusTmp;
 }
 
@@ -152,7 +159,13 @@ Status SingleKvStoreClient::CloseResultSet(std::shared_ptr<KvStoreResultSet> &re
         return Status::SERVER_UNAVAILABLE;
     }
     auto resultSetClient = reinterpret_cast<KvStoreResultSetClient *>(resultSetTmp.get());
-    return kvStoreProxy_->CloseResultSet(resultSetClient->GetKvStoreResultSetProxy());
+    Status status = kvStoreProxy_->CloseResultSet(resultSetClient->GetKvStoreResultSetProxy());
+    if (status != Status::SUCCESS) {
+        ZLOGE("CloseResultSet is not success.");
+        return status;
+    }
+    ZLOGE("CloseResultSet success.");
+    return status;
 }
 
 Status SingleKvStoreClient::GetCountWithQuery(const std::string &query, int &count) const
diff --git a/frameworks/jskitsimpl/distributeddata/include/js_util.h b/frameworks/jskitsimpl/distributeddata/include/js_util.h
index b1b5f3bd9f9c702a88cff81639d0cf1aa346b5c6..892cb72821183da8ca7ff90bb3dab7a1c5635e7c 100644
--- a/frameworks/jskitsimpl/distributeddata/include/js_util.h
+++ b/frameworks/jskitsimpl/distributeddata/include/js_util.h
@@ -17,7 +17,7 @@
 #include <cstdint>
 #include <map>
 #include <variant>
-
+#include "data_query.h"
 #include "change_notification.h"
 #include "napi/native_api.h"
 #include "napi/native_common.h"
@@ -45,6 +45,7 @@ public:
     using Entry = OHOS::DistributedKv::Entry;
     using StoreId = OHOS::DistributedKv::StoreId;
     using Status = OHOS::DistributedKv::Status;
+    using DataQuery = OHOS::DistributedKv::DataQuery;
     /* for kvStore Put/Get : boolean|string|number|Uint8Array */
     using KvStoreVariant = std::variant<std::string, int32_t, float, std::vector<uint8_t>, bool, double>;
     static KvStoreVariant Blob2VariantValue(const Blob& blob);
@@ -139,9 +140,8 @@ public:
     
     static napi_status GetValue(napi_env env, napi_value in, JsSchema*& out);
 
-    static napi_status GetValue(napi_env env, napi_value in, std::vector<DataShare::DataShareValuesBucket> &out);
-    static napi_status GetValue(napi_env env, napi_value in, DataShare::DataShareValuesBucket &out);
-    static napi_status GetValue(napi_env env, napi_value in, DataShare::DataSharePredicates &out);
+    static napi_status GetValue(napi_env env, napi_value in, std::vector<Blob> &out);
+    static napi_status GetValue(napi_env env, napi_value in, DataQuery &out);
 
     /* napi_get_named_property wrapper */
     template <typename T>
diff --git a/frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp b/frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp
index 2edccadd3be698094eb573d2098d441ba4f1455a..d934a2eaf28a27aeceddf4e146d66dc02bcc6b37 100644
--- a/frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp
+++ b/frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp
@@ -122,8 +122,6 @@ enum class ArgsType : uint8_t {
     DEVICEID_KEYPREFIX = 0,
     DEVICEID_QUERY,
     QUERY,
-    PREDICATES,
-    DEVICEID_PREDICATES,
     UNKNOWN = 255
 };
 struct VariantArgs {
@@ -132,7 +130,7 @@ struct VariantArgs {
     std::string keyPrefix;
     JsQuery* query;
     ArgsType type = ArgsType::UNKNOWN;
-    DataSharePredicates predicates;
+    DataQuery dataQuery;
 };
 
 static napi_status GetVariantArgs(napi_env env, size_t argc, napi_value* argv, VariantArgs& va)
@@ -161,8 +159,7 @@ static napi_status GetVariantArgs(napi_env env, size_t argc, napi_value* argv, V
                 CHECK_RETURN(va.query != nullptr, "invalid arg[1], i.e. invalid query!", napi_invalid_arg);
                 va.type = ArgsType::DEVICEID_QUERY;
             } else {
-                status = JSUtil::GetValue(env, argv[1], va.predicates);
-                va.type = ArgsType::DEVICEID_PREDICATES;
+                status = JSUtil::GetValue(env, argv[1], va.dataQuery);
                 ZLOGD("kvStoreDataShare->GetResultSet return %{public}d", status);
                 CHECK_RETURN(true, "invalid arg[0], i.e. invalid predicates!", napi_invalid_arg);
             }
@@ -277,18 +274,10 @@ napi_value JsDeviceKVStore::GetResultSet(napi_env env, napi_callback_info info)
             auto query = ctxt->va.query->GetNative();
             status = kvStore->GetResultSetWithQuery(query.ToString(), kvResultSet);
             ZLOGD("kvStore->GetEntriesWithQuery() return %{public}d", status);
-        }  else if (ctxt->va.type == ArgsType::PREDICATES) {
-            DataQuery query;
-            status = KvUtils::ToQuery(ctxt->va.predicates, query);
-            ZLOGD("ArgsType::PREDICATES ToQuery return %{public}d", status);
-            status = kvStore->GetResultSetWithQuery(query.ToString(), kvResultSet);
-            ZLOGD("ArgsType::PREDICATES GetResultSetWithQuery return %{public}d", status);
-        } else if (ctxt->va.type == ArgsType::DEVICEID_PREDICATES) {
-            DataQuery query;
-            status = KvUtils::ToQuery(ctxt->va.predicates, query);
-            query.DeviceId(ctxt->va.deviceId);
+        } else {
+            ctxt->va.dataQuery.DeviceId(ctxt->va.deviceId);
             ZLOGD("ArgsType::DEVICEID_PREDICATES ToQuery return %{public}d", status);
-            status = kvStore->GetResultSetWithQuery(query.ToString(), kvResultSet);
+            status = kvStore->GetResultSetWithQuery(ctxt->va.dataQuery.ToString(), kvResultSet);
             ZLOGD("ArgsType::DEVICEID_PREDICATES GetResultSetWithQuery return %{public}d", status);
         };
         ctxt->status = (status == Status::SUCCESS) ? napi_ok : napi_generic_failure;
diff --git a/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp b/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp
index 7f5145f70a848353024142d518b1f45c208da8d8..206892f3eb2eb3bf58295b00438eec3f74a04058 100644
--- a/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp
+++ b/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp
@@ -22,8 +22,7 @@
 #include "datashare_predicates.h"
 #include "single_kvstore.h"
 #include "kv_utils.h"
-#include "kvstore_datashare_result_set.h"
-#include "kvstore_predicates.h"
+#include "kvstore_datashare_bridge.h"
 
 using namespace OHOS::DistributedKv;
 using namespace OHOS::DataShare;
@@ -113,49 +112,29 @@ napi_value JsKVStore::Put(napi_env env, napi_callback_info info)
     struct PutContext : public ContextBase {
         std::string key;
         std::vector<uint8_t> value;
-        std::vector<DataShareValuesBucket> valueBuckets;
-        std::vector<Entry> entries;
-        napi_valuetype type;
     };
-
     auto ctxt = std::make_shared<PutContext>();
 
     ctxt->GetCbInfo(env, info, [env, ctxt](size_t argc, napi_value* argv) {
         // required 2 arguments :: <key> <value>
-        CHECK_ARGS_RETURN_VOID(ctxt, (argc == 1 || argc == 2), "invalid arguments!");
-        ctxt->type = napi_undefined;
-        ctxt->status = napi_typeof(env, argv[0], &(ctxt->type));
-        if (ctxt->type == napi_object) {
-            ctxt->status = JSUtil::GetValue(env, argv[0], ctxt->valueBuckets);
-            CHECK_STATUS_RETURN_VOID(ctxt, "invalid arg[0], i.e. invalid valueBuckets!");
-        } else if (ctxt->type == napi_string) {
-            ctxt->status = JSUtil::GetValue(env, argv[0], ctxt->key);
-            CHECK_STATUS_RETURN_VOID(ctxt, "invalid arg[0], i.e. invalid key!");
-            JSUtil::KvStoreVariant vv;
-            ctxt->status = JSUtil::GetValue(env, argv[1], vv);
-            CHECK_STATUS_RETURN_VOID(ctxt, "invalid arg[1], i.e. invalid value!");
-            DistributedKv::Blob blob = JSUtil::VariantValue2Blob(vv);
-            ctxt->value = blob.Data();
-        }
+        CHECK_ARGS_RETURN_VOID(ctxt, argc == 2, "invalid arguments!");
+        ctxt->status = JSUtil::GetValue(env, argv[0], ctxt->key);
+        CHECK_STATUS_RETURN_VOID(ctxt, "invalid arg[0], i.e. invalid key!");
+        JSUtil::KvStoreVariant vv;
+        ctxt->status = JSUtil::GetValue(env, argv[1], vv);
+        CHECK_STATUS_RETURN_VOID(ctxt, "invalid arg[1], i.e. invalid value!");
+        DistributedKv::Blob blob = JSUtil::VariantValue2Blob(vv);
+        ctxt->value = blob.Data();
     });
 
     auto execute = [ctxt]() {
-        if (ctxt->type == napi_string) {
-            OHOS::DistributedKv::Key key(ctxt->key);
-            OHOS::DistributedKv::Value value(ctxt->value);
-            auto& kvStore = reinterpret_cast<JsKVStore*>(ctxt->native)->kvStore_;
-            Status status = kvStore->Put(key, value);
-            ZLOGD("kvStore->Put return %{public}d", status);
-            ctxt->status = (status == Status::SUCCESS) ? napi_ok : napi_generic_failure;
-            CHECK_STATUS_RETURN_VOID(ctxt, "kvStore->Put() failed!");
-        } else if (ctxt->type == napi_object) {
-            auto& kvStore = reinterpret_cast<JsKVStore*>(ctxt->native)->kvStore_;
-            ctxt->entries = KvUtils::ToEntries(ctxt->valueBuckets);
-            ZLOGD("kvStoreDataShare->ToEntry return");
-            Status status = kvStore->PutBatch(ctxt->entries);
-            ctxt->status = (status == Status::SUCCESS) ? napi_ok : napi_generic_failure;
-            CHECK_STATUS_RETURN_VOID(ctxt, "kvStoreDataShare->Put, i.e. Put error!");
-        }
+        OHOS::DistributedKv::Key key(ctxt->key);
+        OHOS::DistributedKv::Value value(ctxt->value);
+        auto& kvStore = reinterpret_cast<JsKVStore*>(ctxt->native)->kvStore_;
+        Status status = kvStore->Put(key, value);
+        ZLOGD("kvStore->Put return %{public}d", status);
+        ctxt->status = (status == Status::SUCCESS) ? napi_ok : napi_generic_failure;
+        CHECK_STATUS_RETURN_VOID(ctxt, "kvStore->Put() failed!");
     };
     return NapiQueue::AsyncWork(env, ctxt, std::string(__FUNCTION__), execute);
 }
@@ -172,7 +151,7 @@ napi_value JsKVStore::Delete(napi_env env, napi_callback_info info)
     ZLOGD("KVStore::Delete()");
     struct DeleteContext : public ContextBase {
         std::string key;
-        DataSharePredicates predicates;
+        std::vector<DistributedKv::Blob> keys;
         napi_valuetype type;
     };
     auto ctxt = std::make_shared<DeleteContext>();
@@ -187,7 +166,7 @@ napi_value JsKVStore::Delete(napi_env env, napi_callback_info info)
             ZLOGD("kvStore->Put return %{public}d", ctxt->status);
             CHECK_STATUS_RETURN_VOID(ctxt, "invalid arg[0], i.e. invalid key!");
         } else if (ctxt->type == napi_object) {
-            ctxt->status = JSUtil::GetValue(env, argv[0], ctxt->predicates);
+            ctxt->status = JSUtil::GetValue(env, argv[0], ctxt->keys);
             ZLOGD("kvStoreDataShare->Delete return %{public}d", ctxt->status);
             CHECK_STATUS_RETURN_VOID(ctxt, "invalid arg[0], i.e. invalid predicates!");
         }
@@ -202,14 +181,8 @@ napi_value JsKVStore::Delete(napi_env env, napi_callback_info info)
             ctxt->status = (status == Status::SUCCESS) ? napi_ok : napi_generic_failure;
             CHECK_STATUS_RETURN_VOID(ctxt, "kvStore->Delete() failed!");
         } else if (ctxt->type == napi_object) {
-            std::vector<Key> keys;
-            auto kvPredicates = std::make_shared<KvStorePredicates>();
-            Status status = kvPredicates->GetKeys(ctxt->predicates, keys);
-            ctxt->status = (status == Status::SUCCESS) ? napi_ok : napi_generic_failure;
-            CHECK_STATUS_RETURN_VOID(ctxt, "kvStore GetKeys failed!");
-            ZLOGD("GetKeys return %{public}d", status);
             auto& kvStore = reinterpret_cast<JsKVStore*>(ctxt->native)->kvStore_;
-            status = kvStore->DeleteBatch(keys);
+            Status status = kvStore->DeleteBatch(ctxt->keys);
             ZLOGD("kv Datashare Delete return %{public}d", status);
         }
     });
diff --git a/frameworks/jskitsimpl/distributeddata/src/js_kv_store_resultset.cpp b/frameworks/jskitsimpl/distributeddata/src/js_kv_store_resultset.cpp
index 994a3b76d2b94c8926ce1913c5441b42011efbaf..361144575c220c10278fd88dd2f269030c7b76aa 100644
--- a/frameworks/jskitsimpl/distributeddata/src/js_kv_store_resultset.cpp
+++ b/frameworks/jskitsimpl/distributeddata/src/js_kv_store_resultset.cpp
@@ -18,7 +18,7 @@
 #include "log_print.h"
 #include "napi_queue.h"
 #include "uv_queue.h"
-#include "kvstore_datashare_result_set.h"
+#include "kvstore_datashare_bridge.h"
 #include "kv_utils.h"
 
 using namespace OHOS::DistributedKv;
diff --git a/frameworks/jskitsimpl/distributeddata/src/js_single_kv_store.cpp b/frameworks/jskitsimpl/distributeddata/src/js_single_kv_store.cpp
index dbb7e38d460b550dfad016817b4ca4762748a393..813ebbeaa9adeeac5ffccecc9b63928ff4fcd41f 100644
--- a/frameworks/jskitsimpl/distributeddata/src/js_single_kv_store.cpp
+++ b/frameworks/jskitsimpl/distributeddata/src/js_single_kv_store.cpp
@@ -106,7 +106,6 @@ enum class ArgsType : uint8_t {
     /* input arguments' combination type */
     KEYPREFIX = 0,
     QUERY,
-    PREDICATES,
     UNKNOWN = 255
 };
 struct VariantArgs {
@@ -114,7 +113,7 @@ struct VariantArgs {
     std::string keyPrefix;
     JsQuery* query;
     ArgsType type = ArgsType::UNKNOWN;
-    DataSharePredicates predicates;
+    DataQuery dataQuery;
 };
 
 static napi_status GetVariantArgs(napi_env env, size_t argc, napi_value* argv, VariantArgs& va)
@@ -136,8 +135,7 @@ static napi_status GetVariantArgs(napi_env env, size_t argc, napi_value* argv, V
             CHECK_RETURN(va.query != nullptr, "invalid arg[0], i.e. invalid query!", napi_invalid_arg);
             va.type = ArgsType::QUERY;
         } else {
-            status = JSUtil::GetValue(env, argv[0], va.predicates);
-            va.type = ArgsType::PREDICATES;
+            status = JSUtil::GetValue(env, argv[0], va.dataQuery);
             ZLOGD("kvStoreDataShare->GetResultSet return %{public}d", status);
         }
     }
@@ -231,13 +229,8 @@ napi_value JsSingleKVStore::GetResultSet(napi_env env, napi_callback_info info)
             auto query = ctxt->va.query->GetNative();
             status = kvStore->GetResultSetWithQuery(query.ToString(), kvResultSet);
             ZLOGD("kvStore->GetEntriesWithQuery() return %{public}d", status);
-        } else if (ctxt->va.type == ArgsType::PREDICATES) {
-            DataQuery query;
-            status = KvUtils::ToQuery(ctxt->va.predicates, query);
-            ctxt->status = (status == Status::SUCCESS) ? napi_ok : napi_generic_failure;
-            CHECK_STATUS_RETURN_VOID(ctxt, "predicate ToQuery failed!");
-            ZLOGD("ArgsType::PREDICATES ToQuery return %{public}d", status);
-            status = kvStore->GetResultSetWithQuery(query.ToString(), kvResultSet);
+        } else {
+            status = kvStore->GetResultSetWithQuery(ctxt->va.dataQuery.ToString(), kvResultSet);
             ZLOGD("ArgsType::PREDICATES GetResultSetWithQuery return %{public}d", status);
         };
         ctxt->status = (status == Status::SUCCESS) ? napi_ok : napi_generic_failure;
diff --git a/frameworks/jskitsimpl/distributeddata/src/js_util.cpp b/frameworks/jskitsimpl/distributeddata/src/js_util.cpp
index 0c7a975b7b66ec2f135b855bc87b6ec91ef66d9a..e7356c1eada8e188d4bf479e3eaca69f9d962e7e 100644
--- a/frameworks/jskitsimpl/distributeddata/src/js_util.cpp
+++ b/frameworks/jskitsimpl/distributeddata/src/js_util.cpp
@@ -21,6 +21,8 @@
 #include "js_schema.h"
 #include "log_print.h"
 #include "napi_queue.h"
+#include "kv_utils.h"
+#include "types.h"
 
 using namespace OHOS::DistributedKv;
 using namespace OHOS::DataShare;
@@ -775,9 +777,15 @@ napi_status JSUtil::GetValue(napi_env env, napi_value in, std::vector<Distribute
         }
         DistributedKv::Entry entry;
         status = GetValue(env, item, entry);
+        if (status != napi_ok) {
+            ZLOGD("maybe valubucket type");
+            DataShareValuesBucket valueBucket;
+            GetValueBucketObject(valueBucket, env, item);
+            entry = KvUtils::ToEntry(valueBucket);
+        }
         out.push_back(entry);
     }
-    return status;
+    return napi_ok;
 }
 
 napi_status JSUtil::SetValue(napi_env env, const std::vector<DistributedKv::Entry>& in, napi_value& out)
@@ -1001,48 +1009,39 @@ bool JSUtil::Equals(napi_env env, napi_value value, napi_ref copy)
     return isEquals;
 }
 
-napi_status JSUtil::GetValue(napi_env env, napi_value in, DataSharePredicates &out)
+napi_status JSUtil::GetValue(napi_env env, napi_value in, std::vector<Blob> &out)
 {
-    ZLOGD("napi_value -> std::GetValue predicate");
+    ZLOGD("napi_value -> std::GetValue Blob");
+    out.clear();
     napi_valuetype type = napi_undefined;
-    napi_status status = napi_typeof(env, in, &type);
-    CHECK_RETURN((status == napi_ok) && (type == napi_object), "invalid type", napi_invalid_arg);
+    napi_status nstatus = napi_typeof(env, in, &type);
+    CHECK_RETURN((nstatus == napi_ok) && (type == napi_object), "invalid type", napi_invalid_arg);
     DataSharePredicates *predicates = GetNativePredicatesObject(env, in);
     CHECK_RETURN((predicates != nullptr), "invalid type", napi_invalid_arg);
-    out = *predicates;
-    return status;
-}
-
-napi_status JSUtil::GetValue(napi_env env, napi_value in, std::vector<DataShareValuesBucket>& out)
-{
-    ZLOGD("napi_value -> std::vector<DataShareValuesBucket>");
-    out.clear();
-    bool isArray = false;
-    napi_is_array(env, in, &isArray);
-    CHECK_RETURN(isArray, "not an array", napi_invalid_arg);
-
-    uint32_t length = 0;
-    napi_status status = napi_get_array_length(env, in, &length);
-    CHECK_RETURN((status == napi_ok) && (length > 0), "get_array failed!", napi_invalid_arg);
-    for (uint32_t i = 0; i < length; ++i) {
-        ZLOGD("length is %{public}d: ", length);
-        napi_value item = nullptr;
-        status = napi_get_element(env, in, i, &item);
-        CHECK_RETURN((status == napi_ok), "no element", napi_invalid_arg);
-        DataShareValuesBucket valueBucket;
-        status = GetValue(env, item, valueBucket);
-        CHECK_RETURN(status == napi_ok, "not a string", napi_invalid_arg);
-        out.push_back(valueBucket);
+    std::vector<Key> keys;
+    nstatus = napi_invalid_arg;
+    Status status = KvUtils::GetKeys(*predicates, keys);
+    if (status == Status::SUCCESS) {
+        ZLOGD("napi_value �> GetValue Blob ok");
+        out = keys;
+        nstatus = napi_ok;
     }
-    return status;
+    return nstatus;
 }
 
-napi_status JSUtil::GetValue(napi_env env, napi_value in, DataShareValuesBucket &out)
+napi_status JSUtil::GetValue(napi_env env, napi_value in, DataQuery &query)
 {
+    ZLOGD("napi_value -> std::GetValue DataQuery");
     napi_valuetype type = napi_undefined;
-    napi_status status = napi_typeof(env, in, &type);
-    CHECK_RETURN((status == napi_ok) && (type == napi_object), "invalid type", napi_invalid_arg);
-    GetValueBucketObject(out, env, in);
-    return status;
+    napi_status nstatus = napi_typeof(env, in, &type);
+    CHECK_RETURN((nstatus == napi_ok) && (type == napi_object), "invalid type", napi_invalid_arg);
+    DataSharePredicates *predicates = GetNativePredicatesObject(env, in);
+    CHECK_RETURN((predicates != nullptr), "invalid type", napi_invalid_arg);
+    std::vector<Key> keys;
+    Status status = KvUtils::ToQuery(*predicates, query);
+    if (status != Status::SUCCESS) {
+        ZLOGD("napi_value -> GetValue DataQuery failed ");
+    }
+    return nstatus;
 }
 } // namespace OHOS::DistributedData
diff --git a/interfaces/innerkits/distributeddata/BUILD.gn b/interfaces/innerkits/distributeddata/BUILD.gn
index 100b1fa45abe37ae104da2afcfa83e5c9d425ecb..359cb0c91a7c29e52ebbb277166ef0e8e34d122f 100644
--- a/interfaces/innerkits/distributeddata/BUILD.gn
+++ b/interfaces/innerkits/distributeddata/BUILD.gn
@@ -64,19 +64,18 @@ ohos_shared_library("distributeddata_inner") {
     "../../../frameworks/innerkitsimpl/distributeddatafwk/src/ikvstore_snapshot.cpp",
     "../../../frameworks/innerkitsimpl/distributeddatafwk/src/ikvstore_sync_callback.cpp",
     "../../../frameworks/innerkitsimpl/distributeddatafwk/src/itypes_util.cpp",
+    "../../../frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp",
     "../../../frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_client.cpp",
     "../../../frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_client_death_observer.cpp",
-    "../../../frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp",
+    "../../../frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_bridge.cpp",
     "../../../frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_death_recipient_impl.cpp",
     "../../../frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_observer_client.cpp",
-    "../../../frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp",
     "../../../frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_resultset_client.cpp",
     "../../../frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_service_death_notifier.cpp",
     "../../../frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_snapshot_client.cpp",
     "../../../frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_sync_callback_client.cpp",
     "../../../frameworks/innerkitsimpl/distributeddatafwk/src/single_kvstore_client.cpp",
     "../../../frameworks/innerkitsimpl/distributeddatafwk/src/sync_observer.cpp",
-    "../../../frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp",
     "include/types.h",
   ]
 
diff --git a/interfaces/innerkits/distributeddata/include/kv_utils.h b/interfaces/innerkits/distributeddata/include/kv_utils.h
index d47cff7466107e213f69a422136b9b483b31da3e..fd7912cda0827c72a2953a3d48adbeaad53f74fd 100644
--- a/interfaces/innerkits/distributeddata/include/kv_utils.h
+++ b/interfaces/innerkits/distributeddata/include/kv_utils.h
@@ -22,25 +22,77 @@
 #include "datashare_values_bucket.h"
 #include "kvstore_result_set.h"
 #include "result_set_bridge.h"
-#include "single_kvstore.h"
 
 namespace OHOS {
 namespace DistributedKv {
 class KvUtils {
 public:
+    enum {
+        STRING = 0,
+        INTEGER = 1,
+        FLOAT = 2,
+        BYTE_ARRAY = 3,
+        BOOLEAN = 4,
+        DOUBLE = 5,
+        INVALID = 255
+    };
     static std::shared_ptr<DataShare::ResultSetBridge> ToResultSetBridge(std::shared_ptr<KvStoreResultSet> resultSet);
     static Status ToQuery(const DataShare::DataSharePredicates &predicates, DataQuery &query);
     static Entry ToEntry(const DataShare::DataShareValuesBucket &valueBucket);
-    static std::vector<Entry> ToEntries(const std::vector<DataShare::DataShareValuesBucket> &Buckets);
+    static std::vector<Entry> ToEntries(const std::vector<DataShare::DataShareValuesBucket> &valueBuckets);
+    static Status GetKeys(const DataShare::DataSharePredicates &predicates, std::vector<Key> &keys);
 private:
+    static void EqualTo(const DataShare::OperationItem &oper, DataQuery &query);
+    static void NotEqualTo(const DataShare::OperationItem &oper, DataQuery &query);
+    static void GreaterThan(const DataShare::OperationItem &oper, DataQuery &query);
+    static void LessThan(const DataShare::OperationItem &oper, DataQuery &query);
+    static void GreaterThanOrEqualTo(const DataShare::OperationItem &oper, DataQuery &query);
+    static void LessThanOrEqualTo(const DataShare::OperationItem &oper, DataQuery &query);
+    static void And(const DataShare::OperationItem &oper, DataQuery &query);
+    static void Or(const DataShare::OperationItem &oper, DataQuery &query);
+    static void IsNull(const DataShare::OperationItem &oper, DataQuery &query);
+    static void IsNotNull(const DataShare::OperationItem &oper, DataQuery &query);
+    static void In(const DataShare::OperationItem &oper, DataQuery &query);
+    static void NotIn(const DataShare::OperationItem &oper, DataQuery &query);
+    static void Like(const DataShare::OperationItem &oper, DataQuery &query);
+    static void Unlike(const DataShare::OperationItem &oper, DataQuery &query);
+    static void OrderByAsc(const DataShare::OperationItem &oper, DataQuery &query);
+    static void OrderByDesc(const DataShare::OperationItem &oper, DataQuery &query);
+    static void Limit(const DataShare::OperationItem &oper, DataQuery &query);
+    static void InKeys(const DataShare::OperationItem &oper, DataQuery &query);
+    static void KeyPrefix(const DataShare::OperationItem &oper, DataQuery &query);
+
     KvUtils(KvUtils &&) = delete;
     KvUtils(const KvUtils &) = delete;
     KvUtils &operator=(KvUtils &&) = delete;
     KvUtils &operator=(const KvUtils &) = delete;
     ~KvUtils() = delete;
-    static Status ToEntryData(const std::map<std::string, DataShare::DataShareValueObject> &valuesMap, const std::string field, Blob &kv);
+    static Status ToEntryData(const std::map<std::string,
+        DataShare::DataShareValueObject> &valuesMap, const std::string field, Blob &blob);
     static const std::string KEY;
     static const std::string VALUE;
+    using QueryHandler = void (*)(const DataShare::OperationItem &, DataQuery &);
+    static constexpr QueryHandler HANDLERS[DataShare::LAST_TYPE] = {
+        [DataShare::EQUAL_TO] = &KvUtils::EqualTo,
+        [DataShare::NOT_EQUAL_TO] = &KvUtils::NotEqualTo,
+        [DataShare::GREATER_THAN] = &KvUtils::GreaterThan,
+        [DataShare::LESS_THAN] = &KvUtils::LessThan,
+        [DataShare::GREATER_THAN_OR_EQUAL_TO] = &KvUtils::GreaterThanOrEqualTo,
+        [DataShare::LESS_THAN_OR_EQUAL_TO] = &KvUtils::LessThanOrEqualTo,
+        [DataShare::AND] = &KvUtils::And,
+        [DataShare::OR] = &KvUtils::Or,
+        [DataShare::IS_NULL] = &KvUtils::IsNull,
+        [DataShare::IS_NOT_NULL] = &KvUtils::IsNotNull,
+        [DataShare::NOT_IN] = &KvUtils::NotIn,
+        [DataShare::LIKE] = &KvUtils::Like,
+        [DataShare::UNLIKE] = &KvUtils::Unlike,
+        [DataShare::ORDER_BY_ASC] = &KvUtils::OrderByAsc,
+        [DataShare::ORDER_BY_DESC] = &KvUtils::OrderByDesc,
+        [DataShare::LIMIT] = &KvUtils::Limit,
+        [DataShare::IN_KEY] = &KvUtils::InKeys,
+        [DataShare::KEY_PREFIX] = &KvUtils::KeyPrefix,
+        [DataShare::IN] = &KvUtils::In,
+        };
 };
 } // namespace DistributedKv
 } // namespace OHOS
diff --git a/interfaces/jskits/distributeddata/BUILD.gn b/interfaces/jskits/distributeddata/BUILD.gn
index 112adf87a82d86a4a8945e64a26bf74f66e11986..326342c91edb78868bb039ebbcef17bd7bf97012 100644
--- a/interfaces/jskits/distributeddata/BUILD.gn
+++ b/interfaces/jskits/distributeddata/BUILD.gn
@@ -51,6 +51,7 @@ ohos_shared_library("distributeddata") {
   ]
 
   sources = [
+    "../../../frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp",
     "../../../frameworks/jskitsimpl/distributeddata/src/entry_point.cpp",
     "../../../frameworks/jskitsimpl/distributeddata/src/js_const_properties.cpp",
     "../../../frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp",
@@ -65,7 +66,6 @@ ohos_shared_library("distributeddata") {
     "../../../frameworks/jskitsimpl/distributeddata/src/js_util.cpp",
     "../../../frameworks/jskitsimpl/distributeddata/src/napi_queue.cpp",
     "../../../frameworks/jskitsimpl/distributeddata/src/uv_queue.cpp",
-    "../../../frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp",
   ]
 
   deps = [