1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "rdb_data_manager.h"
17
18 #include "app_log_wrapper.h"
19 #include "bundle_util.h"
20 #include "scope_guard.h"
21
22 namespace OHOS {
23 namespace AppExecFwk {
24 namespace {
25 const std::string BMS_KEY = "KEY";
26 const std::string BMS_VALUE = "VALUE";
27 const int32_t BMS_KEY_INDEX = 0;
28 const int32_t BMS_VALUE_INDEX = 1;
29 }
30
RdbDataManager(const BmsRdbConfig & bmsRdbConfig)31 RdbDataManager::RdbDataManager(const BmsRdbConfig &bmsRdbConfig)
32 : bmsRdbConfig_(bmsRdbConfig) {}
33
~RdbDataManager()34 RdbDataManager::~RdbDataManager() {}
35
ClearCache()36 void RdbDataManager::ClearCache()
37 {
38 NativeRdb::RdbHelper::ClearCache();
39 }
40
GetRdbStore()41 std::shared_ptr<NativeRdb::RdbStore> RdbDataManager::GetRdbStore()
42 {
43 NativeRdb::RdbStoreConfig rdbStoreConfig(
44 bmsRdbConfig_.dbPath + bmsRdbConfig_.dbName,
45 NativeRdb::StorageMode::MODE_DISK,
46 false,
47 std::vector<uint8_t>(),
48 bmsRdbConfig_.journalMode,
49 bmsRdbConfig_.syncMode);
50
51 int32_t errCode = NativeRdb::E_OK;
52 BmsRdbOpenCallback bmsRdbOpenCallback(bmsRdbConfig_);
53 return NativeRdb::RdbHelper::GetRdbStore(
54 rdbStoreConfig,
55 bmsRdbConfig_.version,
56 bmsRdbOpenCallback,
57 errCode);
58 }
59
InsertData(const std::string & key,const std::string & value)60 bool RdbDataManager::InsertData(const std::string &key, const std::string &value)
61 {
62 APP_LOGD("InsertData start");
63 auto rdbStore = GetRdbStore();
64 if (rdbStore == nullptr) {
65 APP_LOGE("RdbStore is null");
66 return false;
67 }
68
69 int64_t rowId = -1;
70 NativeRdb::ValuesBucket valuesBucket;
71 valuesBucket.PutString(BMS_KEY, key);
72 valuesBucket.PutString(BMS_VALUE, value);
73 auto ret = rdbStore->InsertWithConflictResolution(
74 rowId, bmsRdbConfig_.tableName, valuesBucket, NativeRdb::ConflictResolution::ON_CONFLICT_REPLACE);
75 return ret == NativeRdb::E_OK;
76 }
77
InsertData(const NativeRdb::ValuesBucket & valuesBucket)78 bool RdbDataManager::InsertData(const NativeRdb::ValuesBucket &valuesBucket)
79 {
80 APP_LOGD("InsertData start");
81 auto rdbStore = GetRdbStore();
82 if (rdbStore == nullptr) {
83 APP_LOGE("RdbStore is null");
84 return false;
85 }
86
87 int64_t rowId = -1;
88 auto ret = rdbStore->InsertWithConflictResolution(
89 rowId, bmsRdbConfig_.tableName, valuesBucket, NativeRdb::ConflictResolution::ON_CONFLICT_REPLACE);
90 return ret == NativeRdb::E_OK;
91 }
92
BatchInsert(int64_t & outInsertNum,const std::vector<NativeRdb::ValuesBucket> & valuesBuckets)93 bool RdbDataManager::BatchInsert(int64_t &outInsertNum, const std::vector<NativeRdb::ValuesBucket> &valuesBuckets)
94 {
95 APP_LOGD("BatchInsert start");
96 auto rdbStore = GetRdbStore();
97 if (rdbStore == nullptr) {
98 APP_LOGE("RdbStore is null");
99 return false;
100 }
101 auto ret = rdbStore->BatchInsert(outInsertNum, bmsRdbConfig_.tableName, valuesBuckets);
102 return ret == NativeRdb::E_OK;
103 }
104
UpdateData(const std::string & key,const std::string & value)105 bool RdbDataManager::UpdateData(const std::string &key, const std::string &value)
106 {
107 APP_LOGD("UpdateData start");
108 auto rdbStore = GetRdbStore();
109 if (rdbStore == nullptr) {
110 APP_LOGE("RdbStore is null");
111 return false;
112 }
113
114 int32_t rowId = -1;
115 NativeRdb::AbsRdbPredicates absRdbPredicates(bmsRdbConfig_.tableName);
116 absRdbPredicates.EqualTo(BMS_KEY, key);
117 NativeRdb::ValuesBucket valuesBucket;
118 valuesBucket.PutString(BMS_KEY, key);
119 valuesBucket.PutString(BMS_VALUE, value);
120 auto ret = rdbStore->Update(rowId, valuesBucket, absRdbPredicates);
121 return ret == NativeRdb::E_OK;
122 }
123
UpdateData(const NativeRdb::ValuesBucket & valuesBucket,const NativeRdb::AbsRdbPredicates & absRdbPredicates)124 bool RdbDataManager::UpdateData(
125 const NativeRdb::ValuesBucket &valuesBucket, const NativeRdb::AbsRdbPredicates &absRdbPredicates)
126 {
127 APP_LOGD("UpdateData start");
128 auto rdbStore = GetRdbStore();
129 if (rdbStore == nullptr) {
130 APP_LOGE("RdbStore is null");
131 return false;
132 }
133 if (absRdbPredicates.GetTableName() != bmsRdbConfig_.tableName) {
134 APP_LOGE("RdbStore table is invalid");
135 return false;
136 }
137 int32_t rowId = -1;
138 auto ret = rdbStore->Update(rowId, valuesBucket, absRdbPredicates);
139 return ret == NativeRdb::E_OK;
140 }
141
DeleteData(const std::string & key)142 bool RdbDataManager::DeleteData(const std::string &key)
143 {
144 APP_LOGD("DeleteData start");
145 auto rdbStore = GetRdbStore();
146 if (rdbStore == nullptr) {
147 APP_LOGE("RdbStore is null");
148 return false;
149 }
150
151 int32_t rowId = -1;
152 NativeRdb::AbsRdbPredicates absRdbPredicates(bmsRdbConfig_.tableName);
153 absRdbPredicates.EqualTo(BMS_KEY, key);
154 auto ret = rdbStore->Delete(rowId, absRdbPredicates);
155 return ret == NativeRdb::E_OK;
156 }
157
DeleteData(const NativeRdb::AbsRdbPredicates & absRdbPredicates)158 bool RdbDataManager::DeleteData(const NativeRdb::AbsRdbPredicates &absRdbPredicates)
159 {
160 auto rdbStore = GetRdbStore();
161 if (rdbStore == nullptr) {
162 APP_LOGE("RdbStore is null");
163 return false;
164 }
165 if (absRdbPredicates.GetTableName() != bmsRdbConfig_.tableName) {
166 APP_LOGE("RdbStore table is invalid");
167 return false;
168 }
169 int32_t rowId = -1;
170 auto ret = rdbStore->Delete(rowId, absRdbPredicates);
171 return ret == NativeRdb::E_OK;
172 }
173
QueryData(const std::string & key,std::string & value)174 bool RdbDataManager::QueryData(const std::string &key, std::string &value)
175 {
176 APP_LOGD("QueryData start");
177 auto rdbStore = GetRdbStore();
178 if (rdbStore == nullptr) {
179 APP_LOGE("RdbStore is null");
180 return false;
181 }
182
183 NativeRdb::AbsRdbPredicates absRdbPredicates(bmsRdbConfig_.tableName);
184 absRdbPredicates.EqualTo(BMS_KEY, key);
185 auto absSharedResultSet = rdbStore->Query(absRdbPredicates, std::vector<std::string>());
186 if (absSharedResultSet == nullptr) {
187 APP_LOGE("absSharedResultSet failed");
188 return false;
189 }
190 ScopeGuard stateGuard([&] { absSharedResultSet->Close(); });
191 if (!absSharedResultSet->HasBlock()) {
192 APP_LOGE("absSharedResultSet has no block");
193 return false;
194 }
195 auto ret = absSharedResultSet->GoToFirstRow();
196 if (ret != NativeRdb::E_OK) {
197 APP_LOGE("GoToFirstRow failed, ret: %{public}d", ret);
198 return false;
199 }
200
201 ret = absSharedResultSet->GetString(BMS_VALUE_INDEX, value);
202 if (ret != NativeRdb::E_OK) {
203 APP_LOGE("QueryData failed, ret: %{public}d", ret);
204 return false;
205 }
206
207 return true;
208 }
209
QueryData(const NativeRdb::AbsRdbPredicates & absRdbPredicates)210 std::shared_ptr<NativeRdb::AbsSharedResultSet> RdbDataManager::QueryData(
211 const NativeRdb::AbsRdbPredicates &absRdbPredicates)
212 {
213 APP_LOGD("QueryData start");
214 auto rdbStore = GetRdbStore();
215 if (rdbStore == nullptr) {
216 APP_LOGE("RdbStore is null");
217 return nullptr;
218 }
219 if (absRdbPredicates.GetTableName() != bmsRdbConfig_.tableName) {
220 APP_LOGE("RdbStore table is invalid");
221 return nullptr;
222 }
223 auto absSharedResultSet = rdbStore->Query(absRdbPredicates, std::vector<std::string>());
224 if (absSharedResultSet == nullptr || !absSharedResultSet->HasBlock()) {
225 APP_LOGE("absSharedResultSet failed");
226 return nullptr;
227 }
228 return absSharedResultSet;
229 }
230
QueryAllData(std::map<std::string,std::string> & datas)231 bool RdbDataManager::QueryAllData(std::map<std::string, std::string> &datas)
232 {
233 APP_LOGD("QueryAllData start");
234 auto rdbStore = GetRdbStore();
235 if (rdbStore == nullptr) {
236 APP_LOGE("RdbStore is null");
237 return false;
238 }
239
240 NativeRdb::AbsRdbPredicates absRdbPredicates(bmsRdbConfig_.tableName);
241 auto absSharedResultSet = rdbStore->Query(absRdbPredicates, std::vector<std::string>());
242 if (absSharedResultSet == nullptr) {
243 APP_LOGE("absSharedResultSet failed");
244 return false;
245 }
246 ScopeGuard stateGuard([&] { absSharedResultSet->Close(); });
247 if (!absSharedResultSet->HasBlock()) {
248 APP_LOGE("absSharedResultSet has no block");
249 return false;
250 }
251
252 if (absSharedResultSet->GoToFirstRow() != NativeRdb::E_OK) {
253 APP_LOGE("GoToFirstRow failed");
254 return false;
255 }
256
257 do {
258 std::string key;
259 if (absSharedResultSet->GetString(BMS_KEY_INDEX, key) != NativeRdb::E_OK) {
260 APP_LOGE("GetString key failed");
261 return false;
262 }
263
264 std::string value;
265 if (absSharedResultSet->GetString(BMS_VALUE_INDEX, value) != NativeRdb::E_OK) {
266 APP_LOGE("GetString value failed");
267 return false;
268 }
269
270 datas.emplace(key, value);
271 } while (absSharedResultSet->GoToNextRow() == NativeRdb::E_OK);
272 return !datas.empty();
273 }
274
CreateTable()275 bool RdbDataManager::CreateTable()
276 {
277 std::string createTableSql;
278 if (bmsRdbConfig_.createTableSql.empty()) {
279 createTableSql = std::string(
280 "CREATE TABLE IF NOT EXISTS "
281 + bmsRdbConfig_.tableName
282 + "(KEY TEXT NOT NULL PRIMARY KEY, VALUE TEXT NOT NULL);");
283 } else {
284 createTableSql = bmsRdbConfig_.createTableSql;
285 }
286 auto rdbStore = GetRdbStore();
287 if (rdbStore == nullptr) {
288 APP_LOGE("RdbStore is null");
289 return false;
290 }
291 int ret = rdbStore->ExecuteSql(createTableSql);
292 if (ret != NativeRdb::E_OK) {
293 APP_LOGE("CreateTable failed, ret: %{public}d", ret);
294 return false;
295 }
296 return true;
297 }
298 } // namespace AppExecFwk
299 } // namespace OHOS
300