From f55344db4549747c29aef7a20695570e5d86ae35 Mon Sep 17 00:00:00 2001 From: dy_study Date: Mon, 16 May 2022 13:59:21 +0800 Subject: [PATCH 01/20] =?UTF-8?q?IssueNo:#I57IWN=20Description:ability=5Fb?= =?UTF-8?q?ase=E7=9B=AE=E5=BD=95=E6=95=B4=E6=94=B9=E5=8F=8A=E5=91=A8?= =?UTF-8?q?=E8=BE=B9=E5=AD=90=E7=B3=BB=E7=BB=9F=E4=BE=9D=E8=B5=96=E6=A0=87?= =?UTF-8?q?=E5=87=86=E5=8C=96=20Sig:SIG=5FApplicationFramework=20Feature?= =?UTF-8?q?=20or=20Bugfix:Feature=20Binary=20Source:=20No?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: dy_study Change-Id: I5d4d9e5d3544e6fa6e684bcd0284d9b042344f37 Signed-off-by: anan --- services/distributeddataservice/adapter/broadcaster/BUILD.gn | 1 + .../adapter/broadcaster/src/broadcast_sender_impl.cpp | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/services/distributeddataservice/adapter/broadcaster/BUILD.gn b/services/distributeddataservice/adapter/broadcaster/BUILD.gn index b72dc92a1..7a1ba02d6 100755 --- a/services/distributeddataservice/adapter/broadcaster/BUILD.gn +++ b/services/distributeddataservice/adapter/broadcaster/BUILD.gn @@ -33,6 +33,7 @@ ohos_static_library("distributeddata_broadcaster_static") { external_deps = [ # "ces:libcommonevent", + "ability_base:base", "ability_base:want", "bundle_framework:appexecfwk_base", "common_event_service:cesfwk_innerkits", diff --git a/services/distributeddataservice/adapter/broadcaster/src/broadcast_sender_impl.cpp b/services/distributeddataservice/adapter/broadcaster/src/broadcast_sender_impl.cpp index 4c65a2346..8dd3d8450 100644 --- a/services/distributeddataservice/adapter/broadcaster/src/broadcast_sender_impl.cpp +++ b/services/distributeddataservice/adapter/broadcaster/src/broadcast_sender_impl.cpp @@ -19,7 +19,7 @@ #include "common_event_manager.h" #include "common_event_support.h" #include "log_print.h" -#include "ohos/aafwk/base/string_wrapper.h" +#include "string_wrapper.h" namespace OHOS::DistributedKv { using namespace OHOS::EventFwk; -- Gitee From 767db5b8637c466c938ecc2a612f0393ef2fef7b Mon Sep 17 00:00:00 2001 From: anan <1113275404@qq.com> Date: Tue, 17 May 2022 20:21:02 +0800 Subject: [PATCH 02/20] =?UTF-8?q?datashare=E9=80=82=E9=85=8D=20Signed-off-?= =?UTF-8?q?by:=20anan=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: anan --- .../distributeddatafwk/include/kv_utils.h | 44 ++ .../include/kvstore_datashare_result_set.h | 54 ++ .../include/kvstore_predicates.h | 91 +++ .../include/kvstore_values_bucket.h | 39 ++ .../distributeddatafwk/src/kv_utils.cpp | 96 ++++ .../src/kvstore_datashare_result_set.cpp | 113 ++++ .../src/kvstore_predicates.cpp | 528 ++++++++++++++++++ .../src/kvstore_values_bucket.cpp | 79 +++ .../include/js_kv_store_resultset.h | 5 +- .../distributeddata/include/js_util.h | 6 + .../src/js_device_kv_store.cpp | 15 +- .../distributeddata/src/js_kv_store.cpp | 86 ++- .../src/js_kv_store_resultset.cpp | 10 +- .../src/js_single_kv_store.cpp | 30 +- .../distributeddata/src/js_util.cpp | 50 +- interfaces/innerkits/distributeddata/BUILD.gn | 8 + interfaces/jskits/distributeddata/BUILD.gn | 6 + 17 files changed, 1228 insertions(+), 32 deletions(-) create mode 100644 frameworks/innerkitsimpl/distributeddatafwk/include/kv_utils.h create mode 100644 frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_datashare_result_set.h create mode 100644 frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_predicates.h create mode 100644 frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_values_bucket.h create mode 100644 frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp create mode 100644 frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp create mode 100644 frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp create mode 100644 frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_values_bucket.cpp diff --git a/frameworks/innerkitsimpl/distributeddatafwk/include/kv_utils.h b/frameworks/innerkitsimpl/distributeddatafwk/include/kv_utils.h new file mode 100644 index 000000000..ee492a50e --- /dev/null +++ b/frameworks/innerkitsimpl/distributeddatafwk/include/kv_utils.h @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef KV_UTILS_H +#define KV_UTILS_H + +#include "types.h" +#include "datashare_predicates.h" +#include "data_query.h" +#include "datashare_values_bucket.h" +#include "kvstore_result_set.h" +#include "result_set_bridge.h" + +namespace OHOS { +namespace DistributedKv { +class KvUtils { +public: + static std::shared_ptr ToResultSetBridge(const std::shared_ptr resultSet); + static Status ToQuery(const DataShare::DataSharePredicates &predicates, DataQuery &query); + static Entry ToEntry(const DataShare::DataShareValuesBucket &valueBucket); + static std::vector ToEntry(const std::vector &valueBuckets); + static Status GetKeys(const DataShare::DataSharePredicates &predicates, std::vector &keys); +private: + KvUtils(KvUtils &&) = delete; + KvUtils(const KvUtils &) = delete; + KvUtils &operator=(KvUtils &&) = delete; + KvUtils &operator=(const KvUtils &) = delete; + ~KvUtils() = delete; +}; +} // namespace DistributedKv +} // namespace OHOS +#endif // KV_UTILS_H \ No newline at end of file diff --git a/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_datashare_result_set.h b/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_datashare_result_set.h new file mode 100644 index 000000000..cc3dbf4e1 --- /dev/null +++ b/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_datashare_result_set.h @@ -0,0 +1,54 @@ +/* + * 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_DATASHARE_RESULT_SET_H +#define KVSTORE_DATASHARE_RESULT_SET_H + +#include "kvstore_result_set.h" +#include "single_kvstore.h" +#include "result_set_bridge.h" +#include "datashare_errno.h" + +namespace OHOS { +namespace DistributedKv { +class KvStoreDataShareResultSet : public DataShare::ResultSetBridge { +public: + KvStoreDataShareResultSet(std::shared_ptr kvResultSet); + + ~KvStoreDataShareResultSet() = default; + + int GetRowCount(int32_t &count) override; + + int GetAllColumnsName(std::vector &columnsName) override; + + // bool OnGo(int oldRowIndex, int newRowIndex, const std::shared_ptr &writer) override; + bool OnGo(int32_t start, int32_t length, DataShare::ResultSetBridge::Writer &writer) override; + +private: + int Count(); + + // bool FillBlock(int startRowIndex, const std::shared_ptr &writer); + + bool FillBlock(int startRowIndex, DataShare::ResultSetBridge::Writer &writer); + + static constexpr int32_t INVALID_COUNT = -1; + + int32_t resultRowCount {INVALID_COUNT}; + + std::shared_ptr kvResultSet_; +}; +} // namespace DistributedKv +} // namespace OHOS +#endif // KVSTORE_DATASHARE_RESULT_SET_H diff --git a/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_predicates.h b/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_predicates.h new file mode 100644 index 000000000..12c0739d0 --- /dev/null +++ b/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_predicates.h @@ -0,0 +1,91 @@ +/* + * 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 +#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 intList; + std::vector longList; + std::vector doubleList; + std::vector stringList; + DataShare::DataSharePredicatesObjectType innerType; + }; + KvStorePredicates() = default; + ~KvStorePredicates() = default; + Status ToQuery(const DataShare::DataSharePredicates &predicates, DataQuery &query); + +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 OHOS +#endif // KVSTORE_PREDICATE_H \ No newline at end of file diff --git a/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_values_bucket.h b/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_values_bucket.h new file mode 100644 index 000000000..4fc354291 --- /dev/null +++ b/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_values_bucket.h @@ -0,0 +1,39 @@ +/* + * 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_VALUES_BUCKET_H +#define KVSTORE_VALUES_BUCKET_H + +#include "types.h" +#include "datashare_values_bucket.h" + +namespace OHOS { +namespace DistributedKv { +class KvStoreValuesBucket { +public: + KvStoreValuesBucket() = default; + ~KvStoreValuesBucket() = default; + + std::vector ToEntry(const std::vector &valueBuckets); + Entry ToEntry(const DataShare::DataShareValuesBucket &valueBucket); + +private: + Status ToEntryData(const std::map &valuesMap, const std::string field, Blob &kv); + const std::string KEY = "key"; + const std::string VALUE = "value"; +}; +} // namespace DistributedKv +} // namespace OHOS +#endif // KVSTORE_VALUES_BUCKET_H \ No newline at end of file diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp new file mode 100644 index 000000000..f8f4dd3af --- /dev/null +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp @@ -0,0 +1,96 @@ +/* + * 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. + */ + +#define LOG_TAG "KvUtils" + +#include "kv_utils.h" +#include "kvstore_datashare_result_set.h" +#include "kvstore_predicates.h" +#include "log_print.h" +#include "data_query.h" +#include "kvstore_values_bucket.h" + +namespace OHOS { +namespace DistributedKv { +using namespace DataShare; +std::shared_ptr KvUtils::ToResultSetBridge( + const std::shared_ptr resultSet) +{ + if (resultSet == nullptr) { + ZLOGE("param error, kvResultSet nullptr"); + return nullptr; + } + return std::make_shared(resultSet); +} + +Status KvUtils::ToQuery(const DataSharePredicates &predicates, DataQuery &query) +{ + auto kvPredicates = std::make_shared(); + Status status = kvPredicates->ToQuery(predicates, query); + if (status != Status::SUCCESS) { + ZLOGE("ToQuery failed: %{public}d", status); + return status; + } + return status; +} + +std::vector KvUtils::ToEntry(const std::vector &valueBuckets) +{ + auto KvValuesBucket = std::make_shared(); + std::vector entries = KvValuesBucket->ToEntry(valueBuckets); + if (entries.empty()) { + ZLOGE("ToEntry entries failed"); + return {}; + } + return entries; +} + +Entry KvUtils::ToEntry(const DataShareValuesBucket &valueBucket) +{ + auto KvValuesBucket = std::make_shared(); + return KvValuesBucket->ToEntry(valueBucket); +} + +Status KvUtils::GetKeys(const DataSharePredicates &predicates, std::vector &keys) +{ + std::list operationList = predicates.GetOperationList(); + if (operationList.empty()) { + ZLOGE("operationList is null"); + return Status::ERROR; + } + + std::vector myKeys; + for(const auto &oper : operationList) + { + if (oper.operation != IN_KEY) { + ZLOGE("find operation failed"); + return Status::NOT_SUPPORT; + } + std::vector val; + int status = oper.para1.GetStringVector(val); + if (status != E_OK) { + ZLOGE("GetStringVector failed: %{public}d", status); + return Status::ERROR; + } + myKeys.insert(myKeys.end(), val.begin(), val.end()); + } + for (const auto &it : myKeys) + { + keys.push_back(it.c_str()); + } + return Status::SUCCESS; +} +} // 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_result_set.cpp new file mode 100644 index 000000000..88e98f0f7 --- /dev/null +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp @@ -0,0 +1,113 @@ +/* + * 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. + */ + +#define LOG_TAG "KvStoreDataShareResultSet" + +#include "constant.h" +#include "log_print.h" +#include "kvstore_datashare_result_set.h" + +namespace OHOS { +namespace DistributedKv { +using namespace DataShare; +KvStoreDataShareResultSet::KvStoreDataShareResultSet(std::shared_ptr kvResultSet) + :kvResultSet_(kvResultSet) {}; + +int KvStoreDataShareResultSet::GetRowCount(int32_t &count) +{ + count = Count(); + return count == INVALID_COUNT ? E_ERROR : E_OK; +} + +int KvStoreDataShareResultSet::GetAllColumnsName(std::vector &columnsName) +{ + columnsName = { "key", "value" }; + return E_OK; +} +// bool KvStoreDataShareResultSet::FillBlock(int pos, DataShareBlockWriter &writer) +bool KvStoreDataShareResultSet::FillBlock(int pos, ResultSetBridge::Writer &writer) +{ + if (kvResultSet_ == nullptr) { + ZLOGE("kvResultSet_ nullptr"); + return false; + } + bool isMoved = kvResultSet_->MoveToPosition(pos); + if (!isMoved) { + ZLOGE("MoveToPosition failed"); + return false; + } + Entry entry; + Status status = kvResultSet_->GetEntry(entry); + if (status != Status::SUCCESS) { + ZLOGE("GetEntry failed %{public}d", status); + return false; + } + int statusAlloc = writer.AllocRow(); + if (statusAlloc != E_OK) { + ZLOGE("SharedBlock is full: %{public}d", statusAlloc); + return false; + } + // int keyStatus = writer.Write(0, &entry.key.Data(), entry.key.Size()); //需打开屏蔽 + // if (keyStatus != E_OK) { + // ZLOGE("WriteBlob key error: %{public}d", keyStatus); + // return false; + // } + // int valueStatus = writer.Write(1, &entry.value.Data(), entry.value.Size());//需打开屏蔽 + // if (valueStatus != E_OK) { + // ZLOGE("WriteBlob value error: %{public}d", valueStatus); + // return false; + // } + return true; +} + +int KvStoreDataShareResultSet::Count() +{ + if (kvResultSet_ == nullptr) { + ZLOGE("kvResultSet_ nullptr"); + return INVALID_COUNT; + } + if (resultRowCount != INVALID_COUNT) { + return resultRowCount; + } + int count = kvResultSet_->GetCount(); + if (count < 0) { + ZLOGE("kvResultSet count invalid: %{public}d", count); + return INVALID_COUNT; + } + resultRowCount = count; + return count; +} +bool KvStoreDataShareResultSet::OnGo(int32_t start, int32_t length, ResultSetBridge::Writer &writer) +{ + if ((start < 0) || (length < 0) || (start > length) || (length >= Count())) { + ZLOGE("nowRowIndex out of line: %{public}d", length); + return false; + } + // int statusColumn = writer.SetColumnNum(2); + // if (statusColumn != E_OK) { + // ZLOGE("SetColumnNum faild: %{public}d", statusColumn); + // return false; + // } + for (int pos = start; pos <= length; pos++) { + bool ret = FillBlock(pos, writer); + if (!ret) { + ZLOGE("nowRowIndex out of line: %{public}d", length); + return ret; + } + } + return true; +} +} // namespace DistributedKv +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp new file mode 100644 index 000000000..1a92f7a4d --- /dev/null +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp @@ -0,0 +1,528 @@ +/* + * 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. + */ + +#define LOG_TAG "KvStorePredicates" + +#include "kvstore_predicates.h" +#include "log_print.h" +#include "datashare_errno.h" + +namespace OHOS { +namespace DistributedKv { +using namespace DataShare; +constexpr KvStorePredicates::QueryHandler KvStorePredicates::HANDLERS[LAST_TYPE]; + +Status KvStorePredicates::GetContext(const OperationItem &oper, Context &context) +{ + int status = oper.para1.GetString(context.field); + if (status != E_OK) { + ZLOGE("Get context.field failed: %{public}d", status); + return Status::ERROR; + } + + auto innerType = oper.para2.GetType(); + switch (innerType) { + case DataSharePredicatesObjectType::TYPE_INT: { + status = oper.para2.GetInt(context.intValue); + break; + } + case DataSharePredicatesObjectType::TYPE_LONG: { + status = oper.para2.GetLong(context.longValue); + break; + } + case DataSharePredicatesObjectType::TYPE_DOUBLE: { + status = oper.para2.GetDouble(context.doubleValue); + break; + } + case DataSharePredicatesObjectType::TYPE_BOOL: { + status = oper.para2.GetBool(context.boolValue); + break; + } + case DataSharePredicatesObjectType::TYPE_STRING: { + status = oper.para2.GetString(context.stringValue); + break; + } + case DataSharePredicatesObjectType::TYPE_INT_VECTOR: { + status = oper.para2.GetIntVector(context.intList); + break; + } + case DataSharePredicatesObjectType::TYPE_LONG_VECTOR: { + status = oper.para2.GetLongVector(context.longList); + break; + } + case DataSharePredicatesObjectType::TYPE_DOUBLE_VECTOR: { + status = oper.para2.GetDoubleVector(context.doubleList); + break; + } + case DataSharePredicatesObjectType::TYPE_STRING_VECTOR: { + status = oper.para2.GetStringVector(context.stringList); + break; + } + default: + status = Status::ERROR; + break; + } + + if(status != Status::SUCCESS) { + ZLOGE("GetType failed: %{public}d", status); + return Status::ERROR; + } + return Status::SUCCESS; +} + +Status KvStorePredicates::ToQuery(const DataSharePredicates &predicates, DataQuery &query) +{ + std::list operationList = predicates.GetOperationList(); + if (operationList.empty()) { + ZLOGE("ToQuery operationList is null"); + return Status::INVALID_ARGUMENT; + } + + for (const auto &oper : operationList) { + if (oper.operation < 0 || oper.operation >= LAST_TYPE) { + ZLOGE("operation param error"); + return Status::NOT_SUPPORT; + } + Status status = (this->*HANDLERS[oper.operation])(oper, query); + if (status != Status::SUCCESS) { + ZLOGE("ToQuery called failed: %{public}d", status); + return status; + } + } + return Status::SUCCESS; +} + +Status KvStorePredicates::InKeys(const OperationItem &oper, DataQuery &query) +{ + std::vector keys; + int status = oper.para1.GetStringVector(keys); + if (status != E_OK) { + ZLOGE("GetStringVector failed: %{public}d", status); + return Status::ERROR; + } + query.InKeys(keys); + return Status::SUCCESS; +} + +Status KvStorePredicates::KeyPrefix(const OperationItem &oper, DataQuery &query) +{ + std::string prefix; + int status = oper.para1.GetString(prefix); + if (status != E_OK) { + ZLOGE("KeyPrefix failed: %{public}d", status); + return Status::ERROR; + } + query.KeyPrefix(prefix); + return Status::SUCCESS; +} + +Status KvStorePredicates::EqualTo(const OperationItem &oper, DataQuery &query) +{ + Context context; + Status status = GetContext(oper, context); + if (status != Status::SUCCESS) { + ZLOGE("EqualTo GetContext called failed: %{public}d", status); + return status; + } + + switch (context.innerType) { + case DataSharePredicatesObjectType::TYPE_INT: { + query.EqualTo(context.field, context.intValue); + break; + } + case DataSharePredicatesObjectType::TYPE_LONG: { + query.EqualTo(context.field, context.longValue); + break; + } + case DataSharePredicatesObjectType::TYPE_DOUBLE: { + query.EqualTo(context.field, context.doubleValue); + break; + } + case DataSharePredicatesObjectType::TYPE_BOOL: { + query.EqualTo(context.field, context.boolValue); + break; + } + case DataSharePredicatesObjectType::TYPE_STRING: { + query.EqualTo(context.field, context.stringValue); + break; + } + default: + status = Status::ERROR; + ZLOGE("EqualTo failed: %{public}d", status); + break; + } + return status; +} + +Status KvStorePredicates::NotEqualTo(const OperationItem &oper, DataQuery &query) +{ + Context context; + Status status = GetContext(oper, context); + if (status != Status::SUCCESS) { + ZLOGE("NotEqualTo GetContext called failed: %{public}d", status); + return status; + } + + switch (context.innerType) { + case DataSharePredicatesObjectType::TYPE_INT: { + query.NotEqualTo(context.field, context.intValue); + break; + } + case DataSharePredicatesObjectType::TYPE_LONG: { + query.NotEqualTo(context.field, context.longValue); + break; + } + case DataSharePredicatesObjectType::TYPE_DOUBLE: { + query.NotEqualTo(context.field, context.doubleValue); + break; + } + case DataSharePredicatesObjectType::TYPE_BOOL: { + query.NotEqualTo(context.field, context.boolValue); + break; + } + case DataSharePredicatesObjectType::TYPE_STRING: { + query.NotEqualTo(context.field, context.stringValue); + break; + } + default: + status = Status::ERROR; + ZLOGE("NotEqualTo failed: %{public}d", status); + break; + } + return status; +} + +Status KvStorePredicates::GreaterThan(const OperationItem &oper, DataQuery &query) +{ + Context context; + Status status = GetContext(oper, context); + if (status != Status::SUCCESS) { + ZLOGE("GreaterThan GetContext called failed: %{public}d", status); + return status; + } + + switch (context.innerType) { + case DataSharePredicatesObjectType::TYPE_INT: { + query.GreaterThan(context.field, context.intValue); + break; + } + case DataSharePredicatesObjectType::TYPE_LONG: { + query.GreaterThan(context.field, context.longValue); + break; + } + case DataSharePredicatesObjectType::TYPE_DOUBLE: { + query.GreaterThan(context.field, context.doubleValue); + break; + } + case DataSharePredicatesObjectType::TYPE_STRING: { + query.GreaterThan(context.field, context.stringValue); + break; + } + default: + status = Status::ERROR; + ZLOGE("GreaterThan failed: %{public}d", status); + break; + } + return status; +} + +Status KvStorePredicates::LessThan(const OperationItem &oper, DataQuery &query) +{ + Context context; + Status status = GetContext(oper, context); + if (status != Status::SUCCESS) { + ZLOGE("LessThan GetContext called failed: %{public}d", status); + return status; + } + + switch (context.innerType) { + case DataSharePredicatesObjectType::TYPE_INT: { + query.LessThan(context.field, context.intValue); + break; + } + case DataSharePredicatesObjectType::TYPE_LONG: { + query.LessThan(context.field, context.longValue); + break; + } + case DataSharePredicatesObjectType::TYPE_DOUBLE: { + query.LessThan(context.field, context.doubleValue); + break; + } + case DataSharePredicatesObjectType::TYPE_STRING: { + query.LessThan(context.field, context.stringValue); + break; + } + default: + status = Status::ERROR; + ZLOGE("LessThan failed: %{public}d", status); + break; + } + return status; +} + +Status KvStorePredicates::GreaterThanOrEqualTo(const OperationItem &oper, DataQuery &query) +{ + Context context; + Status status = GetContext(oper, context); + if (status != Status::SUCCESS) { + ZLOGE("GreaterThanOrEqualTo GetContext called failed: %{public}d", status); + return status; + } + + switch (context.innerType) { + case DataSharePredicatesObjectType::TYPE_INT: { + query.GreaterThanOrEqualTo(context.field, context.intValue); + break; + } + case DataSharePredicatesObjectType::TYPE_LONG: { + query.GreaterThanOrEqualTo(context.field, context.longValue); + break; + } + case DataSharePredicatesObjectType::TYPE_DOUBLE: { + query.GreaterThanOrEqualTo(context.field, context.doubleValue); + break; + } + case DataSharePredicatesObjectType::TYPE_STRING: { + query.GreaterThanOrEqualTo(context.field, context.stringValue); + break; + } + default: + status = Status::ERROR; + ZLOGE("GreaterThanOrEqualTo failed: %{public}d", status); + break; + } + return status; +} + +Status KvStorePredicates::LessThanOrEqualTo(const OperationItem &oper, DataQuery &query) +{ + Context context; + Status status = GetContext(oper, context); + if (status != Status::SUCCESS) { + ZLOGE("LessThanOrEqualTo GetContext called failed: %{public}d", status); + return status; + } + + switch (context.innerType) { + case DataSharePredicatesObjectType::TYPE_INT: { + query.LessThanOrEqualTo(context.field, context.intValue); + break; + } + case DataSharePredicatesObjectType::TYPE_LONG: { + query.LessThanOrEqualTo(context.field, context.longValue); + break; + } + case DataSharePredicatesObjectType::TYPE_DOUBLE: { + query.LessThanOrEqualTo(context.field, context.doubleValue); + break; + } + case DataSharePredicatesObjectType::TYPE_STRING: { + query.LessThanOrEqualTo(context.field, context.stringValue); + break; + } + default: + status = Status::ERROR; + ZLOGE("LessThanOrEqualTo failed: %{public}d", status); + break; + } + return status; +} + +Status KvStorePredicates::And(const OperationItem &oper, DataQuery &query) +{ + query.And(); + return Status::SUCCESS; +} + +Status KvStorePredicates::Or(const OperationItem &oper, DataQuery &query) +{ + query.Or(); + return Status::SUCCESS; +} + +Status KvStorePredicates::IsNull(const OperationItem &oper, DataQuery &query) +{ + std::string field; + int status = oper.para1.GetString(field); + if (status != E_OK) { + ZLOGE("IsNull failed: %{public}d", status); + return Status::ERROR; + } + query.IsNull(field); + return Status::SUCCESS; +} + +Status KvStorePredicates::IsNotNull(const OperationItem &oper, DataQuery &query) +{ + std::string field; + int status = oper.para1.GetString(field); + if (status != E_OK) { + ZLOGE("IsNotNull failed: %{public}d", status); + return Status::ERROR; + } + query.IsNotNull(field); + return Status::SUCCESS; +} + +Status KvStorePredicates::In(const OperationItem &oper, DataQuery &query) +{ + Context context; + Status status = GetContext(oper, context); + if (status != Status::SUCCESS) { + ZLOGE("In GetContext called failed: %{public}d", status); + return status; + } + + switch (context.innerType) { + case DataSharePredicatesObjectType::TYPE_INT_VECTOR: { + query.In(context.field, context.intList); + break; + } + case DataSharePredicatesObjectType::TYPE_LONG_VECTOR: { + query.In(context.field, context.longList); + break; + } + case DataSharePredicatesObjectType::TYPE_DOUBLE_VECTOR: { + query.In(context.field, context.doubleList); + break; + } + case DataSharePredicatesObjectType::TYPE_STRING_VECTOR: { + query.In(context.field, context.stringList); + break; + } + default: + status = Status::ERROR; + ZLOGE("In failed: %{public}d", status); + break; + } + return status; +} + +Status KvStorePredicates::NotIn(const OperationItem &oper, DataQuery &query) +{ + Context context; + Status status = GetContext(oper, context); + if (status != Status::SUCCESS) { + ZLOGE("NotIn GetContext called failed: %{public}d", status); + return status; + } + + switch (context.innerType) { + case DataSharePredicatesObjectType::TYPE_INT_VECTOR: { + query.NotIn(context.field, context.intList); + break; + } + case DataSharePredicatesObjectType::TYPE_LONG_VECTOR: { + query.NotIn(context.field, context.longList); + break; + } + case DataSharePredicatesObjectType::TYPE_DOUBLE_VECTOR: { + query.NotIn(context.field, context.doubleList); + break; + } + case DataSharePredicatesObjectType::TYPE_STRING_VECTOR: { + query.NotIn(context.field, context.stringList); + break; + } + default: + status = Status::ERROR; + ZLOGE("NotIn failed: %{public}d", status); + break; + } + return status; +} + +Status KvStorePredicates::Like(const OperationItem &oper, DataQuery &query) +{ + std::string field; + int status = oper.para1.GetString(field); + if (status != E_OK) { + ZLOGE("Like field failed: %{public}d", status); + return Status::ERROR; + } + + std::string value; + status = oper.para2.GetString(value); + if (status != E_OK) { + ZLOGE("Like value failed: %{public}d", status); + return Status::ERROR; + } + query.Like(field, value); + return Status::SUCCESS; +} + +Status KvStorePredicates::Unlike(const OperationItem &oper, DataQuery &query) +{ + std::string field; + int status = oper.para1.GetString(field); + if (status != E_OK) { + ZLOGE("Unlike failed: %{public}d", status); + return Status::ERROR; + } + + std::string value; + status = oper.para2.GetString(value); + if (status != E_OK) { + ZLOGE("Unlike value failed: %{public}d", status); + return Status::ERROR; + } + query.Unlike(field, value); + return Status::SUCCESS; +} + +Status KvStorePredicates::OrderByAsc(const OperationItem &oper, DataQuery &query) +{ + std::string field; + int status = oper.para1.GetString(field); + if (status != E_OK) { + ZLOGE("OrderByAsc failed: %{public}d", status); + return Status::ERROR; + } + query.OrderByAsc(field); + return Status::SUCCESS; +} + +Status KvStorePredicates::OrderByDesc(const OperationItem &oper, DataQuery &query) +{ + std::string field; + int status = oper.para1.GetString(field); + if (status != E_OK) { + ZLOGE("OrderByDesc failed: %{public}d", status); + return Status::ERROR; + } + query.OrderByDesc(field); + return Status::SUCCESS; +} + +Status KvStorePredicates::Limit(const OperationItem &oper, DataQuery &query) +{ + int number; + int status = oper.para1.GetInt(number); + if (status != E_OK) { + ZLOGE("Limit number failed: %{public}d", status); + return Status::ERROR; + } + + int offset; + status = oper.para2.GetInt(offset); + if (status != E_OK) { + ZLOGE("Limit offset failed: %{public}d", offset); + return Status::ERROR; + } + query.Limit(number, offset); + return Status::SUCCESS; +} +} // namespace DistributedKv +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_values_bucket.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_values_bucket.cpp new file mode 100644 index 000000000..322715d31 --- /dev/null +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_values_bucket.cpp @@ -0,0 +1,79 @@ +/* + * 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. + */ + +#define LOG_TAG "KvStoreValuesBucket" + +#include "log_print.h" +#include "kvstore_values_bucket.h" + +namespace OHOS { +namespace DistributedKv { +using namespace DataShare; + +std::vector KvStoreValuesBucket::ToEntry(const std::vector &valueBuckets) +{ + std::vector entries; + for (const auto &val : valueBuckets) { + Entry entry = ToEntry(val); + entries.push_back(entry); + } + return entries; +} + +Entry KvStoreValuesBucket::ToEntry(const DataShareValuesBucket &valueBucket) +{ + std::map valuesMap; + valueBucket.GetAll(valuesMap); + if (valuesMap.empty()) { + ZLOGE("valuesMap is null"); + return {}; + } + Entry entry; + Status status = ToEntryData(valuesMap, KEY, entry.key); + if (status != Status::SUCCESS) { + ZLOGE("GetEntry key failed: %{public}d", status); + return {}; + } + status = ToEntryData(valuesMap, VALUE, entry.value); + if (status != Status::SUCCESS) { + ZLOGE("GetEntry value failed: %{public}d", status); + return {}; + } + return entry; +} + +Status KvStoreValuesBucket::ToEntryData(const std::map &valuesMap, const std::string field, Blob &kv) +{ + auto it = valuesMap.find(field); + if (it == valuesMap.end()) { + ZLOGE("field is not find!"); + 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 data; + int status = it->second.GetBlob(data); + if (status != Status::SUCCESS) { + ZLOGE("GetBlob failed: %{public}d", status); + return Status::ERROR; + } + kv = data; + return Status::SUCCESS; +} +} // namespace DistributedKv +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/jskitsimpl/distributeddata/include/js_kv_store_resultset.h b/frameworks/jskitsimpl/distributeddata/include/js_kv_store_resultset.h index 9ce9ce04c..dd140d8ad 100644 --- a/frameworks/jskitsimpl/distributeddata/include/js_kv_store_resultset.h +++ b/frameworks/jskitsimpl/distributeddata/include/js_kv_store_resultset.h @@ -16,10 +16,11 @@ #define OHOS_KV_STORE_RESELTSET_H #include #include "napi_queue.h" +#include "result_set_bridge.h" #include "kvstore_result_set.h" namespace OHOS::DistributedData { -class JsKVStoreResultSet { +class JsKVStoreResultSet :public DataShare::ResultSetBridge::Creator { public: JsKVStoreResultSet() = default; ~JsKVStoreResultSet() = default; @@ -30,6 +31,8 @@ public: static napi_value Constructor(napi_env env); static napi_value New(napi_env env, napi_callback_info info); + virtual std::shared_ptr Create() override; + private: static napi_value GetCount(napi_env env, napi_callback_info info); static napi_value GetPosition(napi_env env, napi_callback_info info); diff --git a/frameworks/jskitsimpl/distributeddata/include/js_util.h b/frameworks/jskitsimpl/distributeddata/include/js_util.h index 1c4489424..71313b72e 100644 --- a/frameworks/jskitsimpl/distributeddata/include/js_util.h +++ b/frameworks/jskitsimpl/distributeddata/include/js_util.h @@ -22,6 +22,8 @@ #include "napi/native_api.h" #include "napi/native_common.h" #include "napi/native_node_api.h" +#include "datashare_predicates.h" +#include "datashare_values_bucket.h" namespace OHOS::DistributedData { class JSUtil final { @@ -137,6 +139,10 @@ 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 &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); + /* napi_get_named_property wrapper */ template static inline napi_status GetNamedProperty(napi_env env, napi_value in, const std::string& prop, T& value) diff --git a/frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp b/frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp index dd035e0a9..40f73f152 100644 --- a/frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp +++ b/frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp @@ -15,8 +15,9 @@ #define LOG_TAG "JS_DeviceKVStore" #include "js_device_kv_store.h" #include - +#include "kv_utils.h" #include "js_kv_store_resultset.h" +#include "datashare_predicates.h" #include "js_query.h" #include "js_util.h" #include "log_print.h" @@ -24,7 +25,7 @@ #include "uv_queue.h" using namespace OHOS::DistributedKv; - +using namespace OHOS::DataShare; namespace OHOS::DistributedData { constexpr int DEVICEID_WIDTH = 4; static std::string GetDeviceKey(const std::string& deviceId, const std::string& key) @@ -121,6 +122,7 @@ enum class ArgsType : uint8_t { DEVICEID_KEYPREFIX = 0, DEVICEID_QUERY, QUERY, + PREDICATES, UNKNOWN = 255 }; struct VariantArgs { @@ -129,6 +131,7 @@ struct VariantArgs { std::string keyPrefix; JsQuery* query; ArgsType type = ArgsType::UNKNOWN; + DataSharePredicates predicates; }; static napi_status GetVariantArgs(napi_env env, size_t argc, napi_value* argv, VariantArgs& va) @@ -264,7 +267,13 @@ 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); + }; ctxt->status = (status == Status::SUCCESS) ? napi_ok : napi_generic_failure; CHECK_STATUS_RETURN_VOID(ctxt, "kvStore->GetResultSet() failed!"); ctxt->resultSet->SetNative(kvResultSet); diff --git a/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp b/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp index 2762606e8..8bfd2a6e7 100644 --- a/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp +++ b/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp @@ -18,9 +18,15 @@ #include "js_kv_store_resultset.h" #include "log_print.h" #include "napi_queue.h" +#include "datashare_values_bucket.h" +#include "datashare_predicates.h" #include "single_kvstore.h" +#include "kv_utils.h" +#include "kvstore_datashare_result_set.h" +#include "kvstore_predicates.h" using namespace OHOS::DistributedKv; +using namespace OHOS::DataShare; namespace OHOS::DistributedData { std::map JsKVStore::onEventHandlers_ = { @@ -107,28 +113,47 @@ napi_value JsKVStore::Put(napi_env env, napi_callback_info info) struct PutContext : public ContextBase { std::string key; std::vector value; + std::vector valueBuckets; + std::vector entries; + napi_valuetype type; }; auto ctxt = std::make_shared(); ctxt->GetCbInfo(env, info, [env, ctxt](size_t argc, napi_value* argv) { // required 2 arguments :: - 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(); + 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(); + } }); auto execute = [ctxt]() { - OHOS::DistributedKv::Key key(ctxt->key); - OHOS::DistributedKv::Value value(ctxt->value); - auto& kvStore = reinterpret_cast(ctxt->native)->kvStore_; - Status status = kvStore->Put(key, value); - ZLOGD("kvStore->Put return %{public}d", status); + Status status = Status::ERROR; + if (ctxt->type == napi_object) { + auto& kvStore = reinterpret_cast(ctxt->native)->kvStore_; + ctxt->entries = KvUtils::ToEntry(ctxt->valueBuckets); + ZLOGD("kvStoreDataShare->ToEntry return"); + status = kvStore->PutBatch(ctxt->entries); + CHECK_STATUS_RETURN_VOID(ctxt, "kvStoreDataShare->Put, i.e. Put error!"); + } else if (ctxt->type == napi_string) { + OHOS::DistributedKv::Key key(ctxt->key); + OHOS::DistributedKv::Value value(ctxt->value); + auto& kvStore = reinterpret_cast(ctxt->native)->kvStore_; + 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!"); }; @@ -147,21 +172,42 @@ napi_value JsKVStore::Delete(napi_env env, napi_callback_info info) ZLOGD("KVStore::Delete()"); struct DeleteContext : public ContextBase { std::string key; + DataSharePredicates predicates; + napi_valuetype type; }; auto ctxt = std::make_shared(); ctxt->GetCbInfo(env, info, [env, ctxt](size_t argc, napi_value* argv) { - // required 1 arguments :: + // required 1 arguments :: || CHECK_ARGS_RETURN_VOID(ctxt, argc == 1, "invalid arguments!"); - ctxt->status = JSUtil::GetValue(env, argv[0], ctxt->key); - CHECK_STATUS_RETURN_VOID(ctxt, "invalid arg[0], i.e. invalid key!"); + ctxt->type = napi_undefined; + ctxt->status = napi_typeof(env, argv[0], &(ctxt->type)); + if (ctxt->type == napi_string) { + ctxt->status = JSUtil::GetValue(env, argv[0], ctxt->key); + 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); + ZLOGD("kvStoreDataShare->Delete return %{public}d", ctxt->status); + CHECK_STATUS_RETURN_VOID(ctxt, "invalid arg[0], i.e. invalid predicates!"); + } }); return NapiQueue::AsyncWork(env, ctxt, std::string(__FUNCTION__), [ctxt]() { - OHOS::DistributedKv::Key key(ctxt->key); - auto& kvStore = reinterpret_cast(ctxt->native)->kvStore_; - Status status = kvStore->Delete(key); - ZLOGD("kvStore->Put return %{public}d", status); + Status status = Status::ERROR; + if (ctxt->type == napi_object) { + std::vector keys; + status = KvUtils::GetKeys(ctxt->predicates, keys); + ZLOGD("GetKeys return %{public}d", status); + auto& kvStore = reinterpret_cast(ctxt->native)->kvStore_; + status = kvStore->DeleteBatch(keys); + ZLOGD("kv Datashare Delete return %{public}d", status); + } else if (ctxt->type == napi_string) { + OHOS::DistributedKv::Key key(ctxt->key); + auto& kvStore = reinterpret_cast(ctxt->native)->kvStore_; + status = kvStore->Delete(key); + } + ZLOGD("kvStore->Delete return %{public}d", status); ctxt->status = (status == Status::SUCCESS) ? napi_ok : napi_generic_failure; CHECK_STATUS_RETURN_VOID(ctxt, "kvStore->Delete() failed!"); }); diff --git a/frameworks/jskitsimpl/distributeddata/src/js_kv_store_resultset.cpp b/frameworks/jskitsimpl/distributeddata/src/js_kv_store_resultset.cpp index 04467b0ed..f63d36cb2 100644 --- a/frameworks/jskitsimpl/distributeddata/src/js_kv_store_resultset.cpp +++ b/frameworks/jskitsimpl/distributeddata/src/js_kv_store_resultset.cpp @@ -18,8 +18,11 @@ #include "log_print.h" #include "napi_queue.h" #include "uv_queue.h" +#include "kvstore_datashare_result_set.h" +#include "kv_utils.h" using namespace OHOS::DistributedKv; +using namespace OHOS::DataShare; namespace OHOS::DistributedData { void JsKVStoreResultSet::SetNative(std::shared_ptr& resultSet) { @@ -271,4 +274,9 @@ napi_value JsKVStoreResultSet::GetEntry(napi_env env, napi_callback_info info) / NAPI_ASSERT(env, ctxt->status == napi_ok, "GetEntry failed!"); return ctxt->output; } -} // namespace OHOS::DistributedData + +std::shared_ptr JsKVStoreResultSet::Create() +{ + return KvUtils::ToResultSetBridge(resultSet_); +} +}// namespace OHOS::DistributedData diff --git a/frameworks/jskitsimpl/distributeddata/src/js_single_kv_store.cpp b/frameworks/jskitsimpl/distributeddata/src/js_single_kv_store.cpp index 99babeb6c..a7c3f0542 100644 --- a/frameworks/jskitsimpl/distributeddata/src/js_single_kv_store.cpp +++ b/frameworks/jskitsimpl/distributeddata/src/js_single_kv_store.cpp @@ -16,13 +16,15 @@ #include "js_single_kv_store.h" #include "js_util.h" #include "js_kv_store_resultset.h" +#include "datashare_predicates.h" #include "js_query.h" #include "log_print.h" #include "napi_queue.h" #include "uv_queue.h" +#include "kv_utils.h" using namespace OHOS::DistributedKv; - +using namespace OHOS::DataShare; namespace OHOS::DistributedData { JsSingleKVStore::JsSingleKVStore(const std::string& storeId) : JsKVStore(storeId) @@ -104,6 +106,7 @@ enum class ArgsType : uint8_t { /* input arguments' combination type */ KEYPREFIX = 0, QUERY, + PREDICATES, UNKNOWN = 255 }; struct VariantArgs { @@ -111,6 +114,7 @@ struct VariantArgs { std::string keyPrefix; JsQuery* query; ArgsType type = ArgsType::UNKNOWN; + DataSharePredicates predicates; }; static napi_status GetVariantArgs(napi_env env, size_t argc, napi_value* argv, VariantArgs& va) @@ -125,9 +129,19 @@ static napi_status GetVariantArgs(napi_env env, size_t argc, napi_value* argv, V CHECK_RETURN(!va.keyPrefix.empty(), "invalid arg[0], i.e. invalid keyPrefix!", napi_invalid_arg); va.type = ArgsType::KEYPREFIX; } else if (type == napi_object) { - status = JSUtil::Unwrap(env, argv[0], reinterpret_cast(&va.query), JsQuery::Constructor(env)); - CHECK_RETURN(va.query != nullptr, "invalid arg[0], i.e. invalid query!", napi_invalid_arg); - va.type = ArgsType::QUERY; + bool result = false; + status = napi_instanceof(env, argv[0], JsQuery::Constructor(env), &result); + if ((status == napi_ok) && (result != false)) { + status = JSUtil::Unwrap(env, argv[0], reinterpret_cast(&va.query), JsQuery::Constructor(env)); + 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; + ZLOGD("kvStoreDataShare->GetResultSet return %{public}d", status); + CHECK_RETURN(true, "invalid arg[0], i.e. invalid predicates!", napi_invalid_arg); + // CHECK_RETURN(va.predicates, "invalid arg[0], i.e. invalid predicates!", napi_invalid_arg); + } } return status; }; @@ -219,7 +233,13 @@ 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); + ZLOGD("ArgsType::PREDICATES ToQuery return %{public}d", status); + status = kvStore->GetResultSetWithQuery(query.ToString(), kvResultSet); + ZLOGD("ArgsType::PREDICATES GetResultSetWithQuery return %{public}d", status); + }; ctxt->status = (status == Status::SUCCESS) ? napi_ok : napi_generic_failure; CHECK_STATUS_RETURN_VOID(ctxt, "kvStore->GetResultSet() failed!"); ctxt->resultSet->SetNative(kvResultSet); diff --git a/frameworks/jskitsimpl/distributeddata/src/js_util.cpp b/frameworks/jskitsimpl/distributeddata/src/js_util.cpp index 0f8842775..09d1ffef9 100644 --- a/frameworks/jskitsimpl/distributeddata/src/js_util.cpp +++ b/frameworks/jskitsimpl/distributeddata/src/js_util.cpp @@ -16,13 +16,14 @@ #include "js_util.h" #include #include - +#include "datashare_predicates_proxy.h" +#include "napi_datashare_values_bucket.h" #include "js_schema.h" #include "log_print.h" #include "napi_queue.h" using namespace OHOS::DistributedKv; - +using namespace OHOS::DataShare; namespace OHOS::DistributedData { constexpr int32_t STR_MAX_LENGTH = 4096; constexpr size_t STR_TAIL_LENGTH = 1; @@ -999,4 +1000,49 @@ bool JSUtil::Equals(napi_env env, napi_value value, napi_ref copy) napi_strict_equals(env, value, copyValue, &isEquals); return isEquals; } + +napi_status JSUtil::GetValue(napi_env env, napi_value in, DataSharePredicates &out) +{ + ZLOGD("napi_value -> std::GetValue predicate"); + 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); + 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& out) +{ + ZLOGD("napi_value -> std::vector"); + 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 0000000000000000%{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); + } + return status; +} + +napi_status JSUtil::GetValue(napi_env &env, napi_value &in, DataShareValuesBucket &out) +{ + 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; +} } // namespace OHOS::DistributedData diff --git a/interfaces/innerkits/distributeddata/BUILD.gn b/interfaces/innerkits/distributeddata/BUILD.gn index ff9467439..4b4d56a99 100755 --- a/interfaces/innerkits/distributeddata/BUILD.gn +++ b/interfaces/innerkits/distributeddata/BUILD.gn @@ -31,6 +31,9 @@ config("distributeddatafwk_config") { "//utils/system/safwk/native/include", "//utils/native/base/include", "//foundation/distributeddatamgr/distributeddatamgr/interfaces/innerkits/app_distributeddata/include", + "//foundation/distributeddatamgr/appdatamgr/interfaces/inner_api/native/data_share/provider/include", + "//foundation/distributeddatamgr/appdatamgr/interfaces/inner_api/native/data_share/common/include", + "//foundation/distributeddatamgr/appdatamgr/frameworks/native/data_share/common/include", ] } @@ -60,12 +63,16 @@ 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_death_observer.cpp", + "../../../frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.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/kvstore_values_bucket.cpp", "../../../frameworks/innerkitsimpl/distributeddatafwk/src/single_kvstore_client.cpp", "../../../frameworks/innerkitsimpl/distributeddatafwk/src/sync_observer.cpp", "include/types.h", @@ -83,6 +90,7 @@ ohos_shared_library("distributeddata_inner") { configs = [ ":distributeddatafwk_config" ] deps = [ + "//foundation/distributeddatamgr/appdatamgr/frameworks/native/data_share/common:datashare_common", "//foundation/distributeddatamgr/distributeddatamgr/services/distributeddataservice/adapter:distributeddata_adapter", "//foundation/distributeddatamgr/distributeddatamgr/services/distributeddataservice/adapter/utils:distributeddata_utils_static", "//utils/native/base:utils", diff --git a/interfaces/jskits/distributeddata/BUILD.gn b/interfaces/jskits/distributeddata/BUILD.gn index fa53fdfe9..14f2613c4 100644 --- a/interfaces/jskits/distributeddata/BUILD.gn +++ b/interfaces/jskits/distributeddata/BUILD.gn @@ -42,6 +42,11 @@ ohos_shared_library("distributeddata") { "//foundation/distributeddatamgr/distributeddatamgr/frameworks/jskitsimpl/distributeddata/include", "//foundation/distributeddatamgr/distributeddatamgr/services/distributeddataservice/adapter/include/log", "//foundation/distributeddatamgr/distributeddatamgr/services/distributeddataservice/adapter/include/autils", + "//foundation/distributeddatamgr/distributeddatamgr/services/distributeddataservice/adapter/include/autils", + "//foundation/distributeddatamgr/appdatamgr/interfaces/inner_api/native/data_share/provider/include", + "//foundation/distributeddatamgr/appdatamgr/interfaces/inner_api/native/data_share/common/include", + "//foundation/distributeddatamgr/appdatamgr/frameworks/js/napi/data_share/common/include", + "//foundation/distributeddatamgr/appdatamgr/frameworks/native/data_share/common/include", ] sources = [ @@ -64,6 +69,7 @@ ohos_shared_library("distributeddata") { deps = [ #":distributed_data_js", "//foundation/arkui/napi:ace_napi", + "//foundation/distributeddatamgr/appdatamgr/frameworks/native/data_share/common:datashare_common", "//foundation/distributeddatamgr/distributeddatamgr/interfaces/innerkits/distributeddata:distributeddata_inner", "//third_party/libuv:uv", "//utils/native/base:utils", -- Gitee From 88ddc209d50824a0954a827acdb4050de7eccc2d Mon Sep 17 00:00:00 2001 From: anan Date: Wed, 18 May 2022 14:43:52 +0800 Subject: [PATCH 03/20] =?UTF-8?q?=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: anan --- .vscode/settings.json | 70 +++++++++++++++++++ .../distributeddatafwk/include/kv_utils.h | 6 +- .../include/kvstore_datashare_result_set.h | 3 - .../include/kvstore_predicates.h | 2 +- .../include/kvstore_values_bucket.h | 4 +- .../distributeddatafwk/src/kv_utils.cpp | 34 +-------- .../src/kvstore_datashare_result_set.cpp | 1 - .../src/kvstore_predicates.cpp | 30 ++++++++ .../distributeddata/src/js_kv_store.cpp | 5 +- interfaces/jskits/distributeddata/BUILD.gn | 1 + 10 files changed, 112 insertions(+), 44 deletions(-) create mode 100644 .vscode/settings.json diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 000000000..8e91f220c --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,70 @@ +{ + "files.associations": { + "any": "cpp", + "array": "cpp", + "atomic": "cpp", + "bit": "cpp", + "*.tcc": "cpp", + "bitset": "cpp", + "cctype": "cpp", + "chrono": "cpp", + "cinttypes": "cpp", + "clocale": "cpp", + "cmath": "cpp", + "codecvt": "cpp", + "compare": "cpp", + "concepts": "cpp", + "condition_variable": "cpp", + "cstdarg": "cpp", + "cstddef": "cpp", + "cstdint": "cpp", + "cstdio": "cpp", + "cstdlib": "cpp", + "cstring": "cpp", + "ctime": "cpp", + "cwchar": "cpp", + "cwctype": "cpp", + "deque": "cpp", + "list": "cpp", + "map": "cpp", + "set": "cpp", + "string": "cpp", + "unordered_map": "cpp", + "vector": "cpp", + "exception": "cpp", + "algorithm": "cpp", + "functional": "cpp", + "iterator": "cpp", + "memory": "cpp", + "memory_resource": "cpp", + "numeric": "cpp", + "random": "cpp", + "ratio": "cpp", + "regex": "cpp", + "string_view": "cpp", + "system_error": "cpp", + "tuple": "cpp", + "type_traits": "cpp", + "utility": "cpp", + "fstream": "cpp", + "initializer_list": "cpp", + "iomanip": "cpp", + "iosfwd": "cpp", + "iostream": "cpp", + "istream": "cpp", + "limits": "cpp", + "mutex": "cpp", + "new": "cpp", + "numbers": "cpp", + "ostream": "cpp", + "semaphore": "cpp", + "shared_mutex": "cpp", + "sstream": "cpp", + "stdexcept": "cpp", + "stop_token": "cpp", + "streambuf": "cpp", + "thread": "cpp", + "typeinfo": "cpp", + "variant": "cpp" + } +} \ No newline at end of file diff --git a/frameworks/innerkitsimpl/distributeddatafwk/include/kv_utils.h b/frameworks/innerkitsimpl/distributeddatafwk/include/kv_utils.h index ee492a50e..bfe8af87b 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/include/kv_utils.h +++ b/frameworks/innerkitsimpl/distributeddatafwk/include/kv_utils.h @@ -27,12 +27,12 @@ namespace OHOS { namespace DistributedKv { class KvUtils { public: - static std::shared_ptr ToResultSetBridge(const std::shared_ptr resultSet); + static std::shared_ptr ToResultSetBridge(std::shared_ptr resultSet); static Status ToQuery(const DataShare::DataSharePredicates &predicates, DataQuery &query); static Entry ToEntry(const DataShare::DataShareValuesBucket &valueBucket); - static std::vector ToEntry(const std::vector &valueBuckets); - static Status GetKeys(const DataShare::DataSharePredicates &predicates, std::vector &keys); + static std::vector ToEntries(const std::vector &valueBuckets); private: + KvUtils() = delete; KvUtils(KvUtils &&) = delete; KvUtils(const KvUtils &) = delete; KvUtils &operator=(KvUtils &&) = delete; diff --git a/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_datashare_result_set.h b/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_datashare_result_set.h index cc3dbf4e1..ba9723b75 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_datashare_result_set.h +++ b/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_datashare_result_set.h @@ -33,14 +33,11 @@ public: int GetAllColumnsName(std::vector &columnsName) override; - // bool OnGo(int oldRowIndex, int newRowIndex, const std::shared_ptr &writer) override; bool OnGo(int32_t start, int32_t length, DataShare::ResultSetBridge::Writer &writer) override; private: int Count(); - // bool FillBlock(int startRowIndex, const std::shared_ptr &writer); - bool FillBlock(int startRowIndex, DataShare::ResultSetBridge::Writer &writer); static constexpr int32_t INVALID_COUNT = -1; diff --git a/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_predicates.h b/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_predicates.h index 12c0739d0..b6dffd1b6 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_predicates.h +++ b/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_predicates.h @@ -41,7 +41,7 @@ public: KvStorePredicates() = default; ~KvStorePredicates() = default; Status ToQuery(const DataShare::DataSharePredicates &predicates, DataQuery &query); - + Status GetKeys(const DataShare::DataSharePredicates &predicates, std::vector &keys); private: Status EqualTo(const DataShare::OperationItem &oper, DataQuery &query); Status NotEqualTo(const DataShare::OperationItem &oper, DataQuery &query); diff --git a/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_values_bucket.h b/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_values_bucket.h index 4fc354291..ad2a3fa41 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_values_bucket.h +++ b/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_values_bucket.h @@ -31,8 +31,8 @@ public: private: Status ToEntryData(const std::map &valuesMap, const std::string field, Blob &kv); - const std::string KEY = "key"; - const std::string VALUE = "value"; + static constexpr const char *KEY= "key"; + static constexpr const char *VALUE= "value"; }; } // namespace DistributedKv } // namespace OHOS diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp index f8f4dd3af..a245ebdcf 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp @@ -26,7 +26,7 @@ namespace OHOS { namespace DistributedKv { using namespace DataShare; std::shared_ptr KvUtils::ToResultSetBridge( - const std::shared_ptr resultSet) + std::shared_ptr resultSet) { if (resultSet == nullptr) { ZLOGE("param error, kvResultSet nullptr"); @@ -46,7 +46,7 @@ Status KvUtils::ToQuery(const DataSharePredicates &predicates, DataQuery &query) return status; } -std::vector KvUtils::ToEntry(const std::vector &valueBuckets) +std::vector KvUtils::ToEntries(const std::vector &valueBuckets) { auto KvValuesBucket = std::make_shared(); std::vector entries = KvValuesBucket->ToEntry(valueBuckets); @@ -62,35 +62,5 @@ Entry KvUtils::ToEntry(const DataShareValuesBucket &valueBucket) auto KvValuesBucket = std::make_shared(); return KvValuesBucket->ToEntry(valueBucket); } - -Status KvUtils::GetKeys(const DataSharePredicates &predicates, std::vector &keys) -{ - std::list operationList = predicates.GetOperationList(); - if (operationList.empty()) { - ZLOGE("operationList is null"); - return Status::ERROR; - } - - std::vector myKeys; - for(const auto &oper : operationList) - { - if (oper.operation != IN_KEY) { - ZLOGE("find operation failed"); - return Status::NOT_SUPPORT; - } - std::vector val; - int status = oper.para1.GetStringVector(val); - if (status != E_OK) { - ZLOGE("GetStringVector failed: %{public}d", status); - return Status::ERROR; - } - myKeys.insert(myKeys.end(), val.begin(), val.end()); - } - for (const auto &it : myKeys) - { - keys.push_back(it.c_str()); - } - return Status::SUCCESS; -} } // 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_result_set.cpp index 88e98f0f7..6330c1460 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp @@ -36,7 +36,6 @@ int KvStoreDataShareResultSet::GetAllColumnsName(std::vector &colum columnsName = { "key", "value" }; return E_OK; } -// bool KvStoreDataShareResultSet::FillBlock(int pos, DataShareBlockWriter &writer) bool KvStoreDataShareResultSet::FillBlock(int pos, ResultSetBridge::Writer &writer) { if (kvResultSet_ == nullptr) { diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp index 1a92f7a4d..4fec578c5 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp @@ -104,6 +104,36 @@ Status KvStorePredicates::ToQuery(const DataSharePredicates &predicates, DataQue return Status::SUCCESS; } +Status KvStorePredicates::GetKeys(const DataSharePredicates &predicates, std::vector &keys) +{ + std::list operationList = predicates.GetOperationList(); + if (operationList.empty()) { + ZLOGE("operationList is null"); + return Status::ERROR; + } + + std::vector myKeys; + for(const auto &oper : operationList) + { + if (oper.operation != IN_KEY) { + ZLOGE("find operation failed"); + return Status::NOT_SUPPORT; + } + std::vector val; + int status = oper.para1.GetStringVector(val); + if (status != E_OK) { + ZLOGE("GetStringVector failed: %{public}d", status); + return Status::ERROR; + } + myKeys.insert(myKeys.end(), val.begin(), val.end()); + } + for (const auto &it : myKeys) + { + keys.push_back(it.c_str()); + } + return Status::SUCCESS; +} + Status KvStorePredicates::InKeys(const OperationItem &oper, DataQuery &query) { std::vector keys; diff --git a/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp b/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp index 8bfd2a6e7..935ae1ea8 100644 --- a/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp +++ b/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp @@ -143,7 +143,7 @@ napi_value JsKVStore::Put(napi_env env, napi_callback_info info) Status status = Status::ERROR; if (ctxt->type == napi_object) { auto& kvStore = reinterpret_cast(ctxt->native)->kvStore_; - ctxt->entries = KvUtils::ToEntry(ctxt->valueBuckets); + ctxt->entries = KvUtils::ToEntries(ctxt->valueBuckets); ZLOGD("kvStoreDataShare->ToEntry return"); status = kvStore->PutBatch(ctxt->entries); CHECK_STATUS_RETURN_VOID(ctxt, "kvStoreDataShare->Put, i.e. Put error!"); @@ -197,7 +197,8 @@ napi_value JsKVStore::Delete(napi_env env, napi_callback_info info) Status status = Status::ERROR; if (ctxt->type == napi_object) { std::vector keys; - status = KvUtils::GetKeys(ctxt->predicates, keys); + auto kvPredicates = std::make_shared(); + status = kvPredicates->GetKeys(ctxt->predicates, keys); ZLOGD("GetKeys return %{public}d", status); auto& kvStore = reinterpret_cast(ctxt->native)->kvStore_; status = kvStore->DeleteBatch(keys); diff --git a/interfaces/jskits/distributeddata/BUILD.gn b/interfaces/jskits/distributeddata/BUILD.gn index 14f2613c4..750128dd3 100644 --- a/interfaces/jskits/distributeddata/BUILD.gn +++ b/interfaces/jskits/distributeddata/BUILD.gn @@ -64,6 +64,7 @@ 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 = [ -- Gitee From da2d40e81a6a7228fb064d24e59c1878f834d9e6 Mon Sep 17 00:00:00 2001 From: anan Date: Wed, 18 May 2022 14:59:00 +0800 Subject: [PATCH 04/20] =?UTF-8?q?=E4=BF=AE=E6=94=B9js=5Fkv=5Fstore=5Fresul?= =?UTF-8?q?tset?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: anan --- .../jskitsimpl/distributeddata/include/js_kv_store_resultset.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/frameworks/jskitsimpl/distributeddata/include/js_kv_store_resultset.h b/frameworks/jskitsimpl/distributeddata/include/js_kv_store_resultset.h index dd140d8ad..2589a4ec6 100644 --- a/frameworks/jskitsimpl/distributeddata/include/js_kv_store_resultset.h +++ b/frameworks/jskitsimpl/distributeddata/include/js_kv_store_resultset.h @@ -23,7 +23,7 @@ namespace OHOS::DistributedData { class JsKVStoreResultSet :public DataShare::ResultSetBridge::Creator { public: JsKVStoreResultSet() = default; - ~JsKVStoreResultSet() = default; + virtual ~JsKVStoreResultSet() = default; void SetNative(std::shared_ptr& resultSet); std::shared_ptr& GetNative(); -- Gitee From 68069d8fffceae1df3861fbbfae68ace6fb65cd0 Mon Sep 17 00:00:00 2001 From: anan Date: Fri, 20 May 2022 17:47:36 +0800 Subject: [PATCH 05/20] =?UTF-8?q?=E4=BF=AE=E6=94=B9kvstore=5Fpredicates?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: anan --- .../distributeddatafwk/include/cov_util.h | 237 +++++++++++ .../include/kvstore_datashare_result_set.h | 4 +- .../include/kvstore_predicates.h | 14 - .../include/kvstore_values_bucket.h | 39 -- .../distributeddatafwk/src/kv_utils.cpp | 54 ++- .../src/kvstore_datashare_result_set.cpp | 39 +- .../src/kvstore_predicates.cpp | 371 ++++-------------- .../src/kvstore_values_bucket.cpp | 79 ---- .../distributeddata/include/js_util.h | 2 +- .../distributeddata/src/js_kv_store.cpp | 43 +- .../distributeddata/src/js_util.cpp | 4 +- interfaces/innerkits/distributeddata/BUILD.gn | 1 - .../distributeddata}/include/kv_utils.h | 4 +- 13 files changed, 400 insertions(+), 491 deletions(-) create mode 100644 frameworks/innerkitsimpl/distributeddatafwk/include/cov_util.h delete mode 100644 frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_values_bucket.h delete mode 100644 frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_values_bucket.cpp rename {frameworks/innerkitsimpl/distributeddatafwk => interfaces/innerkits/distributeddata}/include/kv_utils.h (88%) diff --git a/frameworks/innerkitsimpl/distributeddatafwk/include/cov_util.h b/frameworks/innerkitsimpl/distributeddatafwk/include/cov_util.h new file mode 100644 index 000000000..39ee7d8ea --- /dev/null +++ b/frameworks/innerkitsimpl/distributeddatafwk/include/cov_util.h @@ -0,0 +1,237 @@ +/* + * 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 +#include +#include +#include "data_query.h" + +namespace OHOS { +namespace DistributedKv { +class CovUtil final { +public: + template + static auto FillField(const std::string &field, const _VTp &data, _TTp &target) + { + return target(); + } + + template + 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 + static auto FillField(const std::string &field, const std::variant<_Types...> &data, _TTp &target) + { + return FillField(field, data, target); + } +}; + +class Equal { +public: + Equal(OHOS::DistributedKv::DataQuery *dataQuery) : dataQuery_(dataQuery) {}; + template + int operator()(const std::string &field, const T &value) + { + dataQuery_->EqualTo(field, value); + return 0; + } + + template + int operator()(const std::string &field, const std::vector &value) + { + return 0; + } + + int operator()() + { + return 0; + } +private: + OHOS::DistributedKv::DataQuery *dataQuery_; +}; + +class NotEqual { +public: + NotEqual(OHOS::DistributedKv::DataQuery *dataQuery) : dataQuery_(dataQuery) {}; + template + int operator()(const std::string &field, const T &value) + { + dataQuery_->NotEqualTo(field, value); + return 0; + } + template + int operator()(const std::string &field, const std::vector &value) + { + return 0; + } + + int operator()() + { + return 0; + } +private: + OHOS::DistributedKv::DataQuery *dataQuery_; +}; + +class Greater { +public: + Greater(OHOS::DistributedKv::DataQuery *dataQuery) : dataQuery_(dataQuery) {}; + template + int operator()(const std::string &field, const T &value) + { + dataQuery_->GreaterThan(field, value); + return 0; + } + template + int operator()(const std::string &field, const std::vector &value) + { + return 0; + } + + int operator()() + { + return 0; + } +private: + OHOS::DistributedKv::DataQuery *dataQuery_; +}; + +class Less { +public: + Less(OHOS::DistributedKv::DataQuery *dataQuery) : dataQuery_(dataQuery) {}; + template + int operator()(const std::string &field, const T &value) + { + dataQuery_->LessThan(field, value); + return 0; + } + template + int operator()(const std::string &field, const std::vector &value) + { + return 0; + } + + int operator()() + { + return 0; + } +private: + OHOS::DistributedKv::DataQuery *dataQuery_; +}; + +class GreaterOrEqual { +public: + GreaterOrEqual(OHOS::DistributedKv::DataQuery *dataQuery) : dataQuery_(dataQuery) {}; + template + int operator()(const std::string &field, const T &value) + { + dataQuery_->GreaterThanOrEqualTo(field, value); + return 0; + } + template + int operator()(const std::string &field, const std::vector &value) + { + return 0; + } + + int operator()() + { + return 0; + } +private: + OHOS::DistributedKv::DataQuery *dataQuery_; +}; + +class LessOrEqual { +public: + LessOrEqual(OHOS::DistributedKv::DataQuery *dataQuery) : dataQuery_(dataQuery) {}; + template + int operator()(const std::string &field, const T &value) + { + dataQuery_->LessThanOrEqualTo(field, value); + return 0; + } + template + int operator()(const std::string &field, const std::vector &value) + { + return 0; + } + + int operator()() + { + return 0; + } +private: + OHOS::DistributedKv::DataQuery *dataQuery_; +}; + +class In { +public: + In(OHOS::DistributedKv::DataQuery *dataQuery) : dataQuery_(dataQuery) {}; + template + int operator()(const std::string &field, const T &value) + { + return 0; + } + template + int operator()(const std::string &field, const std::vector &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 + int operator()(const std::string &field, const T &value) + { + return 0; + } + template + int operator()(const std::string &field, const std::vector &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_result_set.h index ba9723b75..f295e758a 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_datashare_result_set.h +++ b/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_datashare_result_set.h @@ -31,9 +31,9 @@ public: int GetRowCount(int32_t &count) override; - int GetAllColumnsName(std::vector &columnsName) override; + int GetAllColumnNames(std::vector &columnNames) override; - bool OnGo(int32_t start, int32_t length, DataShare::ResultSetBridge::Writer &writer) override; + bool OnGo(int32_t startRowIndex, int32_t targetRowIndex, DataShare::ResultSetBridge::Writer &writer) override; private: int Count(); diff --git a/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_predicates.h b/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_predicates.h index b6dffd1b6..dc40e0b2a 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_predicates.h +++ b/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_predicates.h @@ -25,19 +25,6 @@ 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 intList; - std::vector longList; - std::vector doubleList; - std::vector stringList; - DataShare::DataSharePredicatesObjectType innerType; - }; KvStorePredicates() = default; ~KvStorePredicates() = default; Status ToQuery(const DataShare::DataSharePredicates &predicates, DataQuery &query); @@ -62,7 +49,6 @@ private: 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, diff --git a/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_values_bucket.h b/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_values_bucket.h deleted file mode 100644 index ad2a3fa41..000000000 --- a/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_values_bucket.h +++ /dev/null @@ -1,39 +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_VALUES_BUCKET_H -#define KVSTORE_VALUES_BUCKET_H - -#include "types.h" -#include "datashare_values_bucket.h" - -namespace OHOS { -namespace DistributedKv { -class KvStoreValuesBucket { -public: - KvStoreValuesBucket() = default; - ~KvStoreValuesBucket() = default; - - std::vector ToEntry(const std::vector &valueBuckets); - Entry ToEntry(const DataShare::DataShareValuesBucket &valueBucket); - -private: - Status ToEntryData(const std::map &valuesMap, const std::string field, Blob &kv); - static constexpr const char *KEY= "key"; - static constexpr const char *VALUE= "value"; -}; -} // namespace DistributedKv -} // namespace OHOS -#endif // KVSTORE_VALUES_BUCKET_H \ No newline at end of file diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp index a245ebdcf..4ac8ae56c 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp @@ -20,11 +20,12 @@ #include "kvstore_predicates.h" #include "log_print.h" #include "data_query.h" -#include "kvstore_values_bucket.h" namespace OHOS { namespace DistributedKv { using namespace DataShare; +const std::string KvUtils::KEY = "key"; +const std::string KvUtils::VALUE = "value"; std::shared_ptr KvUtils::ToResultSetBridge( std::shared_ptr resultSet) { @@ -48,19 +49,56 @@ Status KvUtils::ToQuery(const DataSharePredicates &predicates, DataQuery &query) std::vector KvUtils::ToEntries(const std::vector &valueBuckets) { - auto KvValuesBucket = std::make_shared(); - std::vector entries = KvValuesBucket->ToEntry(valueBuckets); - if (entries.empty()) { - ZLOGE("ToEntry entries failed"); - return {}; + std::vector entries; + for (const auto &val : valueBuckets) { + Entry entry = ToEntry(val); + entries.push_back(entry); } return entries; } Entry KvUtils::ToEntry(const DataShareValuesBucket &valueBucket) { - auto KvValuesBucket = std::make_shared(); - return KvValuesBucket->ToEntry(valueBucket); + std::map valuesMap; + valueBucket.GetAll(valuesMap); + if (valuesMap.empty()) { + ZLOGE("valuesMap is null"); + return {}; + } + Entry entry; + Status status = ToEntryData(valuesMap, KEY, entry.key); + if (status != Status::SUCCESS) { + ZLOGE("GetEntry key failed: %{public}d", status); + return {}; + } + status = ToEntryData(valuesMap, VALUE, entry.value); + if (status != Status::SUCCESS) { + ZLOGE("GetEntry value failed: %{public}d", status); + return {}; + } + return entry; +} + +Status KvUtils::ToEntryData(const std::map &valuesMap, const std::string field, Blob &kv) +{ + auto it = valuesMap.find(field); + if (it == valuesMap.end()) { + ZLOGE("field is not find!"); + 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 data; + int status = it->second.GetBlob(data); + if (status != Status::SUCCESS) { + ZLOGE("GetBlob failed: %{public}d", status); + return Status::ERROR; + } + kv = data; + return Status::SUCCESS; } } // 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_result_set.cpp index 6330c1460..17995c751 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp @@ -31,7 +31,7 @@ int KvStoreDataShareResultSet::GetRowCount(int32_t &count) return count == INVALID_COUNT ? E_ERROR : E_OK; } -int KvStoreDataShareResultSet::GetAllColumnsName(std::vector &columnsName) +int KvStoreDataShareResultSet::GetAllColumnNames(std::vector &columnsName) { columnsName = { "key", "value" }; return E_OK; @@ -58,16 +58,16 @@ bool KvStoreDataShareResultSet::FillBlock(int pos, ResultSetBridge::Writer &writ ZLOGE("SharedBlock is full: %{public}d", statusAlloc); return false; } - // int keyStatus = writer.Write(0, &entry.key.Data(), entry.key.Size()); //需打开屏蔽 - // if (keyStatus != E_OK) { - // ZLOGE("WriteBlob key error: %{public}d", keyStatus); - // return false; - // } - // int valueStatus = writer.Write(1, &entry.value.Data(), entry.value.Size());//需打开屏蔽 - // if (valueStatus != E_OK) { - // ZLOGE("WriteBlob value error: %{public}d", valueStatus); - // return false; - // } + int keyStatus = writer.Write(0, &entry.key.Data(), entry.key.Size()); + if (keyStatus != E_OK) { + ZLOGE("WriteBlob key error: %{public}d", keyStatus); + return false; + } + int valueStatus = writer.Write(1, &entry.value.Data(), entry.value.Size()); + if (valueStatus != E_OK) { + ZLOGE("WriteBlob value error: %{public}d", valueStatus); + return false; + } return true; } @@ -88,21 +88,16 @@ int KvStoreDataShareResultSet::Count() resultRowCount = count; return count; } -bool KvStoreDataShareResultSet::OnGo(int32_t start, int32_t length, ResultSetBridge::Writer &writer) +bool KvStoreDataShareResultSet::OnGo(int32_t start, int32_t target, ResultSetBridge::Writer &writer) { - if ((start < 0) || (length < 0) || (start > length) || (length >= Count())) { - ZLOGE("nowRowIndex out of line: %{public}d", length); + if ((start < 0) || (target < 0) || (start > target) || (target >= Count())) { + ZLOGE("nowRowIndex out of line: %{public}d", target); return false; } - // int statusColumn = writer.SetColumnNum(2); - // if (statusColumn != E_OK) { - // ZLOGE("SetColumnNum faild: %{public}d", statusColumn); - // return false; - // } - for (int pos = start; pos <= length; pos++) { - bool ret = FillBlock(pos, writer); + for (int pos = 0; pos < target; pos++) { + bool ret = FillBlock(pos + start, writer); if (!ret) { - ZLOGE("nowRowIndex out of line: %{public}d", length); + ZLOGE("nowRowIndex out of line: %{public}d", target); return ret; } } diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp index 4fec578c5..45e4d7911 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp @@ -15,6 +15,7 @@ #define LOG_TAG "KvStorePredicates" +#include "cov_util.h" #include "kvstore_predicates.h" #include "log_print.h" #include "datashare_errno.h" @@ -24,64 +25,6 @@ namespace DistributedKv { using namespace DataShare; constexpr KvStorePredicates::QueryHandler KvStorePredicates::HANDLERS[LAST_TYPE]; -Status KvStorePredicates::GetContext(const OperationItem &oper, Context &context) -{ - int status = oper.para1.GetString(context.field); - if (status != E_OK) { - ZLOGE("Get context.field failed: %{public}d", status); - return Status::ERROR; - } - - auto innerType = oper.para2.GetType(); - switch (innerType) { - case DataSharePredicatesObjectType::TYPE_INT: { - status = oper.para2.GetInt(context.intValue); - break; - } - case DataSharePredicatesObjectType::TYPE_LONG: { - status = oper.para2.GetLong(context.longValue); - break; - } - case DataSharePredicatesObjectType::TYPE_DOUBLE: { - status = oper.para2.GetDouble(context.doubleValue); - break; - } - case DataSharePredicatesObjectType::TYPE_BOOL: { - status = oper.para2.GetBool(context.boolValue); - break; - } - case DataSharePredicatesObjectType::TYPE_STRING: { - status = oper.para2.GetString(context.stringValue); - break; - } - case DataSharePredicatesObjectType::TYPE_INT_VECTOR: { - status = oper.para2.GetIntVector(context.intList); - break; - } - case DataSharePredicatesObjectType::TYPE_LONG_VECTOR: { - status = oper.para2.GetLongVector(context.longList); - break; - } - case DataSharePredicatesObjectType::TYPE_DOUBLE_VECTOR: { - status = oper.para2.GetDoubleVector(context.doubleList); - break; - } - case DataSharePredicatesObjectType::TYPE_STRING_VECTOR: { - status = oper.para2.GetStringVector(context.stringList); - break; - } - default: - status = Status::ERROR; - break; - } - - if(status != Status::SUCCESS) { - ZLOGE("GetType failed: %{public}d", status); - return Status::ERROR; - } - return Status::SUCCESS; -} - Status KvStorePredicates::ToQuery(const DataSharePredicates &predicates, DataQuery &query) { std::list operationList = predicates.GetOperationList(); @@ -160,214 +103,82 @@ Status KvStorePredicates::KeyPrefix(const OperationItem &oper, DataQuery &query) Status KvStorePredicates::EqualTo(const OperationItem &oper, DataQuery &query) { - Context context; - Status status = GetContext(oper, context); - if (status != Status::SUCCESS) { - ZLOGE("EqualTo GetContext called failed: %{public}d", status); - return status; - } - - switch (context.innerType) { - case DataSharePredicatesObjectType::TYPE_INT: { - query.EqualTo(context.field, context.intValue); - break; - } - case DataSharePredicatesObjectType::TYPE_LONG: { - query.EqualTo(context.field, context.longValue); - break; - } - case DataSharePredicatesObjectType::TYPE_DOUBLE: { - query.EqualTo(context.field, context.doubleValue); - break; - } - case DataSharePredicatesObjectType::TYPE_BOOL: { - query.EqualTo(context.field, context.boolValue); - break; - } - case DataSharePredicatesObjectType::TYPE_STRING: { - query.EqualTo(context.field, context.stringValue); - break; - } - default: - status = Status::ERROR; - ZLOGE("EqualTo failed: %{public}d", status); - break; + + std::string field; + int status = oper.para1.GetString(field); + if (status != E_OK) { + ZLOGE("GetString failed: %{public}d", status); + return Status::ERROR; } - return status; + Equal equal(&query); + CovUtil::FillField(field, oper.para2.value, equal); + return Status::SUCCESS; } Status KvStorePredicates::NotEqualTo(const OperationItem &oper, DataQuery &query) { - Context context; - Status status = GetContext(oper, context); - if (status != Status::SUCCESS) { - ZLOGE("NotEqualTo GetContext called failed: %{public}d", status); - return status; - } - - switch (context.innerType) { - case DataSharePredicatesObjectType::TYPE_INT: { - query.NotEqualTo(context.field, context.intValue); - break; - } - case DataSharePredicatesObjectType::TYPE_LONG: { - query.NotEqualTo(context.field, context.longValue); - break; - } - case DataSharePredicatesObjectType::TYPE_DOUBLE: { - query.NotEqualTo(context.field, context.doubleValue); - break; - } - case DataSharePredicatesObjectType::TYPE_BOOL: { - query.NotEqualTo(context.field, context.boolValue); - break; - } - case DataSharePredicatesObjectType::TYPE_STRING: { - query.NotEqualTo(context.field, context.stringValue); - break; - } - default: - status = Status::ERROR; - ZLOGE("NotEqualTo failed: %{public}d", status); - break; + + std::string field; + int status = oper.para1.GetString(field); + if (status != E_OK) { + ZLOGE("GetString failed: %{public}d", status); + return Status::ERROR; } - return status; + NotEqual notEqual(&query); + CovUtil::FillField(field, oper.para2.value, notEqual); + return Status::SUCCESS; } Status KvStorePredicates::GreaterThan(const OperationItem &oper, DataQuery &query) { - Context context; - Status status = GetContext(oper, context); - if (status != Status::SUCCESS) { - ZLOGE("GreaterThan GetContext called failed: %{public}d", status); - return status; - } - - switch (context.innerType) { - case DataSharePredicatesObjectType::TYPE_INT: { - query.GreaterThan(context.field, context.intValue); - break; - } - case DataSharePredicatesObjectType::TYPE_LONG: { - query.GreaterThan(context.field, context.longValue); - break; - } - case DataSharePredicatesObjectType::TYPE_DOUBLE: { - query.GreaterThan(context.field, context.doubleValue); - break; - } - case DataSharePredicatesObjectType::TYPE_STRING: { - query.GreaterThan(context.field, context.stringValue); - break; - } - default: - status = Status::ERROR; - ZLOGE("GreaterThan failed: %{public}d", status); - break; + std::string field; + int status = oper.para1.GetString(field); + if (status != E_OK) { + ZLOGE("GetString failed: %{public}d", status); + return Status::ERROR; } - return status; + Greater greater(&query); + CovUtil::FillField(field, oper.para2.value, greater); + return Status::SUCCESS; } Status KvStorePredicates::LessThan(const OperationItem &oper, DataQuery &query) -{ - Context context; - Status status = GetContext(oper, context); - if (status != Status::SUCCESS) { - ZLOGE("LessThan GetContext called failed: %{public}d", status); - return status; - } - - switch (context.innerType) { - case DataSharePredicatesObjectType::TYPE_INT: { - query.LessThan(context.field, context.intValue); - break; - } - case DataSharePredicatesObjectType::TYPE_LONG: { - query.LessThan(context.field, context.longValue); - break; - } - case DataSharePredicatesObjectType::TYPE_DOUBLE: { - query.LessThan(context.field, context.doubleValue); - break; - } - case DataSharePredicatesObjectType::TYPE_STRING: { - query.LessThan(context.field, context.stringValue); - break; - } - default: - status = Status::ERROR; - ZLOGE("LessThan failed: %{public}d", status); - break; +{ + std::string field; + int status = oper.para1.GetString(field); + if (status != E_OK) { + ZLOGE("GetString failed: %{public}d", status); + return Status::ERROR; } - return status; + Less less(&query); + CovUtil::FillField(field, oper.para2.value, less); + return Status::SUCCESS; } Status KvStorePredicates::GreaterThanOrEqualTo(const OperationItem &oper, DataQuery &query) -{ - Context context; - Status status = GetContext(oper, context); - if (status != Status::SUCCESS) { - ZLOGE("GreaterThanOrEqualTo GetContext called failed: %{public}d", status); - return status; - } - - switch (context.innerType) { - case DataSharePredicatesObjectType::TYPE_INT: { - query.GreaterThanOrEqualTo(context.field, context.intValue); - break; - } - case DataSharePredicatesObjectType::TYPE_LONG: { - query.GreaterThanOrEqualTo(context.field, context.longValue); - break; - } - case DataSharePredicatesObjectType::TYPE_DOUBLE: { - query.GreaterThanOrEqualTo(context.field, context.doubleValue); - break; - } - case DataSharePredicatesObjectType::TYPE_STRING: { - query.GreaterThanOrEqualTo(context.field, context.stringValue); - break; - } - default: - status = Status::ERROR; - ZLOGE("GreaterThanOrEqualTo failed: %{public}d", status); - break; +{ + std::string field; + int status = oper.para1.GetString(field); + if (status != E_OK) { + ZLOGE("GetString failed: %{public}d", status); + return Status::ERROR; } - return status; + GreaterOrEqual greaterOrEqual(&query); + CovUtil::FillField(field, oper.para2.value, greaterOrEqual); + return Status::SUCCESS; } Status KvStorePredicates::LessThanOrEqualTo(const OperationItem &oper, DataQuery &query) { - Context context; - Status status = GetContext(oper, context); - if (status != Status::SUCCESS) { - ZLOGE("LessThanOrEqualTo GetContext called failed: %{public}d", status); - return status; - } - - switch (context.innerType) { - case DataSharePredicatesObjectType::TYPE_INT: { - query.LessThanOrEqualTo(context.field, context.intValue); - break; - } - case DataSharePredicatesObjectType::TYPE_LONG: { - query.LessThanOrEqualTo(context.field, context.longValue); - break; - } - case DataSharePredicatesObjectType::TYPE_DOUBLE: { - query.LessThanOrEqualTo(context.field, context.doubleValue); - break; - } - case DataSharePredicatesObjectType::TYPE_STRING: { - query.LessThanOrEqualTo(context.field, context.stringValue); - break; - } - default: - status = Status::ERROR; - ZLOGE("LessThanOrEqualTo failed: %{public}d", status); - break; + std::string field; + int status = oper.para1.GetString(field); + if (status != E_OK) { + ZLOGE("GetString failed: %{public}d", status); + return Status::ERROR; } - return status; + LessOrEqual lessOrEqual(&query); + CovUtil::FillField(field, oper.para2.value, lessOrEqual); + return Status::SUCCESS; } Status KvStorePredicates::And(const OperationItem &oper, DataQuery &query) @@ -407,71 +218,29 @@ Status KvStorePredicates::IsNotNull(const OperationItem &oper, DataQuery &query) } Status KvStorePredicates::In(const OperationItem &oper, DataQuery &query) -{ - Context context; - Status status = GetContext(oper, context); - if (status != Status::SUCCESS) { - ZLOGE("In GetContext called failed: %{public}d", status); - return status; - } - - switch (context.innerType) { - case DataSharePredicatesObjectType::TYPE_INT_VECTOR: { - query.In(context.field, context.intList); - break; - } - case DataSharePredicatesObjectType::TYPE_LONG_VECTOR: { - query.In(context.field, context.longList); - break; - } - case DataSharePredicatesObjectType::TYPE_DOUBLE_VECTOR: { - query.In(context.field, context.doubleList); - break; - } - case DataSharePredicatesObjectType::TYPE_STRING_VECTOR: { - query.In(context.field, context.stringList); - break; - } - default: - status = Status::ERROR; - ZLOGE("In failed: %{public}d", status); - break; +{ + std::string field; + int status = oper.para1.GetString(field); + if (status != E_OK) { + ZLOGE("GetString failed: %{public}d", status); + return Status::ERROR; } - return status; + DistributedKv::In in(&query); + CovUtil::FillField(field, oper.para2.value, in); + return Status::SUCCESS; } Status KvStorePredicates::NotIn(const OperationItem &oper, DataQuery &query) { - Context context; - Status status = GetContext(oper, context); - if (status != Status::SUCCESS) { - ZLOGE("NotIn GetContext called failed: %{public}d", status); - return status; - } - - switch (context.innerType) { - case DataSharePredicatesObjectType::TYPE_INT_VECTOR: { - query.NotIn(context.field, context.intList); - break; - } - case DataSharePredicatesObjectType::TYPE_LONG_VECTOR: { - query.NotIn(context.field, context.longList); - break; - } - case DataSharePredicatesObjectType::TYPE_DOUBLE_VECTOR: { - query.NotIn(context.field, context.doubleList); - break; - } - case DataSharePredicatesObjectType::TYPE_STRING_VECTOR: { - query.NotIn(context.field, context.stringList); - break; - } - default: - status = Status::ERROR; - ZLOGE("NotIn failed: %{public}d", status); - break; + std::string field; + int status = oper.para1.GetString(field); + if (status != E_OK) { + ZLOGE("GetString failed: %{public}d", status); + return Status::ERROR; } - return status; + DistributedKv::NotIn notIn(&query); + CovUtil::FillField(field, oper.para2.value, notIn); + return Status::SUCCESS; } Status KvStorePredicates::Like(const OperationItem &oper, DataQuery &query) diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_values_bucket.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_values_bucket.cpp deleted file mode 100644 index 322715d31..000000000 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_values_bucket.cpp +++ /dev/null @@ -1,79 +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. - */ - -#define LOG_TAG "KvStoreValuesBucket" - -#include "log_print.h" -#include "kvstore_values_bucket.h" - -namespace OHOS { -namespace DistributedKv { -using namespace DataShare; - -std::vector KvStoreValuesBucket::ToEntry(const std::vector &valueBuckets) -{ - std::vector entries; - for (const auto &val : valueBuckets) { - Entry entry = ToEntry(val); - entries.push_back(entry); - } - return entries; -} - -Entry KvStoreValuesBucket::ToEntry(const DataShareValuesBucket &valueBucket) -{ - std::map valuesMap; - valueBucket.GetAll(valuesMap); - if (valuesMap.empty()) { - ZLOGE("valuesMap is null"); - return {}; - } - Entry entry; - Status status = ToEntryData(valuesMap, KEY, entry.key); - if (status != Status::SUCCESS) { - ZLOGE("GetEntry key failed: %{public}d", status); - return {}; - } - status = ToEntryData(valuesMap, VALUE, entry.value); - if (status != Status::SUCCESS) { - ZLOGE("GetEntry value failed: %{public}d", status); - return {}; - } - return entry; -} - -Status KvStoreValuesBucket::ToEntryData(const std::map &valuesMap, const std::string field, Blob &kv) -{ - auto it = valuesMap.find(field); - if (it == valuesMap.end()) { - ZLOGE("field is not find!"); - 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 data; - int status = it->second.GetBlob(data); - if (status != Status::SUCCESS) { - ZLOGE("GetBlob failed: %{public}d", status); - return Status::ERROR; - } - kv = data; - return Status::SUCCESS; -} -} // namespace DistributedKv -} // namespace OHOS \ No newline at end of file diff --git a/frameworks/jskitsimpl/distributeddata/include/js_util.h b/frameworks/jskitsimpl/distributeddata/include/js_util.h index 71313b72e..b1b5f3bd9 100644 --- a/frameworks/jskitsimpl/distributeddata/include/js_util.h +++ b/frameworks/jskitsimpl/distributeddata/include/js_util.h @@ -140,7 +140,7 @@ 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 &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::DataShareValuesBucket &out); static napi_status GetValue(napi_env env, napi_value in, DataShare::DataSharePredicates &out); /* napi_get_named_property wrapper */ diff --git a/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp b/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp index 935ae1ea8..a5407ed9b 100644 --- a/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp +++ b/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp @@ -140,22 +140,22 @@ napi_value JsKVStore::Put(napi_env env, napi_callback_info info) }); auto execute = [ctxt]() { - Status status = Status::ERROR; - if (ctxt->type == napi_object) { - auto& kvStore = reinterpret_cast(ctxt->native)->kvStore_; - ctxt->entries = KvUtils::ToEntries(ctxt->valueBuckets); - ZLOGD("kvStoreDataShare->ToEntry return"); - status = kvStore->PutBatch(ctxt->entries); - CHECK_STATUS_RETURN_VOID(ctxt, "kvStoreDataShare->Put, i.e. Put error!"); - } else if (ctxt->type == napi_string) { + if (ctxt->type == napi_string) { OHOS::DistributedKv::Key key(ctxt->key); OHOS::DistributedKv::Value value(ctxt->value); auto& kvStore = reinterpret_cast(ctxt->native)->kvStore_; - status = kvStore->Put(key, value); + 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(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!"); } - 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); } @@ -194,23 +194,24 @@ napi_value JsKVStore::Delete(napi_env env, napi_callback_info info) }); return NapiQueue::AsyncWork(env, ctxt, std::string(__FUNCTION__), [ctxt]() { - Status status = Status::ERROR; - if (ctxt->type == napi_object) { + if (ctxt->type == napi_string) { + OHOS::DistributedKv::Key key(ctxt->key); + auto& kvStore = reinterpret_cast(ctxt->native)->kvStore_; + Status status = kvStore->Delete(key); + ZLOGD("kvStore->Put return %{public}d", status); + 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 keys; auto kvPredicates = std::make_shared(); - status = kvPredicates->GetKeys(ctxt->predicates, keys); + 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(ctxt->native)->kvStore_; status = kvStore->DeleteBatch(keys); ZLOGD("kv Datashare Delete return %{public}d", status); - } else if (ctxt->type == napi_string) { - OHOS::DistributedKv::Key key(ctxt->key); - auto& kvStore = reinterpret_cast(ctxt->native)->kvStore_; - status = kvStore->Delete(key); } - ZLOGD("kvStore->Delete return %{public}d", status); - ctxt->status = (status == Status::SUCCESS) ? napi_ok : napi_generic_failure; - CHECK_STATUS_RETURN_VOID(ctxt, "kvStore->Delete() failed!"); }); } diff --git a/frameworks/jskitsimpl/distributeddata/src/js_util.cpp b/frameworks/jskitsimpl/distributeddata/src/js_util.cpp index 09d1ffef9..1fe6380be 100644 --- a/frameworks/jskitsimpl/distributeddata/src/js_util.cpp +++ b/frameworks/jskitsimpl/distributeddata/src/js_util.cpp @@ -1025,7 +1025,7 @@ napi_status JSUtil::GetValue(napi_env env, napi_value in, std::vector 0), "get_array failed!", napi_invalid_arg); for (uint32_t i = 0; i < length; ++i) { - ZLOGD("length is 0000000000000000%{public}d: ",length); + 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); @@ -1037,7 +1037,7 @@ napi_status JSUtil::GetValue(napi_env env, napi_value in, std::vector ToEntries(const std::vector &valueBuckets); private: - KvUtils() = delete; KvUtils(KvUtils &&) = delete; KvUtils(const KvUtils &) = delete; KvUtils &operator=(KvUtils &&) = delete; KvUtils &operator=(const KvUtils &) = delete; ~KvUtils() = delete; + static Status ToEntryData(const std::map &valuesMap, const std::string field, Blob &kv); + static const std::string KEY; + static const std::string VALUE; }; } // namespace DistributedKv } // namespace OHOS -- Gitee From 3ab72fa6a8dfca8fa136a504c86335da8bc9a253 Mon Sep 17 00:00:00 2001 From: anan Date: Fri, 20 May 2022 18:39:43 +0800 Subject: [PATCH 06/20] =?UTF-8?q?=E5=88=A0=E9=99=A4set?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: anan --- .vscode/settings.json | 70 ------------------------------------------- 1 file changed, 70 deletions(-) delete mode 100644 .vscode/settings.json diff --git a/.vscode/settings.json b/.vscode/settings.json deleted file mode 100644 index 8e91f220c..000000000 --- a/.vscode/settings.json +++ /dev/null @@ -1,70 +0,0 @@ -{ - "files.associations": { - "any": "cpp", - "array": "cpp", - "atomic": "cpp", - "bit": "cpp", - "*.tcc": "cpp", - "bitset": "cpp", - "cctype": "cpp", - "chrono": "cpp", - "cinttypes": "cpp", - "clocale": "cpp", - "cmath": "cpp", - "codecvt": "cpp", - "compare": "cpp", - "concepts": "cpp", - "condition_variable": "cpp", - "cstdarg": "cpp", - "cstddef": "cpp", - "cstdint": "cpp", - "cstdio": "cpp", - "cstdlib": "cpp", - "cstring": "cpp", - "ctime": "cpp", - "cwchar": "cpp", - "cwctype": "cpp", - "deque": "cpp", - "list": "cpp", - "map": "cpp", - "set": "cpp", - "string": "cpp", - "unordered_map": "cpp", - "vector": "cpp", - "exception": "cpp", - "algorithm": "cpp", - "functional": "cpp", - "iterator": "cpp", - "memory": "cpp", - "memory_resource": "cpp", - "numeric": "cpp", - "random": "cpp", - "ratio": "cpp", - "regex": "cpp", - "string_view": "cpp", - "system_error": "cpp", - "tuple": "cpp", - "type_traits": "cpp", - "utility": "cpp", - "fstream": "cpp", - "initializer_list": "cpp", - "iomanip": "cpp", - "iosfwd": "cpp", - "iostream": "cpp", - "istream": "cpp", - "limits": "cpp", - "mutex": "cpp", - "new": "cpp", - "numbers": "cpp", - "ostream": "cpp", - "semaphore": "cpp", - "shared_mutex": "cpp", - "sstream": "cpp", - "stdexcept": "cpp", - "stop_token": "cpp", - "streambuf": "cpp", - "thread": "cpp", - "typeinfo": "cpp", - "variant": "cpp" - } -} \ No newline at end of file -- Gitee From 3fc43d02bda6f3e8c4f03a1d3dc64515cf8aa606 Mon Sep 17 00:00:00 2001 From: anan Date: Sat, 21 May 2022 09:19:57 +0800 Subject: [PATCH 07/20] =?UTF-8?q?=E4=BF=AE=E6=94=B9result=5Fset?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: anan --- .../distributeddatafwk/src/kvstore_datashare_result_set.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp index 17995c751..e7c1ee6ea 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp @@ -58,12 +58,12 @@ bool KvStoreDataShareResultSet::FillBlock(int pos, ResultSetBridge::Writer &writ ZLOGE("SharedBlock is full: %{public}d", statusAlloc); return false; } - int keyStatus = writer.Write(0, &entry.key.Data(), entry.key.Size()); + int keyStatus = writer.Write(0, (uint8_t *)&entry.key.Data(), entry.key.Size()); if (keyStatus != E_OK) { ZLOGE("WriteBlob key error: %{public}d", keyStatus); return false; } - int valueStatus = writer.Write(1, &entry.value.Data(), entry.value.Size()); + int valueStatus = writer.Write(1, (uint8_t *)&entry.value.Data(), entry.value.Size()); if (valueStatus != E_OK) { ZLOGE("WriteBlob value error: %{public}d", valueStatus); return false; @@ -94,7 +94,7 @@ bool KvStoreDataShareResultSet::OnGo(int32_t start, int32_t target, ResultSetBri ZLOGE("nowRowIndex out of line: %{public}d", target); return false; } - for (int pos = 0; pos < target; pos++) { + for (int pos = start; pos <= target; pos++) { bool ret = FillBlock(pos + start, writer); if (!ret) { ZLOGE("nowRowIndex out of line: %{public}d", target); -- Gitee From 8ffc79d98653244de76bd608ff34c75ec271aef7 Mon Sep 17 00:00:00 2001 From: anan Date: Sat, 21 May 2022 10:30:16 +0800 Subject: [PATCH 08/20] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E6=A0=BC=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: anan --- .../distributeddatafwk/src/kv_utils.cpp | 5 +++-- .../src/kvstore_datashare_result_set.cpp | 6 +++--- .../src/kvstore_predicates.cpp | 18 +++++++----------- .../include/js_kv_store_resultset.h | 2 +- .../distributeddata/src/js_kv_store.cpp | 4 ++-- .../src/js_kv_store_resultset.cpp | 4 ++-- .../distributeddata/src/js_single_kv_store.cpp | 4 +--- .../jskitsimpl/distributeddata/src/js_util.cpp | 2 +- .../distributeddata/include/kv_utils.h | 3 ++- interfaces/jskits/distributeddata/BUILD.gn | 2 +- 10 files changed, 23 insertions(+), 27 deletions(-) diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp index 4ac8ae56c..38f130434 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp @@ -79,7 +79,8 @@ Entry KvUtils::ToEntry(const DataShareValuesBucket &valueBucket) return entry; } -Status KvUtils::ToEntryData(const std::map &valuesMap, const std::string field, Blob &kv) +Status KvUtils::ToEntryData(const std::map &valuesMap, + const std::string field, Blob &kv) { auto it = valuesMap.find(field); if (it == valuesMap.end()) { @@ -92,7 +93,7 @@ Status KvUtils::ToEntryData(const std::map &v return Status::ERROR; } std::vector data; - int status = it->second.GetBlob(data); + int status = it->second.GetBlob(data); if (status != Status::SUCCESS) { ZLOGE("GetBlob failed: %{public}d", status); return Status::ERROR; diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp index e7c1ee6ea..708958a3a 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp @@ -58,8 +58,8 @@ 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, (uint8_t *)&entry.key.Data(), entry.key.Size()); + if (keyStatus != E_OK) { ZLOGE("WriteBlob key error: %{public}d", keyStatus); return false; } @@ -88,7 +88,7 @@ int KvStoreDataShareResultSet::Count() resultRowCount = count; return count; } -bool KvStoreDataShareResultSet::OnGo(int32_t start, int32_t target, ResultSetBridge::Writer &writer) +bool KvStoreDataShareResultSet::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/kvstore_predicates.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp index 45e4d7911..58f2e1cac 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp @@ -16,9 +16,9 @@ #define LOG_TAG "KvStorePredicates" #include "cov_util.h" -#include "kvstore_predicates.h" #include "log_print.h" #include "datashare_errno.h" +#include "kvstore_predicates.h" namespace OHOS { namespace DistributedKv { @@ -56,8 +56,7 @@ Status KvStorePredicates::GetKeys(const DataSharePredicates &predicates, std::ve } std::vector myKeys; - for(const auto &oper : operationList) - { + for(const auto &oper : operationList) { if (oper.operation != IN_KEY) { ZLOGE("find operation failed"); return Status::NOT_SUPPORT; @@ -70,11 +69,10 @@ Status KvStorePredicates::GetKeys(const DataSharePredicates &predicates, std::ve } myKeys.insert(myKeys.end(), val.begin(), val.end()); } - for (const auto &it : myKeys) - { + for (const auto &it : myKeys) { keys.push_back(it.c_str()); } - return Status::SUCCESS; + return Status::SUCCESS; } Status KvStorePredicates::InKeys(const OperationItem &oper, DataQuery &query) @@ -103,7 +101,6 @@ Status KvStorePredicates::KeyPrefix(const OperationItem &oper, DataQuery &query) Status KvStorePredicates::EqualTo(const OperationItem &oper, DataQuery &query) { - std::string field; int status = oper.para1.GetString(field); if (status != E_OK) { @@ -117,7 +114,6 @@ Status KvStorePredicates::EqualTo(const OperationItem &oper, DataQuery &query) Status KvStorePredicates::NotEqualTo(const OperationItem &oper, DataQuery &query) { - std::string field; int status = oper.para1.GetString(field); if (status != E_OK) { @@ -143,7 +139,7 @@ Status KvStorePredicates::GreaterThan(const OperationItem &oper, DataQuery &quer } Status KvStorePredicates::LessThan(const OperationItem &oper, DataQuery &query) -{ +{ std::string field; int status = oper.para1.GetString(field); if (status != E_OK) { @@ -156,7 +152,7 @@ Status KvStorePredicates::LessThan(const OperationItem &oper, DataQuery &query) } Status KvStorePredicates::GreaterThanOrEqualTo(const OperationItem &oper, DataQuery &query) -{ +{ std::string field; int status = oper.para1.GetString(field); if (status != E_OK) { @@ -218,7 +214,7 @@ Status KvStorePredicates::IsNotNull(const OperationItem &oper, DataQuery &query) } Status KvStorePredicates::In(const OperationItem &oper, DataQuery &query) -{ +{ std::string field; int status = oper.para1.GetString(field); if (status != E_OK) { diff --git a/frameworks/jskitsimpl/distributeddata/include/js_kv_store_resultset.h b/frameworks/jskitsimpl/distributeddata/include/js_kv_store_resultset.h index 2589a4ec6..9b8406386 100644 --- a/frameworks/jskitsimpl/distributeddata/include/js_kv_store_resultset.h +++ b/frameworks/jskitsimpl/distributeddata/include/js_kv_store_resultset.h @@ -20,7 +20,7 @@ #include "kvstore_result_set.h" namespace OHOS::DistributedData { -class JsKVStoreResultSet :public DataShare::ResultSetBridge::Creator { +class JsKVStoreResultSet : public DataShare::ResultSetBridge::Creator { public: JsKVStoreResultSet() = default; virtual ~JsKVStoreResultSet() = default; diff --git a/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp b/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp index a5407ed9b..7f5145f70 100644 --- a/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp +++ b/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp @@ -122,7 +122,7 @@ napi_value JsKVStore::Put(napi_env env, napi_callback_info info) ctxt->GetCbInfo(env, info, [env, ctxt](size_t argc, napi_value* argv) { // required 2 arguments :: - CHECK_ARGS_RETURN_VOID(ctxt, (argc == 1 | argc == 2), "invalid arguments!"); + 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) { @@ -182,7 +182,7 @@ napi_value JsKVStore::Delete(napi_env env, napi_callback_info info) CHECK_ARGS_RETURN_VOID(ctxt, argc == 1, "invalid arguments!"); ctxt->type = napi_undefined; ctxt->status = napi_typeof(env, argv[0], &(ctxt->type)); - if (ctxt->type == napi_string) { + if (ctxt->type == napi_string) { ctxt->status = JSUtil::GetValue(env, argv[0], ctxt->key); ZLOGD("kvStore->Put return %{public}d", ctxt->status); CHECK_STATUS_RETURN_VOID(ctxt, "invalid arg[0], i.e. invalid key!"); diff --git a/frameworks/jskitsimpl/distributeddata/src/js_kv_store_resultset.cpp b/frameworks/jskitsimpl/distributeddata/src/js_kv_store_resultset.cpp index f63d36cb2..994a3b76d 100644 --- a/frameworks/jskitsimpl/distributeddata/src/js_kv_store_resultset.cpp +++ b/frameworks/jskitsimpl/distributeddata/src/js_kv_store_resultset.cpp @@ -278,5 +278,5 @@ napi_value JsKVStoreResultSet::GetEntry(napi_env env, napi_callback_info info) / std::shared_ptr JsKVStoreResultSet::Create() { return KvUtils::ToResultSetBridge(resultSet_); -} -}// namespace OHOS::DistributedData +} +} // namespace OHOS::DistributedData diff --git a/frameworks/jskitsimpl/distributeddata/src/js_single_kv_store.cpp b/frameworks/jskitsimpl/distributeddata/src/js_single_kv_store.cpp index a7c3f0542..f82712551 100644 --- a/frameworks/jskitsimpl/distributeddata/src/js_single_kv_store.cpp +++ b/frameworks/jskitsimpl/distributeddata/src/js_single_kv_store.cpp @@ -139,9 +139,7 @@ static napi_status GetVariantArgs(napi_env env, size_t argc, napi_value* argv, V status = JSUtil::GetValue(env, argv[0], va.predicates); va.type = ArgsType::PREDICATES; ZLOGD("kvStoreDataShare->GetResultSet return %{public}d", status); - CHECK_RETURN(true, "invalid arg[0], i.e. invalid predicates!", napi_invalid_arg); - // CHECK_RETURN(va.predicates, "invalid arg[0], i.e. invalid predicates!", napi_invalid_arg); - } + } } return status; }; diff --git a/frameworks/jskitsimpl/distributeddata/src/js_util.cpp b/frameworks/jskitsimpl/distributeddata/src/js_util.cpp index 1fe6380be..0c7a975b7 100644 --- a/frameworks/jskitsimpl/distributeddata/src/js_util.cpp +++ b/frameworks/jskitsimpl/distributeddata/src/js_util.cpp @@ -1025,7 +1025,7 @@ napi_status JSUtil::GetValue(napi_env env, napi_value in, std::vector 0), "get_array failed!", napi_invalid_arg); for (uint32_t i = 0; i < length; ++i) { - ZLOGD("length is %{public}d: ",length); + 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); diff --git a/interfaces/innerkits/distributeddata/include/kv_utils.h b/interfaces/innerkits/distributeddata/include/kv_utils.h index 223acde7f..1d606576d 100644 --- a/interfaces/innerkits/distributeddata/include/kv_utils.h +++ b/interfaces/innerkits/distributeddata/include/kv_utils.h @@ -37,7 +37,8 @@ private: KvUtils &operator=(KvUtils &&) = delete; KvUtils &operator=(const KvUtils &) = delete; ~KvUtils() = delete; - static Status ToEntryData(const std::map &valuesMap, const std::string field, Blob &kv); + static Status ToEntryData(const std::map &valuesMap, const std::string field, Blob &kv); static const std::string KEY; static const std::string VALUE; }; diff --git a/interfaces/jskits/distributeddata/BUILD.gn b/interfaces/jskits/distributeddata/BUILD.gn index 750128dd3..a4b95e153 100644 --- a/interfaces/jskits/distributeddata/BUILD.gn +++ b/interfaces/jskits/distributeddata/BUILD.gn @@ -40,9 +40,9 @@ ohos_shared_library("distributeddata") { "//utils/native/base/include", "//foundation/distributeddatamgr/distributeddatamgr/interfaces/innerkits/distributeddata/include", "//foundation/distributeddatamgr/distributeddatamgr/frameworks/jskitsimpl/distributeddata/include", + "//foundation/distributeddatamgr/distributeddatamgr/frameworks/innerkitsimpl/distributeddatafwk/include", "//foundation/distributeddatamgr/distributeddatamgr/services/distributeddataservice/adapter/include/log", "//foundation/distributeddatamgr/distributeddatamgr/services/distributeddataservice/adapter/include/autils", - "//foundation/distributeddatamgr/distributeddatamgr/services/distributeddataservice/adapter/include/autils", "//foundation/distributeddatamgr/appdatamgr/interfaces/inner_api/native/data_share/provider/include", "//foundation/distributeddatamgr/appdatamgr/interfaces/inner_api/native/data_share/common/include", "//foundation/distributeddatamgr/appdatamgr/frameworks/js/napi/data_share/common/include", -- Gitee From ffc8ad62e733837ff60759bf490b378bf6a27e53 Mon Sep 17 00:00:00 2001 From: anan Date: Sat, 21 May 2022 11:20:02 +0800 Subject: [PATCH 09/20] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E6=A0=BC=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: anan --- frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp | 2 +- .../distributeddatafwk/src/kvstore_datashare_result_set.cpp | 2 +- .../innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp | 2 +- interfaces/innerkits/distributeddata/include/kv_utils.h | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp index 38f130434..19fc4c054 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp @@ -79,7 +79,7 @@ Entry KvUtils::ToEntry(const DataShareValuesBucket &valueBucket) return entry; } -Status KvUtils::ToEntryData(const std::map &valuesMap, +Status KvUtils::ToEntryData(const std::map &valuesMap, const std::string field, Blob &kv) { auto it = valuesMap.find(field); diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp index 708958a3a..287209df3 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp @@ -95,7 +95,7 @@ bool KvStoreDataShareResultSet::OnGo(int32_t start, int32_t target, ResultSetBri return false; } for (int pos = start; pos <= target; pos++) { - bool ret = FillBlock(pos + start, writer); + bool ret = FillBlock(pos, writer); if (!ret) { ZLOGE("nowRowIndex out of line: %{public}d", target); return ret; diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp index 58f2e1cac..acde88729 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp @@ -56,7 +56,7 @@ Status KvStorePredicates::GetKeys(const DataSharePredicates &predicates, std::ve } std::vector myKeys; - for(const auto &oper : operationList) { + for (const auto &oper : operationList) { if (oper.operation != IN_KEY) { ZLOGE("find operation failed"); return Status::NOT_SUPPORT; diff --git a/interfaces/innerkits/distributeddata/include/kv_utils.h b/interfaces/innerkits/distributeddata/include/kv_utils.h index 1d606576d..5ce1fe458 100644 --- a/interfaces/innerkits/distributeddata/include/kv_utils.h +++ b/interfaces/innerkits/distributeddata/include/kv_utils.h @@ -37,7 +37,7 @@ private: KvUtils &operator=(KvUtils &&) = delete; KvUtils &operator=(const KvUtils &) = delete; ~KvUtils() = delete; - static Status ToEntryData(const std::map &valuesMap, const std::string field, Blob &kv); static const std::string KEY; static const std::string VALUE; -- Gitee From c58f36e3afc11239d33c52f34e45998cc1366458 Mon Sep 17 00:00:00 2001 From: anan Date: Sat, 21 May 2022 18:23:51 +0800 Subject: [PATCH 10/20] =?UTF-8?q?=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: anan --- .../distributeddatafwk/include/cov_util.h | 138 +++--------------- .../src/kvstore_predicates.cpp | 37 +++-- 2 files changed, 41 insertions(+), 134 deletions(-) diff --git a/frameworks/innerkitsimpl/distributeddatafwk/include/cov_util.h b/frameworks/innerkitsimpl/distributeddatafwk/include/cov_util.h index 39ee7d8ea..9876c1379 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/include/cov_util.h +++ b/frameworks/innerkitsimpl/distributeddatafwk/include/cov_util.h @@ -47,108 +47,37 @@ public: } }; -class Equal { -public: - Equal(OHOS::DistributedKv::DataQuery *dataQuery) : dataQuery_(dataQuery) {}; - template - int operator()(const std::string &field, const T &value) - { - dataQuery_->EqualTo(field, value); - return 0; - } - - template - int operator()(const std::string &field, const std::vector &value) - { - return 0; - } - - int operator()() - { - return 0; - } -private: - OHOS::DistributedKv::DataQuery *dataQuery_; -}; - -class NotEqual { -public: - NotEqual(OHOS::DistributedKv::DataQuery *dataQuery) : dataQuery_(dataQuery) {}; - template - int operator()(const std::string &field, const T &value) - { - dataQuery_->NotEqualTo(field, value); - return 0; - } - template - int operator()(const std::string &field, const std::vector &value) - { - return 0; - } - - int operator()() - { - return 0; - } -private: - OHOS::DistributedKv::DataQuery *dataQuery_; -}; - -class Greater { -public: - Greater(OHOS::DistributedKv::DataQuery *dataQuery) : dataQuery_(dataQuery) {}; - template - int operator()(const std::string &field, const T &value) - { - dataQuery_->GreaterThan(field, value); - return 0; - } - template - int operator()(const std::string &field, const std::vector &value) - { - return 0; - } - - int operator()() - { - return 0; - } -private: - OHOS::DistributedKv::DataQuery *dataQuery_; +enum class QueryType { + EQUAL = 0, + NOT_EQUAL = 1, + GREATER = 2, + LESS = 3, + GREATER_OR_EQUAL = 4, + LESS_OR_EQUAL = 5, }; -class Less { +class Querys { public: - Less(OHOS::DistributedKv::DataQuery *dataQuery) : dataQuery_(dataQuery) {}; + Querys(OHOS::DistributedKv::DataQuery *dataQuery, QueryType type) : dataQuery_(dataQuery), type_(type) {}; template int operator()(const std::string &field, const T &value) { - dataQuery_->LessThan(field, value); - return 0; - } - template - int operator()(const std::string &field, const std::vector &value) - { - return 0; - } - - int operator()() - { + 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; } -private: - OHOS::DistributedKv::DataQuery *dataQuery_; -}; -class GreaterOrEqual { -public: - GreaterOrEqual(OHOS::DistributedKv::DataQuery *dataQuery) : dataQuery_(dataQuery) {}; - template - int operator()(const std::string &field, const T &value) - { - dataQuery_->GreaterThanOrEqualTo(field, value); - return 0; - } template int operator()(const std::string &field, const std::vector &value) { @@ -159,31 +88,10 @@ public: { return 0; } -private: - OHOS::DistributedKv::DataQuery *dataQuery_; -}; - -class LessOrEqual { -public: - LessOrEqual(OHOS::DistributedKv::DataQuery *dataQuery) : dataQuery_(dataQuery) {}; - template - int operator()(const std::string &field, const T &value) - { - dataQuery_->LessThanOrEqualTo(field, value); - return 0; - } - template - int operator()(const std::string &field, const std::vector &value) - { - return 0; - } - int operator()() - { - return 0; - } private: OHOS::DistributedKv::DataQuery *dataQuery_; + QueryType type_; }; class In { diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp index acde88729..c328ddf21 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp @@ -16,9 +16,9 @@ #define LOG_TAG "KvStorePredicates" #include "cov_util.h" +#include "kvstore_predicates.h" #include "log_print.h" #include "datashare_errno.h" -#include "kvstore_predicates.h" namespace OHOS { namespace DistributedKv { @@ -27,12 +27,7 @@ constexpr KvStorePredicates::QueryHandler KvStorePredicates::HANDLERS[LAST_TYPE] Status KvStorePredicates::ToQuery(const DataSharePredicates &predicates, DataQuery &query) { - std::list operationList = predicates.GetOperationList(); - if (operationList.empty()) { - ZLOGE("ToQuery operationList is null"); - return Status::INVALID_ARGUMENT; - } - + std::list operationList = predicates.GetOperationList(); for (const auto &oper : operationList) { if (oper.operation < 0 || oper.operation >= LAST_TYPE) { ZLOGE("operation param error"); @@ -56,7 +51,8 @@ Status KvStorePredicates::GetKeys(const DataSharePredicates &predicates, std::ve } std::vector myKeys; - for (const auto &oper : operationList) { + for(const auto &oper : operationList) + { if (oper.operation != IN_KEY) { ZLOGE("find operation failed"); return Status::NOT_SUPPORT; @@ -69,10 +65,11 @@ Status KvStorePredicates::GetKeys(const DataSharePredicates &predicates, std::ve } myKeys.insert(myKeys.end(), val.begin(), val.end()); } - for (const auto &it : myKeys) { + for (const auto &it : myKeys) + { keys.push_back(it.c_str()); } - return Status::SUCCESS; + return Status::SUCCESS; } Status KvStorePredicates::InKeys(const OperationItem &oper, DataQuery &query) @@ -101,26 +98,28 @@ Status KvStorePredicates::KeyPrefix(const OperationItem &oper, DataQuery &query) Status KvStorePredicates::EqualTo(const OperationItem &oper, DataQuery &query) { + std::string field; int status = oper.para1.GetString(field); if (status != E_OK) { ZLOGE("GetString failed: %{public}d", status); return Status::ERROR; } - Equal equal(&query); + Querys equal(&query, QueryType::EQUAL); CovUtil::FillField(field, oper.para2.value, equal); return Status::SUCCESS; } Status KvStorePredicates::NotEqualTo(const OperationItem &oper, DataQuery &query) { + std::string field; int status = oper.para1.GetString(field); if (status != E_OK) { ZLOGE("GetString failed: %{public}d", status); return Status::ERROR; } - NotEqual notEqual(&query); + Querys notEqual(&query, QueryType::NOT_EQUAL); CovUtil::FillField(field, oper.para2.value, notEqual); return Status::SUCCESS; } @@ -133,33 +132,33 @@ Status KvStorePredicates::GreaterThan(const OperationItem &oper, DataQuery &quer ZLOGE("GetString failed: %{public}d", status); return Status::ERROR; } - Greater greater(&query); + Querys greater(&query, QueryType::GREATER); CovUtil::FillField(field, oper.para2.value, greater); return Status::SUCCESS; } Status KvStorePredicates::LessThan(const OperationItem &oper, DataQuery &query) -{ +{ std::string field; int status = oper.para1.GetString(field); if (status != E_OK) { ZLOGE("GetString failed: %{public}d", status); return Status::ERROR; } - Less less(&query); + Querys less(&query, QueryType::LESS); CovUtil::FillField(field, oper.para2.value, less); return Status::SUCCESS; } Status KvStorePredicates::GreaterThanOrEqualTo(const OperationItem &oper, DataQuery &query) -{ +{ std::string field; int status = oper.para1.GetString(field); if (status != E_OK) { ZLOGE("GetString failed: %{public}d", status); return Status::ERROR; } - GreaterOrEqual greaterOrEqual(&query); + Querys greaterOrEqual(&query, QueryType::GREATER_OR_EQUAL); CovUtil::FillField(field, oper.para2.value, greaterOrEqual); return Status::SUCCESS; } @@ -172,7 +171,7 @@ Status KvStorePredicates::LessThanOrEqualTo(const OperationItem &oper, DataQuery ZLOGE("GetString failed: %{public}d", status); return Status::ERROR; } - LessOrEqual lessOrEqual(&query); + Querys lessOrEqual(&query, QueryType::LESS_OR_EQUAL); CovUtil::FillField(field, oper.para2.value, lessOrEqual); return Status::SUCCESS; } @@ -214,7 +213,7 @@ Status KvStorePredicates::IsNotNull(const OperationItem &oper, DataQuery &query) } Status KvStorePredicates::In(const OperationItem &oper, DataQuery &query) -{ +{ std::string field; int status = oper.para1.GetString(field); if (status != E_OK) { -- Gitee From c1ce8d82874514ececb834ed4ec463e0aafcde3f Mon Sep 17 00:00:00 2001 From: anan Date: Sat, 21 May 2022 18:55:17 +0800 Subject: [PATCH 11/20] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E6=A0=BC=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: anan --- .../src/kvstore_predicates.cpp | 20 ++++++++----------- 1 file changed, 8 insertions(+), 12 deletions(-) diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp index c328ddf21..cf5553d40 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp @@ -16,9 +16,9 @@ #define LOG_TAG "KvStorePredicates" #include "cov_util.h" -#include "kvstore_predicates.h" #include "log_print.h" #include "datashare_errno.h" +#include "kvstore_predicates.h" namespace OHOS { namespace DistributedKv { @@ -27,7 +27,7 @@ constexpr KvStorePredicates::QueryHandler KvStorePredicates::HANDLERS[LAST_TYPE] Status KvStorePredicates::ToQuery(const DataSharePredicates &predicates, DataQuery &query) { - std::list operationList = predicates.GetOperationList(); + std::list operationList = predicates.GetOperationList(); for (const auto &oper : operationList) { if (oper.operation < 0 || oper.operation >= LAST_TYPE) { ZLOGE("operation param error"); @@ -51,8 +51,7 @@ Status KvStorePredicates::GetKeys(const DataSharePredicates &predicates, std::ve } std::vector myKeys; - for(const auto &oper : operationList) - { + for (const auto &oper : operationList) { if (oper.operation != IN_KEY) { ZLOGE("find operation failed"); return Status::NOT_SUPPORT; @@ -65,11 +64,10 @@ Status KvStorePredicates::GetKeys(const DataSharePredicates &predicates, std::ve } myKeys.insert(myKeys.end(), val.begin(), val.end()); } - for (const auto &it : myKeys) - { + for (const auto &it : myKeys) { keys.push_back(it.c_str()); } - return Status::SUCCESS; + return Status::SUCCESS; } Status KvStorePredicates::InKeys(const OperationItem &oper, DataQuery &query) @@ -98,7 +96,6 @@ Status KvStorePredicates::KeyPrefix(const OperationItem &oper, DataQuery &query) Status KvStorePredicates::EqualTo(const OperationItem &oper, DataQuery &query) { - std::string field; int status = oper.para1.GetString(field); if (status != E_OK) { @@ -112,7 +109,6 @@ Status KvStorePredicates::EqualTo(const OperationItem &oper, DataQuery &query) Status KvStorePredicates::NotEqualTo(const OperationItem &oper, DataQuery &query) { - std::string field; int status = oper.para1.GetString(field); if (status != E_OK) { @@ -138,7 +134,7 @@ Status KvStorePredicates::GreaterThan(const OperationItem &oper, DataQuery &quer } Status KvStorePredicates::LessThan(const OperationItem &oper, DataQuery &query) -{ +{ std::string field; int status = oper.para1.GetString(field); if (status != E_OK) { @@ -151,7 +147,7 @@ Status KvStorePredicates::LessThan(const OperationItem &oper, DataQuery &query) } Status KvStorePredicates::GreaterThanOrEqualTo(const OperationItem &oper, DataQuery &query) -{ +{ std::string field; int status = oper.para1.GetString(field); if (status != E_OK) { @@ -213,7 +209,7 @@ Status KvStorePredicates::IsNotNull(const OperationItem &oper, DataQuery &query) } Status KvStorePredicates::In(const OperationItem &oper, DataQuery &query) -{ +{ std::string field; int status = oper.para1.GetString(field); if (status != E_OK) { -- Gitee From 3caec0c2930e26b0f9d7fe5e2888d51db28c9e94 Mon Sep 17 00:00:00 2001 From: anan Date: Sat, 21 May 2022 19:01:21 +0800 Subject: [PATCH 12/20] update Signed-off-by: anan --- .../innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp index cf5553d40..4d23bd5c6 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp @@ -27,7 +27,7 @@ constexpr KvStorePredicates::QueryHandler KvStorePredicates::HANDLERS[LAST_TYPE] Status KvStorePredicates::ToQuery(const DataSharePredicates &predicates, DataQuery &query) { - std::list operationList = predicates.GetOperationList(); + std::list operationList = predicates.GetOperationList(); for (const auto &oper : operationList) { if (oper.operation < 0 || oper.operation >= LAST_TYPE) { ZLOGE("operation param error"); -- Gitee From 3e589b67c7843d7568dea2a88dfbacc01c1eae9e Mon Sep 17 00:00:00 2001 From: anan Date: Mon, 23 May 2022 09:55:46 +0800 Subject: [PATCH 13/20] =?UTF-8?q?=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: anan --- .vscode/settings.json | 7 ++++ .../distributeddatafwk/include/cov_util.h | 35 ++++++------------- .../src/kvstore_datashare_result_set.cpp | 4 +-- .../src/kvstore_predicates.cpp | 4 +-- 4 files changed, 21 insertions(+), 29 deletions(-) create mode 100644 .vscode/settings.json diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 000000000..45203bcc3 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,7 @@ +{ + "files.associations": { + "array": "cpp", + "string": "cpp", + "string_view": "cpp" + } +} \ No newline at end of file diff --git a/frameworks/innerkitsimpl/distributeddatafwk/include/cov_util.h b/frameworks/innerkitsimpl/distributeddatafwk/include/cov_util.h index 9876c1379..2c0ca8fe4 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/include/cov_util.h +++ b/frameworks/innerkitsimpl/distributeddatafwk/include/cov_util.h @@ -54,6 +54,8 @@ enum class QueryType { LESS = 3, GREATER_OR_EQUAL = 4, LESS_OR_EQUAL = 5, + IN = 6, + NOT_IN = 7 }; class Querys { @@ -94,9 +96,9 @@ private: QueryType type_; }; -class In { +class InOrNotIn { public: - In(OHOS::DistributedKv::DataQuery *dataQuery) : dataQuery_(dataQuery) {}; + InOrNotIn(OHOS::DistributedKv::DataQuery *dataQuery, QueryType type) : dataQuery_(dataQuery), type_(type) {}; template int operator()(const std::string &field, const T &value) { @@ -105,7 +107,11 @@ public: template int operator()(const std::string &field, const std::vector &value) { - dataQuery_->In(field, value); + if (type_ == QueryType::IN) { + dataQuery_->In(field, value); + } else if (type_ == QueryType::NOT_IN) { + dataQuery_->NotIn(field, value); + } return 0; } @@ -113,31 +119,10 @@ public: { return 0; } -private: - OHOS::DistributedKv::DataQuery *dataQuery_; -}; -class NotIn { -public: - NotIn(OHOS::DistributedKv::DataQuery *dataQuery) : dataQuery_(dataQuery) {}; - template - int operator()(const std::string &field, const T &value) - { - return 0; - } - template - int operator()(const std::string &field, const std::vector &value) - { - dataQuery_->In(field, value); - return 0; - } - - int operator()() - { - return 0; - } private: OHOS::DistributedKv::DataQuery *dataQuery_; + QueryType type_; }; } } diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp index 287209df3..cee34e336 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp @@ -58,12 +58,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()); + 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; diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp index 4d23bd5c6..a935ec99a 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp @@ -216,7 +216,7 @@ Status KvStorePredicates::In(const OperationItem &oper, DataQuery &query) ZLOGE("GetString failed: %{public}d", status); return Status::ERROR; } - DistributedKv::In in(&query); + InOrNotIn in(&query, QueryType::IN); CovUtil::FillField(field, oper.para2.value, in); return Status::SUCCESS; } @@ -229,7 +229,7 @@ Status KvStorePredicates::NotIn(const OperationItem &oper, DataQuery &query) ZLOGE("GetString failed: %{public}d", status); return Status::ERROR; } - DistributedKv::NotIn notIn(&query); + InOrNotIn notIn(&query, QueryType::NOT_IN); CovUtil::FillField(field, oper.para2.value, notIn); return Status::SUCCESS; } -- Gitee From c7550aaa0b05fa55243265952fcdd8908c6859f5 Mon Sep 17 00:00:00 2001 From: anan Date: Mon, 23 May 2022 10:05:20 +0800 Subject: [PATCH 14/20] =?UTF-8?q?=E5=88=A0=E9=99=A4=E6=96=87=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: anan --- .vscode/settings.json | 7 ------- 1 file changed, 7 deletions(-) delete mode 100644 .vscode/settings.json diff --git a/.vscode/settings.json b/.vscode/settings.json deleted file mode 100644 index 45203bcc3..000000000 --- a/.vscode/settings.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "files.associations": { - "array": "cpp", - "string": "cpp", - "string_view": "cpp" - } -} \ No newline at end of file -- Gitee From 7a4b9451df8aede4549f25fe8f34d811427f1534 Mon Sep 17 00:00:00 2001 From: anan Date: Mon, 23 May 2022 10:05:20 +0800 Subject: [PATCH 15/20] =?UTF-8?q?=E5=88=A0=E9=99=A4=E6=96=87=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: anan -- Gitee From 683fc79938ac7f585d227b17bc08bd169424f3b4 Mon Sep 17 00:00:00 2001 From: anan Date: Tue, 24 May 2022 22:53:49 +0800 Subject: [PATCH 16/20] update Signed-off-by: anan --- .../distributeddatafwk/include/cov_util.h | 1 - ...esult_set.h => kvstore_datashare_bridge.h} | 12 +- .../include/kvstore_predicates.h | 77 ----- .../distributeddatafwk/src/kv_utils.cpp | 154 ++++++++- ...t_set.cpp => kvstore_datashare_bridge.cpp} | 16 +- .../src/kvstore_predicates.cpp | 318 ------------------ .../src/single_kvstore_client.cpp | 13 +- .../distributeddata/include/js_util.h | 9 +- .../src/js_device_kv_store.cpp | 32 +- .../distributeddata/src/js_kv_store.cpp | 26 +- .../src/js_kv_store_resultset.cpp | 2 +- .../src/js_single_kv_store.cpp | 13 +- .../distributeddata/src/js_util.cpp | 60 ++-- interfaces/innerkits/distributeddata/BUILD.gn | 3 +- .../distributeddata/include/kv_utils.h | 43 +++ interfaces/jskits/distributeddata/BUILD.gn | 1 - 16 files changed, 290 insertions(+), 490 deletions(-) rename frameworks/innerkitsimpl/distributeddatafwk/include/{kvstore_datashare_result_set.h => kvstore_datashare_bridge.h} (81%) delete mode 100644 frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_predicates.h rename frameworks/innerkitsimpl/distributeddatafwk/src/{kvstore_datashare_result_set.cpp => kvstore_datashare_bridge.cpp} (83%) delete mode 100644 frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp diff --git a/frameworks/innerkitsimpl/distributeddatafwk/include/cov_util.h b/frameworks/innerkitsimpl/distributeddatafwk/include/cov_util.h index 2c0ca8fe4..d423337d6 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/include/cov_util.h +++ b/frameworks/innerkitsimpl/distributeddatafwk/include/cov_util.h @@ -126,5 +126,4 @@ private: }; } } - #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 81% rename from frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_datashare_result_set.h rename to frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_datashare_bridge.h index f295e758a..b8743a99e 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,11 +23,11 @@ namespace OHOS { namespace DistributedKv { -class KvStoreDataShareResultSet : public DataShare::ResultSetBridge { +class KvStoreDataShareBrige : public DataShare::ResultSetBridge { public: - KvStoreDataShareResultSet(std::shared_ptr kvResultSet); + KvStoreDataShareBrige(std::shared_ptr kvResultSet); - ~KvStoreDataShareResultSet() = default; + ~KvStoreDataShareBrige() = default; int GetRowCount(int32_t &count) override; @@ -48,4 +48,4 @@ private: }; } // 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 dc40e0b2a..000000000 --- a/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_predicates.h +++ /dev/null @@ -1,77 +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 -#include "data_query.h" -#include "types.h" -#include "datashare_predicates.h" - -namespace OHOS { -namespace DistributedKv { -class KvStorePredicates { -public: - KvStorePredicates() = default; - ~KvStorePredicates() = default; - Status ToQuery(const DataShare::DataSharePredicates &predicates, DataQuery &query); - Status GetKeys(const DataShare::DataSharePredicates &predicates, std::vector &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); - 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 OHOS -#endif // KVSTORE_PREDICATE_H \ No newline at end of file diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp index 19fc4c054..07517a6ad 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp @@ -16,35 +16,38 @@ #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; const std::string KvUtils::KEY = "key"; const std::string KvUtils::VALUE = "value"; -std::shared_ptr KvUtils::ToResultSetBridge( - std::shared_ptr resultSet) +constexpr KvUtils::QueryHandler KvUtils::HANDLERS[LAST_TYPE]; + +std::shared_ptr KvUtils::ToResultSetBridge(std::shared_ptr resultSet) { if (resultSet == nullptr) { ZLOGE("param error, kvResultSet nullptr"); return nullptr; } - return std::make_shared(resultSet); + return std::make_shared(resultSet); } Status KvUtils::ToQuery(const DataSharePredicates &predicates, DataQuery &query) { - auto kvPredicates = std::make_shared(); - Status status = kvPredicates->ToQuery(predicates, query); - if (status != Status::SUCCESS) { - ZLOGE("ToQuery failed: %{public}d", status); - return status; + std::list 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 KvUtils::ToEntries(const std::vector &valueBuckets) @@ -79,8 +82,30 @@ Entry KvUtils::ToEntry(const DataShareValuesBucket &valueBucket) return entry; } -Status KvUtils::ToEntryData(const std::map &valuesMap, - const std::string field, Blob &kv) +Status KvUtils::GetKeys(const DataSharePredicates &predicates, std::vector &keys) +{ + std::list operations = predicates.GetOperationList(); + if (operations.empty()) { + ZLOGE("operations is null"); + return Status::ERROR; + } + + std::vector myKeys; + for (const auto &oper : operations) { + if (oper.operation != IN_KEY) { + ZLOGE("find operation failed"); + return Status::NOT_SUPPORT; + } + std::vector 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 &valuesMap, const std::string field, Blob &kv) { auto it = valuesMap.find(field); if (it == valuesMap.end()) { @@ -101,5 +126,108 @@ Status KvUtils::ToEntryData(const std::map &v kv = data; 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 83% rename from frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp rename to frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_bridge.cpp index cee34e336..756c36b96 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_result_set.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_bridge.cpp @@ -13,30 +13,30 @@ * limitations under the License. */ -#define LOG_TAG "KvStoreDataShareResultSet" +#define LOG_TAG "KvStoreDataShareBrige" #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 kvResultSet) +KvStoreDataShareBrige::KvStoreDataShareBrige(std::shared_ptr kvResultSet) :kvResultSet_(kvResultSet) {}; -int KvStoreDataShareResultSet::GetRowCount(int32_t &count) +int KvStoreDataShareBrige::GetRowCount(int32_t &count) { count = Count(); return count == INVALID_COUNT ? E_ERROR : E_OK; } -int KvStoreDataShareResultSet::GetAllColumnNames(std::vector &columnsName) +int KvStoreDataShareBrige::GetAllColumnNames(std::vector &columnsName) { columnsName = { "key", "value" }; return E_OK; } -bool KvStoreDataShareResultSet::FillBlock(int pos, ResultSetBridge::Writer &writer) +bool KvStoreDataShareBrige::FillBlock(int pos, ResultSetBridge::Writer &writer) { if (kvResultSet_ == nullptr) { ZLOGE("kvResultSet_ nullptr"); @@ -71,7 +71,7 @@ bool KvStoreDataShareResultSet::FillBlock(int pos, ResultSetBridge::Writer &writ return true; } -int KvStoreDataShareResultSet::Count() +int KvStoreDataShareBrige::Count() { if (kvResultSet_ == nullptr) { ZLOGE("kvResultSet_ nullptr"); @@ -88,7 +88,7 @@ int KvStoreDataShareResultSet::Count() resultRowCount = count; return count; } -bool KvStoreDataShareResultSet::OnGo(int32_t start, int32_t target, ResultSetBridge::Writer &writer) +bool KvStoreDataShareBrige::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/kvstore_predicates.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp deleted file mode 100644 index a935ec99a..000000000 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_predicates.cpp +++ /dev/null @@ -1,318 +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. - */ - -#define LOG_TAG "KvStorePredicates" - -#include "cov_util.h" -#include "log_print.h" -#include "datashare_errno.h" -#include "kvstore_predicates.h" - -namespace OHOS { -namespace DistributedKv { -using namespace DataShare; -constexpr KvStorePredicates::QueryHandler KvStorePredicates::HANDLERS[LAST_TYPE]; - -Status KvStorePredicates::ToQuery(const DataSharePredicates &predicates, DataQuery &query) -{ - std::list operationList = predicates.GetOperationList(); - for (const auto &oper : operationList) { - if (oper.operation < 0 || oper.operation >= LAST_TYPE) { - ZLOGE("operation param error"); - return Status::NOT_SUPPORT; - } - Status status = (this->*HANDLERS[oper.operation])(oper, query); - if (status != Status::SUCCESS) { - ZLOGE("ToQuery called failed: %{public}d", status); - return status; - } - } - return Status::SUCCESS; -} - -Status KvStorePredicates::GetKeys(const DataSharePredicates &predicates, std::vector &keys) -{ - std::list operationList = predicates.GetOperationList(); - if (operationList.empty()) { - ZLOGE("operationList is null"); - return Status::ERROR; - } - - std::vector myKeys; - for (const auto &oper : operationList) { - if (oper.operation != IN_KEY) { - ZLOGE("find operation failed"); - return Status::NOT_SUPPORT; - } - std::vector val; - int status = oper.para1.GetStringVector(val); - if (status != E_OK) { - ZLOGE("GetStringVector failed: %{public}d", status); - return Status::ERROR; - } - myKeys.insert(myKeys.end(), val.begin(), val.end()); - } - for (const auto &it : myKeys) { - keys.push_back(it.c_str()); - } - return Status::SUCCESS; -} - -Status KvStorePredicates::InKeys(const OperationItem &oper, DataQuery &query) -{ - std::vector keys; - int status = oper.para1.GetStringVector(keys); - if (status != E_OK) { - ZLOGE("GetStringVector failed: %{public}d", status); - return Status::ERROR; - } - query.InKeys(keys); - return Status::SUCCESS; -} - -Status KvStorePredicates::KeyPrefix(const OperationItem &oper, DataQuery &query) -{ - std::string prefix; - int status = oper.para1.GetString(prefix); - if (status != E_OK) { - ZLOGE("KeyPrefix failed: %{public}d", status); - return Status::ERROR; - } - query.KeyPrefix(prefix); - return Status::SUCCESS; -} - -Status KvStorePredicates::EqualTo(const OperationItem &oper, DataQuery &query) -{ - std::string field; - int status = oper.para1.GetString(field); - if (status != E_OK) { - ZLOGE("GetString failed: %{public}d", status); - return Status::ERROR; - } - Querys equal(&query, QueryType::EQUAL); - CovUtil::FillField(field, oper.para2.value, equal); - return Status::SUCCESS; -} - -Status KvStorePredicates::NotEqualTo(const OperationItem &oper, DataQuery &query) -{ - std::string field; - int status = oper.para1.GetString(field); - if (status != E_OK) { - ZLOGE("GetString failed: %{public}d", status); - return Status::ERROR; - } - Querys notEqual(&query, QueryType::NOT_EQUAL); - CovUtil::FillField(field, oper.para2.value, notEqual); - return Status::SUCCESS; -} - -Status KvStorePredicates::GreaterThan(const OperationItem &oper, DataQuery &query) -{ - std::string field; - int status = oper.para1.GetString(field); - if (status != E_OK) { - ZLOGE("GetString failed: %{public}d", status); - return Status::ERROR; - } - Querys greater(&query, QueryType::GREATER); - CovUtil::FillField(field, oper.para2.value, greater); - return Status::SUCCESS; -} - -Status KvStorePredicates::LessThan(const OperationItem &oper, DataQuery &query) -{ - std::string field; - int status = oper.para1.GetString(field); - if (status != E_OK) { - ZLOGE("GetString failed: %{public}d", status); - return Status::ERROR; - } - Querys less(&query, QueryType::LESS); - CovUtil::FillField(field, oper.para2.value, less); - return Status::SUCCESS; -} - -Status KvStorePredicates::GreaterThanOrEqualTo(const OperationItem &oper, DataQuery &query) -{ - std::string field; - int status = oper.para1.GetString(field); - if (status != E_OK) { - ZLOGE("GetString failed: %{public}d", status); - return Status::ERROR; - } - Querys greaterOrEqual(&query, QueryType::GREATER_OR_EQUAL); - CovUtil::FillField(field, oper.para2.value, greaterOrEqual); - return Status::SUCCESS; -} - -Status KvStorePredicates::LessThanOrEqualTo(const OperationItem &oper, DataQuery &query) -{ - std::string field; - int status = oper.para1.GetString(field); - if (status != E_OK) { - ZLOGE("GetString failed: %{public}d", status); - return Status::ERROR; - } - Querys lessOrEqual(&query, QueryType::LESS_OR_EQUAL); - CovUtil::FillField(field, oper.para2.value, lessOrEqual); - return Status::SUCCESS; -} - -Status KvStorePredicates::And(const OperationItem &oper, DataQuery &query) -{ - query.And(); - return Status::SUCCESS; -} - -Status KvStorePredicates::Or(const OperationItem &oper, DataQuery &query) -{ - query.Or(); - return Status::SUCCESS; -} - -Status KvStorePredicates::IsNull(const OperationItem &oper, DataQuery &query) -{ - std::string field; - int status = oper.para1.GetString(field); - if (status != E_OK) { - ZLOGE("IsNull failed: %{public}d", status); - return Status::ERROR; - } - query.IsNull(field); - return Status::SUCCESS; -} - -Status KvStorePredicates::IsNotNull(const OperationItem &oper, DataQuery &query) -{ - std::string field; - int status = oper.para1.GetString(field); - if (status != E_OK) { - ZLOGE("IsNotNull failed: %{public}d", status); - return Status::ERROR; - } - query.IsNotNull(field); - return Status::SUCCESS; -} - -Status KvStorePredicates::In(const OperationItem &oper, DataQuery &query) -{ - std::string field; - int status = oper.para1.GetString(field); - if (status != E_OK) { - ZLOGE("GetString failed: %{public}d", status); - return Status::ERROR; - } - InOrNotIn in(&query, QueryType::IN); - CovUtil::FillField(field, oper.para2.value, in); - return Status::SUCCESS; -} - -Status KvStorePredicates::NotIn(const OperationItem &oper, DataQuery &query) -{ - std::string field; - int status = oper.para1.GetString(field); - if (status != E_OK) { - ZLOGE("GetString failed: %{public}d", status); - return Status::ERROR; - } - InOrNotIn notIn(&query, QueryType::NOT_IN); - CovUtil::FillField(field, oper.para2.value, notIn); - return Status::SUCCESS; -} - -Status KvStorePredicates::Like(const OperationItem &oper, DataQuery &query) -{ - std::string field; - int status = oper.para1.GetString(field); - if (status != E_OK) { - ZLOGE("Like field failed: %{public}d", status); - return Status::ERROR; - } - - std::string value; - status = oper.para2.GetString(value); - if (status != E_OK) { - ZLOGE("Like value failed: %{public}d", status); - return Status::ERROR; - } - query.Like(field, value); - return Status::SUCCESS; -} - -Status KvStorePredicates::Unlike(const OperationItem &oper, DataQuery &query) -{ - std::string field; - int status = oper.para1.GetString(field); - if (status != E_OK) { - ZLOGE("Unlike failed: %{public}d", status); - return Status::ERROR; - } - - std::string value; - status = oper.para2.GetString(value); - if (status != E_OK) { - ZLOGE("Unlike value failed: %{public}d", status); - return Status::ERROR; - } - query.Unlike(field, value); - return Status::SUCCESS; -} - -Status KvStorePredicates::OrderByAsc(const OperationItem &oper, DataQuery &query) -{ - std::string field; - int status = oper.para1.GetString(field); - if (status != E_OK) { - ZLOGE("OrderByAsc failed: %{public}d", status); - return Status::ERROR; - } - query.OrderByAsc(field); - return Status::SUCCESS; -} - -Status KvStorePredicates::OrderByDesc(const OperationItem &oper, DataQuery &query) -{ - std::string field; - int status = oper.para1.GetString(field); - if (status != E_OK) { - ZLOGE("OrderByDesc failed: %{public}d", status); - return Status::ERROR; - } - query.OrderByDesc(field); - return Status::SUCCESS; -} - -Status KvStorePredicates::Limit(const OperationItem &oper, DataQuery &query) -{ - int number; - int status = oper.para1.GetInt(number); - if (status != E_OK) { - ZLOGE("Limit number failed: %{public}d", status); - return Status::ERROR; - } - - int offset; - status = oper.para2.GetInt(offset); - if (status != E_OK) { - ZLOGE("Limit offset failed: %{public}d", offset); - return Status::ERROR; - } - query.Limit(number, offset); - return Status::SUCCESS; -} -} // namespace DistributedKv -} // namespace OHOS \ No newline at end of file diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/single_kvstore_client.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/single_kvstore_client.cpp index 1d5a1e442..ab77fba7c 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(std::move(resultSetTmp)); + + resultSet = std::shared_ptr(new KvStoreResultSetClient(resultSetTmp), [proxy = kvStoreProxy_] (auto result) { + ZLOGE("kvstore proxy ResultSet closed."); + proxy->CloseResultSet(result->GetKvStoreResultSetProxy()); + }); return statusTmp; } @@ -128,8 +132,11 @@ Status SingleKvStoreClient::GetResultSetWithQuery(const std::string &query, ZLOGE("resultSetTmp is nullptr."); return statusTmp; } - ZLOGE("GetResultSetWithQuery"); - resultSet = std::make_shared(std::move(resultSetTmp)); + + resultSet = std::shared_ptr(new KvStoreResultSetClient(resultSetTmp), [proxy = kvStoreProxy_] (auto result) { + ZLOGE("kvstore proxy ResultSetwithquery closed."); + proxy->CloseResultSet(result->GetKvStoreResultSetProxy()); + }); return statusTmp; } diff --git a/frameworks/jskitsimpl/distributeddata/include/js_util.h b/frameworks/jskitsimpl/distributeddata/include/js_util.h index b1b5f3bd9..7c13e687c 100644 --- a/frameworks/jskitsimpl/distributeddata/include/js_util.h +++ b/frameworks/jskitsimpl/distributeddata/include/js_util.h @@ -17,7 +17,7 @@ #include #include #include - +#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, bool, double>; static KvStoreVariant Blob2VariantValue(const Blob& blob); @@ -139,9 +140,9 @@ 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 &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 &out); + static napi_status GetValue(napi_env env, napi_value in, DataQuery &out); + static napi_status GetValue(napi_value in, napi_env env, std::vector &out); /* napi_get_named_property wrapper */ template diff --git a/frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp b/frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp index 806cdaa3a..0cae71760 100644 --- a/frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp +++ b/frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp @@ -122,7 +122,6 @@ enum class ArgsType : uint8_t { DEVICEID_KEYPREFIX = 0, DEVICEID_QUERY, QUERY, - PREDICATES, UNKNOWN = 255 }; struct VariantArgs { @@ -131,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) @@ -143,9 +142,8 @@ static napi_status GetVariantArgs(napi_env env, size_t argc, napi_value* argv, V if (type == napi_string) { // number 2 means: required 2 arguments, CHECK_RETURN(argc == 2, "invalid arguments!", napi_invalid_arg); - JSUtil::GetValue(env, argv[0], va.deviceId); + status = JSUtil::GetValue(env, argv[0], va.deviceId); CHECK_RETURN(!va.deviceId.empty(), "invalid arg[0], i.e. invalid deviceId!", napi_invalid_arg); - status = napi_typeof(env, argv[1], &type); CHECK_RETURN((type == napi_string) || (type == napi_object), "invalid arg[1], type error!", napi_invalid_arg); if (type == napi_string) { @@ -153,9 +151,18 @@ static napi_status GetVariantArgs(napi_env env, size_t argc, napi_value* argv, V CHECK_RETURN(!va.keyPrefix.empty(), "invalid arg[1], i.e. invalid keyPrefix!", napi_invalid_arg); va.type = ArgsType::DEVICEID_KEYPREFIX; } else if (type == napi_object) { - status = JSUtil::Unwrap(env, argv[1], reinterpret_cast(&va.query), JsQuery::Constructor(env)); - CHECK_RETURN(va.query != nullptr, "invalid arg[1], i.e. invalid query!", napi_invalid_arg); - va.type = ArgsType::DEVICEID_QUERY; + bool result = false; + status = napi_instanceof(env, argv[1], JsQuery::Constructor(env), &result); + if ((status == napi_ok) && (result != false)) { + status = JSUtil::Unwrap(env, argv[1], reinterpret_cast(&va.query), JsQuery::Constructor(env)); + 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.dataQuery); + // va.type = ArgsType::DEVICEID_PREDICATES; + ZLOGD("kvStoreDataShare->GetResultSet return %{public}d", status); + CHECK_RETURN(true, "invalid arg[0], i.e. invalid predicates!", napi_invalid_arg); + } } } else if (type == napi_object) { // number 1 means: required 1 arguments, @@ -267,12 +274,11 @@ 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 { + ctxt->va.dataQuery.DeviceId(ctxt->va.deviceId); + ZLOGD("ArgsType::DEVICEID_PREDICATES ToQuery return %{public}d", status); + 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; CHECK_STATUS_RETURN_VOID(ctxt, "kvStore->GetResultSet() failed!"); diff --git a/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp b/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp index b43072a9f..eae684d92 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,7 +112,6 @@ napi_value JsKVStore::Put(napi_env env, napi_callback_info info) struct PutContext : public ContextBase { std::string key; std::vector value; - std::vector valueBuckets; std::vector entries; napi_valuetype type; }; @@ -126,7 +124,7 @@ napi_value JsKVStore::Put(napi_env env, napi_callback_info info) 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); + ctxt->status = JSUtil::GetValue(argv[0], env, ctxt->entries); 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); @@ -150,8 +148,6 @@ napi_value JsKVStore::Put(napi_env env, napi_callback_info info) CHECK_STATUS_RETURN_VOID(ctxt, "kvStore->Put() failed!"); } else if (ctxt->type == napi_object) { auto& kvStore = reinterpret_cast(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!"); @@ -172,7 +168,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 keys; napi_valuetype type; }; auto ctxt = std::make_shared(); @@ -187,7 +183,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 +198,14 @@ 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 keys; - auto kvPredicates = std::make_shared(); - 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); + // std::vector keys; + // auto kvPredicates = std::make_shared(); + // 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(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 994a3b76d..361144575 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 f82712551..813ebbeaa 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,11 +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); - 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 0c7a975b7..451a76f4c 100644 --- a/frameworks/jskitsimpl/distributeddata/src/js_util.cpp +++ b/frameworks/jskitsimpl/distributeddata/src/js_util.cpp @@ -14,6 +14,7 @@ */ #define LOG_TAG "JSUtil" #include "js_util.h" +#include "types.h" #include #include #include "datashare_predicates_proxy.h" @@ -21,6 +22,7 @@ #include "js_schema.h" #include "log_print.h" #include "napi_queue.h" +#include "kv_utils.h" using namespace OHOS::DistributedKv; using namespace OHOS::DataShare; @@ -1001,48 +1003,68 @@ 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 &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; + std::vector keys; + Status status = KvUtils::GetKeys(*predicates, keys); + if (status == Status::SUCCESS) { + ZLOGD("napi_value -> GetValue Blob ok"); + out = keys; + } + return nstatus; } -napi_status JSUtil::GetValue(napi_env env, napi_value in, std::vector& out) +napi_status JSUtil::GetValue(napi_value in, napi_env env, std::vector &out) { - ZLOGD("napi_value -> std::vector"); out.clear(); + ZLOGD("napi_value -> std::vector "); bool isArray = false; napi_is_array(env, in, &isArray); - CHECK_RETURN(isArray, "not an array", napi_invalid_arg); + CHECK_RETURN(isArray, "not 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); + CHECK_RETURN((status == napi_ok) && (length > 0), "get_array failed!", status); 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); + CHECK_RETURN((status == napi_ok), "no element", status); + if ((status != napi_ok) || (item == nullptr)) { + continue; + } DataShareValuesBucket valueBucket; - status = GetValue(env, item, valueBucket); + 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(valueBucket, env, in); CHECK_RETURN(status == napi_ok, "not a string", napi_invalid_arg); - out.push_back(valueBucket); + DistributedKv::Entry entry; + entry = KvUtils::ToEntry(valueBucket); + out.push_back(entry); } return status; } -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 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 9e27504ff..5159f34a2 100755 --- a/interfaces/innerkits/distributeddata/BUILD.gn +++ b/interfaces/innerkits/distributeddata/BUILD.gn @@ -64,9 +64,8 @@ ohos_shared_library("distributeddata_inner") { "../../../frameworks/innerkitsimpl/distributeddatafwk/src/itypes_util.cpp", "../../../frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.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_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_sync_callback_client.cpp", diff --git a/interfaces/innerkits/distributeddata/include/kv_utils.h b/interfaces/innerkits/distributeddata/include/kv_utils.h index 5ce1fe458..254e19157 100644 --- a/interfaces/innerkits/distributeddata/include/kv_utils.h +++ b/interfaces/innerkits/distributeddata/include/kv_utils.h @@ -31,7 +31,28 @@ public: static Status ToQuery(const DataShare::DataSharePredicates &predicates, DataQuery &query); static Entry ToEntry(const DataShare::DataShareValuesBucket &valueBucket); static std::vector ToEntries(const std::vector &valueBuckets); + static Status GetKeys(const DataShare::DataSharePredicates &predicates, std::vector &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; @@ -41,6 +62,28 @@ private: DataShare::DataShareValueObject> &valuesMap, const std::string field, Blob &kv); 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 112adf87a..f30d7972a 100644 --- a/interfaces/jskits/distributeddata/BUILD.gn +++ b/interfaces/jskits/distributeddata/BUILD.gn @@ -65,7 +65,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 = [ -- Gitee From d8a1e753614ba44ef0133de448af3f4ea927d54f Mon Sep 17 00:00:00 2001 From: anan Date: Tue, 24 May 2022 23:27:51 +0800 Subject: [PATCH 17/20] update Signed-off-by: anan --- .../include/kvstore_datashare_bridge.h | 6 +++--- .../distributeddatafwk/src/kv_utils.cpp | 5 +++-- .../src/kvstore_datashare_bridge.cpp | 14 +++++++------- .../src/single_kvstore_client.cpp | 12 +++++++----- .../distributeddata/src/js_device_kv_store.cpp | 1 - .../jskitsimpl/distributeddata/src/js_kv_store.cpp | 6 ------ .../jskitsimpl/distributeddata/src/js_util.cpp | 5 ++--- 7 files changed, 22 insertions(+), 27 deletions(-) diff --git a/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_datashare_bridge.h b/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_datashare_bridge.h index b8743a99e..a121fed11 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_datashare_bridge.h +++ b/frameworks/innerkitsimpl/distributeddatafwk/include/kvstore_datashare_bridge.h @@ -23,11 +23,11 @@ namespace OHOS { namespace DistributedKv { -class KvStoreDataShareBrige : public DataShare::ResultSetBridge { +class KvStoreDataShareBridge : public DataShare::ResultSetBridge { public: - KvStoreDataShareBrige(std::shared_ptr kvResultSet); + KvStoreDataShareBridge(std::shared_ptr kvResultSet); - ~KvStoreDataShareBrige() = default; + ~KvStoreDataShareBridge() = default; int GetRowCount(int32_t &count) override; diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp index 07517a6ad..4680c0f6f 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp @@ -34,7 +34,7 @@ std::shared_ptr KvUtils::ToResultSetBridge(std::shared_ptr(resultSet); + return std::make_shared(resultSet); } Status KvUtils::ToQuery(const DataSharePredicates &predicates, DataQuery &query) @@ -105,7 +105,8 @@ Status KvUtils::GetKeys(const DataSharePredicates &predicates, std::vector return Status::SUCCESS; } -Status KvUtils::ToEntryData(const std::map &valuesMap, const std::string field, Blob &kv) +Status KvUtils::ToEntryData(const std::map &valuesMap, + const std::string field, Blob &kv) { auto it = valuesMap.find(field); if (it == valuesMap.end()) { diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_bridge.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_bridge.cpp index 756c36b96..8d612c1bf 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_bridge.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_datashare_bridge.cpp @@ -13,7 +13,7 @@ * limitations under the License. */ -#define LOG_TAG "KvStoreDataShareBrige" +#define LOG_TAG "KvStoreDataShareBridge" #include "constant.h" #include "log_print.h" @@ -22,21 +22,21 @@ namespace OHOS { namespace DistributedKv { using namespace DataShare; -KvStoreDataShareBrige::KvStoreDataShareBrige(std::shared_ptr kvResultSet) +KvStoreDataShareBridge::KvStoreDataShareBridge(std::shared_ptr kvResultSet) :kvResultSet_(kvResultSet) {}; -int KvStoreDataShareBrige::GetRowCount(int32_t &count) +int KvStoreDataShareBridge::GetRowCount(int32_t &count) { count = Count(); return count == INVALID_COUNT ? E_ERROR : E_OK; } -int KvStoreDataShareBrige::GetAllColumnNames(std::vector &columnsName) +int KvStoreDataShareBridge::GetAllColumnNames(std::vector &columnsName) { columnsName = { "key", "value" }; return E_OK; } -bool KvStoreDataShareBrige::FillBlock(int pos, ResultSetBridge::Writer &writer) +bool KvStoreDataShareBridge::FillBlock(int pos, ResultSetBridge::Writer &writer) { if (kvResultSet_ == nullptr) { ZLOGE("kvResultSet_ nullptr"); @@ -71,7 +71,7 @@ bool KvStoreDataShareBrige::FillBlock(int pos, ResultSetBridge::Writer &writer) return true; } -int KvStoreDataShareBrige::Count() +int KvStoreDataShareBridge::Count() { if (kvResultSet_ == nullptr) { ZLOGE("kvResultSet_ nullptr"); @@ -88,7 +88,7 @@ int KvStoreDataShareBrige::Count() resultRowCount = count; return count; } -bool KvStoreDataShareBrige::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 ab77fba7c..11bba1595 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/single_kvstore_client.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/single_kvstore_client.cpp @@ -97,9 +97,10 @@ Status SingleKvStoreClient::GetResultSet(const Key &prefix, std::shared_ptr(new KvStoreResultSetClient(resultSetTmp), [proxy = kvStoreProxy_] (auto result) { + resultSet = std::shared_ptr( + new KvStoreResultSetClient(resultSetTmp), [proxy = kvStoreProxy_] (auto result) { ZLOGE("kvstore proxy ResultSet closed."); - proxy->CloseResultSet(result->GetKvStoreResultSetProxy()); + proxy->CloseResultSet(result->GetKvStoreResultSetProxy()); }); return statusTmp; } @@ -133,9 +134,10 @@ Status SingleKvStoreClient::GetResultSetWithQuery(const std::string &query, return statusTmp; } - resultSet = std::shared_ptr(new KvStoreResultSetClient(resultSetTmp), [proxy = kvStoreProxy_] (auto result) { + resultSet = std::shared_ptr( + new KvStoreResultSetClient(resultSetTmp), [proxy = kvStoreProxy_] (auto result) { ZLOGE("kvstore proxy ResultSetwithquery closed."); - proxy->CloseResultSet(result->GetKvStoreResultSetProxy()); + proxy->CloseResultSet(result->GetKvStoreResultSetProxy()); }); return statusTmp; } @@ -275,7 +277,7 @@ Status SingleKvStoreClient::SubscribeKvStore(SubscribeType subscribeType, std::s // remove storeId after remove SubscribeKvStore function in manager. currently reserve for convenience. sptr ipcObserver = new (std::nothrow) KvStoreObserverClient(GetStoreId(), subscribeType, observer, - KvStoreType::SINGLE_VERSION); + KvStoreType::SINGLE_VERSION ); if (ipcObserver == nullptr) { ZLOGW("new KvStoreObserverClient failed"); return Status::ERROR; diff --git a/frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp b/frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp index 0cae71760..e34f3bb6d 100644 --- a/frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp +++ b/frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp @@ -159,7 +159,6 @@ static napi_status GetVariantArgs(napi_env env, size_t argc, napi_value* argv, V va.type = ArgsType::DEVICEID_QUERY; } else { status = JSUtil::GetValue(env, argv[1], va.dataQuery); - // va.type = ArgsType::DEVICEID_PREDICATES; ZLOGD("kvStoreDataShare->GetResultSet return %{public}d", status); CHECK_RETURN(true, "invalid arg[0], i.e. invalid predicates!", napi_invalid_arg); } diff --git a/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp b/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp index eae684d92..10a66da39 100644 --- a/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp +++ b/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp @@ -198,12 +198,6 @@ 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 keys; - // auto kvPredicates = std::make_shared(); - // 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(ctxt->native)->kvStore_; Status status = kvStore->DeleteBatch(ctxt->keys); ZLOGD("kv Datashare Delete return %{public}d", status); diff --git a/frameworks/jskitsimpl/distributeddata/src/js_util.cpp b/frameworks/jskitsimpl/distributeddata/src/js_util.cpp index 451a76f4c..c5beaa75c 100644 --- a/frameworks/jskitsimpl/distributeddata/src/js_util.cpp +++ b/frameworks/jskitsimpl/distributeddata/src/js_util.cpp @@ -14,7 +14,6 @@ */ #define LOG_TAG "JSUtil" #include "js_util.h" -#include "types.h" #include #include #include "datashare_predicates_proxy.h" @@ -23,6 +22,7 @@ #include "log_print.h" #include "napi_queue.h" #include "kv_utils.h" +#include "types.h" using namespace OHOS::DistributedKv; using namespace OHOS::DataShare; @@ -1045,8 +1045,7 @@ napi_status JSUtil::GetValue(napi_value in, napi_env env, std::vector Date: Tue, 24 May 2022 23:32:26 +0800 Subject: [PATCH 18/20] update Signed-off-by: anan --- .../distributeddatafwk/src/single_kvstore_client.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/single_kvstore_client.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/single_kvstore_client.cpp index 11bba1595..cc85aa8f4 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/single_kvstore_client.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/single_kvstore_client.cpp @@ -137,7 +137,7 @@ Status SingleKvStoreClient::GetResultSetWithQuery(const std::string &query, resultSet = std::shared_ptr( new KvStoreResultSetClient(resultSetTmp), [proxy = kvStoreProxy_] (auto result) { ZLOGE("kvstore proxy ResultSetwithquery closed."); - proxy->CloseResultSet(result->GetKvStoreResultSetProxy()); + proxy->CloseResultSet(result->GetKvStoreResultSetProxy()); }); return statusTmp; } @@ -276,8 +276,8 @@ Status SingleKvStoreClient::SubscribeKvStore(SubscribeType subscribeType, std::s } // remove storeId after remove SubscribeKvStore function in manager. currently reserve for convenience. sptr ipcObserver = - new (std::nothrow) KvStoreObserverClient(GetStoreId(), subscribeType, observer, - KvStoreType::SINGLE_VERSION ); + new (std::nothrow) KvStoreObserverClient(GetStoreId(), + subscribeType, observer, KvStoreType::SINGLE_VERSION); if (ipcObserver == nullptr) { ZLOGW("new KvStoreObserverClient failed"); return Status::ERROR; -- Gitee From 770eb5ad31bfb3e4814346ba603cbb1986e0d7f3 Mon Sep 17 00:00:00 2001 From: anan Date: Wed, 25 May 2022 22:37:27 +0800 Subject: [PATCH 19/20] update Signed-off-by: anan --- .../distributeddatafwk/src/kv_utils.cpp | 44 ++++++++++++----- .../distributeddata/include/js_util.h | 1 - .../distributeddata/src/js_kv_store.cpp | 47 ++++++------------- .../distributeddata/src/js_util.cpp | 14 ++++-- .../distributeddata/include/kv_utils.h | 11 ++++- interfaces/jskits/distributeddata/BUILD.gn | 1 + 6 files changed, 70 insertions(+), 48 deletions(-) diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp index 4680c0f6f..bc8c44e3f 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp @@ -24,6 +24,7 @@ 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]; @@ -106,7 +107,7 @@ Status KvUtils::GetKeys(const DataSharePredicates &predicates, std::vector } Status KvUtils::ToEntryData(const std::map &valuesMap, - const std::string field, Blob &kv) + const std::string field, Blob &blob) { auto it = valuesMap.find(field); if (it == valuesMap.end()) { @@ -114,17 +115,38 @@ Status KvUtils::ToEntryData(const std::map &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 data; - int status = it->second.GetBlob(data); - if (status != Status::SUCCESS) { - ZLOGE("GetBlob failed: %{public}d", status); - return Status::ERROR; + + std::vector uData; + if (type == DataShareValueObjectType::TYPE_BLOB) { + ZLOGE("Value bucket type blob"); + std::vector 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; + uint8_t *dataU8 = reinterpret_cast(&data); + uData.push_back(KvUtils::INTEGER); + uData.insert(uData.end(), dataU8, dataU8 + sizeof(double) / sizeof(uint8_t)); + } else if (type == DataShareValueObjectType::TYPE_DOUBLE) { + ZLOGE("Value bucket type double"); + double data = it->second; + uint64_t data64 = htobe64(*reinterpret_cast(&data)); + uint8_t *dataU8 = reinterpret_cast(&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(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; } diff --git a/frameworks/jskitsimpl/distributeddata/include/js_util.h b/frameworks/jskitsimpl/distributeddata/include/js_util.h index 7c13e687c..892cb7282 100644 --- a/frameworks/jskitsimpl/distributeddata/include/js_util.h +++ b/frameworks/jskitsimpl/distributeddata/include/js_util.h @@ -142,7 +142,6 @@ public: static napi_status GetValue(napi_env env, napi_value in, std::vector &out); static napi_status GetValue(napi_env env, napi_value in, DataQuery &out); - static napi_status GetValue(napi_value in, napi_env env, std::vector &out); /* napi_get_named_property wrapper */ template diff --git a/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp b/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp index 10a66da39..7d712d528 100644 --- a/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp +++ b/frameworks/jskitsimpl/distributeddata/src/js_kv_store.cpp @@ -112,46 +112,29 @@ napi_value JsKVStore::Put(napi_env env, napi_callback_info info) struct PutContext : public ContextBase { std::string key; std::vector value; - std::vector entries; - napi_valuetype type; }; - auto ctxt = std::make_shared(); ctxt->GetCbInfo(env, info, [env, ctxt](size_t argc, napi_value* argv) { // required 2 arguments :: - 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(argv[0], env, ctxt->entries); - 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(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(ctxt->native)->kvStore_; - 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(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); } diff --git a/frameworks/jskitsimpl/distributeddata/src/js_util.cpp b/frameworks/jskitsimpl/distributeddata/src/js_util.cpp index c5beaa75c..e012640f5 100644 --- a/frameworks/jskitsimpl/distributeddata/src/js_util.cpp +++ b/frameworks/jskitsimpl/distributeddata/src/js_util.cpp @@ -757,7 +757,7 @@ napi_status JSUtil::SetValue(napi_env env, const std::list } /* napi_value <-> std::vector */ -napi_status JSUtil::GetValue(napi_env env, napi_value in, std::vector& out) +napi_status JSUtil::GetValue(napi_env env, napi_value in, std::vector &out) { out.clear(); ZLOGD("napi_value -> std::vector "); @@ -777,9 +777,15 @@ napi_status JSUtil::GetValue(napi_env env, napi_value in, std::vector& in, napi_value& out) @@ -1013,10 +1019,12 @@ napi_status JSUtil::GetValue(napi_env env, napi_value in, std::vector &out DataSharePredicates *predicates = GetNativePredicatesObject(env, in); CHECK_RETURN((predicates != nullptr), "invalid type", napi_invalid_arg); std::vector keys; + nstatus = napi_invalid_arg; Status status = KvUtils::GetKeys(*predicates, keys); if (status == Status::SUCCESS) { - ZLOGD("napi_value -> GetValue Blob ok"); + ZLOGD("napi_value —> GetValue Blob ok"); out = keys; + nstatus = napi_ok; } return nstatus; } diff --git a/interfaces/innerkits/distributeddata/include/kv_utils.h b/interfaces/innerkits/distributeddata/include/kv_utils.h index 254e19157..fd7912cda 100644 --- a/interfaces/innerkits/distributeddata/include/kv_utils.h +++ b/interfaces/innerkits/distributeddata/include/kv_utils.h @@ -27,6 +27,15 @@ 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 ToResultSetBridge(std::shared_ptr resultSet); static Status ToQuery(const DataShare::DataSharePredicates &predicates, DataQuery &query); static Entry ToEntry(const DataShare::DataShareValuesBucket &valueBucket); @@ -59,7 +68,7 @@ private: KvUtils &operator=(const KvUtils &) = delete; ~KvUtils() = delete; static Status ToEntryData(const std::map &valuesMap, const std::string field, Blob &kv); + 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 &); diff --git a/interfaces/jskits/distributeddata/BUILD.gn b/interfaces/jskits/distributeddata/BUILD.gn index f30d7972a..326342c91 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", -- Gitee From c078ba0e80ff59e0a8b6967aea79dffdc9d194de Mon Sep 17 00:00:00 2001 From: anan Date: Thu, 26 May 2022 16:45:50 +0800 Subject: [PATCH 20/20] update Signed-off-by: anan --- .../distributeddatafwk/src/kv_utils.cpp | 15 +++++----- .../src/js_device_kv_store.cpp | 6 ++-- .../distributeddata/src/js_util.cpp | 30 ------------------- 3 files changed, 11 insertions(+), 40 deletions(-) diff --git a/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp b/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp index bc8c44e3f..00ad83622 100644 --- a/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp +++ b/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp @@ -42,11 +42,11 @@ Status KvUtils::ToQuery(const DataSharePredicates &predicates, DataQuery &query) { std::list 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); + if (oper.operation < 0 || oper.operation >= LAST_TYPE) { + ZLOGE("operation param error"); + return Status::NOT_SUPPORT; + } + (*HANDLERS[oper.operation])(oper, query); } return Status::SUCCESS; } @@ -125,9 +125,10 @@ Status KvUtils::ToEntryData(const std::map &v } else if (type == DataShareValueObjectType::TYPE_INT) { ZLOGE("Value bucket type int"); int64_t data = it->second; - uint8_t *dataU8 = reinterpret_cast(&data); + uint64_t data64 = htobe64(*reinterpret_cast(&data)); + uint8_t *dataU8 = reinterpret_cast(&data64); uData.push_back(KvUtils::INTEGER); - uData.insert(uData.end(), dataU8, dataU8 + sizeof(double) / sizeof(uint8_t)); + 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; diff --git a/frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp b/frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp index e34f3bb6d..01ecf58b8 100644 --- a/frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp +++ b/frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp @@ -267,16 +267,16 @@ napi_value JsDeviceKVStore::GetResultSet(napi_env env, napi_callback_info info) } else if (ctxt->va.type == ArgsType::DEVICEID_QUERY) { auto query = ctxt->va.query->GetNative(); query.DeviceId(ctxt->va.deviceId); - status = kvStore->GetResultSetWithQuery(query.ToString(), kvResultSet); + status = kvStore->GetResultSet(query.ToString(), kvResultSet); ZLOGD("kvStore->GetEntriesWithQuery() return %{public}d", status); } else if (ctxt->va.type == ArgsType::QUERY) { auto query = ctxt->va.query->GetNative(); - status = kvStore->GetResultSetWithQuery(query.ToString(), kvResultSet); + status = kvStore->GetResultSet(query.ToString(), kvResultSet); ZLOGD("kvStore->GetEntriesWithQuery() return %{public}d", status); } else { ctxt->va.dataQuery.DeviceId(ctxt->va.deviceId); ZLOGD("ArgsType::DEVICEID_PREDICATES ToQuery return %{public}d", status); - status = kvStore->GetResultSetWithQuery(ctxt->va.dataQuery.ToString(), kvResultSet); + status = kvStore->GetResultSet(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_util.cpp b/frameworks/jskitsimpl/distributeddata/src/js_util.cpp index e012640f5..cfba37195 100644 --- a/frameworks/jskitsimpl/distributeddata/src/js_util.cpp +++ b/frameworks/jskitsimpl/distributeddata/src/js_util.cpp @@ -1029,36 +1029,6 @@ napi_status JSUtil::GetValue(napi_env env, napi_value in, std::vector &out return nstatus; } -napi_status JSUtil::GetValue(napi_value in, napi_env env, std::vector &out) -{ - out.clear(); - ZLOGD("napi_value -> std::vector "); - bool isArray = false; - napi_is_array(env, in, &isArray); - CHECK_RETURN(isArray, "not 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!", status); - for (uint32_t i = 0; i < length; ++i) { - napi_value item = nullptr; - status = napi_get_element(env, in, i, &item); - CHECK_RETURN((status == napi_ok), "no element", status); - if ((status != napi_ok) || (item == nullptr)) { - continue; - } - DataShareValuesBucket valueBucket; - 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(valueBucket, env, in); - CHECK_RETURN(status == napi_ok, "not a string", napi_invalid_arg); - DistributedKv::Entry entry = KvUtils::ToEntry(valueBucket); - out.push_back(entry); - } - return status; -} - napi_status JSUtil::GetValue(napi_env env, napi_value in, DataQuery &query) { ZLOGD("napi_value -> std::GetValue DataQuery"); -- Gitee