1 /*
2 * Copyright (c) 2022-2023 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 #include "form_rdb_data_mgr.h"
16
17 #include <cinttypes>
18 #include <thread>
19 #include <filesystem>
20 #include <sstream>
21 #include <sys/stat.h>
22 #include <unistd.h>
23 #include "fms_log_wrapper.h"
24 #include "form_constants.h"
25 #include "form_mgr_errors.h"
26 #include "scope_guard.h"
27
28 namespace OHOS {
29 namespace AppExecFwk {
30 namespace {
31 const std::string FORM_KEY = "KEY";
32 const std::string FORM_VALUE = "VALUE";
33 const int32_t FORM_KEY_INDEX = 0;
34 const int32_t FORM_VALUE_INDEX = 1;
35 } // namespace
RdbStoreDataCallBackFormInfoStorage(const FormRdbConfig & formRdbConfig)36 RdbStoreDataCallBackFormInfoStorage::RdbStoreDataCallBackFormInfoStorage(const FormRdbConfig &formRdbConfig)
37 : formRdbConfig_(formRdbConfig)
38 {
39 HILOG_DEBUG("create rdb store callback instance");
40 }
41
~RdbStoreDataCallBackFormInfoStorage()42 RdbStoreDataCallBackFormInfoStorage::~RdbStoreDataCallBackFormInfoStorage()
43 {
44 HILOG_DEBUG("destroy rdb store callback instance");
45 }
46
OnCreate(NativeRdb::RdbStore & rdbStore)47 int32_t RdbStoreDataCallBackFormInfoStorage::OnCreate(NativeRdb::RdbStore &rdbStore)
48 {
49 HILOG_DEBUG("OnCreate");
50 return NativeRdb::E_OK;
51 }
52
OnUpgrade(NativeRdb::RdbStore & rdbStore,int currentVersion,int targetVersion)53 int32_t RdbStoreDataCallBackFormInfoStorage::OnUpgrade(
54 NativeRdb::RdbStore &rdbStore, int currentVersion, int targetVersion)
55 {
56 HILOG_DEBUG("OnUpgrade currentVersion: %{plubic}d, targetVersion: %{plubic}d",
57 currentVersion, targetVersion);
58 return NativeRdb::E_OK;
59 }
60
OnDowngrade(NativeRdb::RdbStore & rdbStore,int currentVersion,int targetVersion)61 int32_t RdbStoreDataCallBackFormInfoStorage::OnDowngrade(
62 NativeRdb::RdbStore &rdbStore, int currentVersion, int targetVersion)
63 {
64 HILOG_DEBUG("OnDowngrade currentVersion: %{plubic}d, targetVersion: %{plubic}d",
65 currentVersion, targetVersion);
66 return NativeRdb::E_OK;
67 }
68
OnOpen(NativeRdb::RdbStore & rdbStore)69 int32_t RdbStoreDataCallBackFormInfoStorage::OnOpen(NativeRdb::RdbStore &rdbStore)
70 {
71 HILOG_DEBUG("OnOpen");
72 return NativeRdb::E_OK;
73 }
74
onCorruption(std::string databaseFile)75 int32_t RdbStoreDataCallBackFormInfoStorage::onCorruption(std::string databaseFile)
76 {
77 return NativeRdb::E_OK;
78 }
79
FormRdbDataMgr(const FormRdbConfig & formRdbConfig)80 FormRdbDataMgr::FormRdbDataMgr(const FormRdbConfig &formRdbConfig)
81 : formRdbConfig_(formRdbConfig)
82 {
83 HILOG_DEBUG("create form rdb data manager");
84 }
85
CreateTable()86 ErrCode FormRdbDataMgr::CreateTable()
87 {
88 if (rdbStore_ == nullptr) {
89 HILOG_ERROR("FormInfoRdbStore is null");
90 return ERR_APPEXECFWK_FORM_COMMON_CODE;
91 }
92
93 std::string createTableSql;
94 if (formRdbConfig_.createTableSql.empty()) {
95 createTableSql = "CREATE TABLE IF NOT EXISTS " + formRdbConfig_.tableName
96 + " (KEY TEXT NOT NULL PRIMARY KEY, VALUE TEXT NOT NULL);";
97 } else {
98 createTableSql = formRdbConfig_.createTableSql;
99 }
100
101 int ret = rdbStore_->ExecuteSql(createTableSql);
102 if (ret != NativeRdb::E_OK) {
103 HILOG_ERROR("CreateTable failed, ret: %{public}d", ret);
104 return ERR_APPEXECFWK_FORM_COMMON_CODE;
105 }
106 return ERR_OK;
107 }
108
Init()109 ErrCode FormRdbDataMgr::Init()
110 {
111 HILOG_DEBUG("Create rdbStore");
112
113 if (rdbStore_ != nullptr) {
114 HILOG_DEBUG("FormInfoRdbStore has existed");
115 return ERR_OK;
116 }
117
118 NativeRdb::RdbStoreConfig rdbStoreConfig(
119 formRdbConfig_.dbPath + formRdbConfig_.dbName,
120 NativeRdb::StorageMode::MODE_DISK,
121 false,
122 std::vector<uint8_t>(),
123 formRdbConfig_.journalMode,
124 formRdbConfig_.syncMode,
125 "",
126 NativeRdb::SecurityLevel::S1);
127 int32_t errCode = NativeRdb::E_OK;
128 RdbStoreDataCallBackFormInfoStorage rdbDataCallBack_(formRdbConfig_);
129 rdbStore_ = NativeRdb::RdbHelper::GetRdbStore(rdbStoreConfig, formRdbConfig_.version, rdbDataCallBack_, errCode);
130 if (rdbStore_ == nullptr) {
131 HILOG_ERROR("FormInfoRdbStore init fail");
132 return ERR_APPEXECFWK_FORM_COMMON_CODE;
133 }
134
135 return CreateTable();
136 }
137
ExecuteSql(const std::string & sql)138 ErrCode FormRdbDataMgr::ExecuteSql(const std::string &sql)
139 {
140 if (rdbStore_ == nullptr) {
141 HILOG_ERROR("FormInfoRdbStore is null");
142 return ERR_APPEXECFWK_FORM_COMMON_CODE;
143 }
144
145 int ret = rdbStore_->ExecuteSql(sql);
146 if (ret != NativeRdb::E_OK) {
147 HILOG_ERROR("ExecuteSql failed, ret: %{public}d", ret);
148 return ERR_APPEXECFWK_FORM_COMMON_CODE;
149 }
150 return ERR_OK;
151 }
152
InsertData(const std::string & key)153 ErrCode FormRdbDataMgr::InsertData(const std::string &key)
154 {
155 HILOG_DEBUG("InsertData start");
156 if (rdbStore_ == nullptr) {
157 HILOG_ERROR("FormInfoRdbStore is null");
158 return ERR_APPEXECFWK_FORM_COMMON_CODE;
159 }
160
161 int64_t rowId = -1;
162 NativeRdb::ValuesBucket valuesBucket;
163 valuesBucket.PutString(FORM_KEY, key);
164 auto ret = rdbStore_->InsertWithConflictResolution(
165 rowId, formRdbConfig_.tableName, valuesBucket, NativeRdb::ConflictResolution::ON_CONFLICT_REPLACE);
166 if (ret != NativeRdb::E_OK) {
167 HILOG_ERROR("Insert operation failed, result: %{public}d, key=%{public}s.", ret, key.c_str());
168 return ERR_APPEXECFWK_FORM_COMMON_CODE;
169 }
170 return ERR_OK;
171 }
172
InsertData(const std::string & key,const std::string & value)173 ErrCode FormRdbDataMgr::InsertData(const std::string &key, const std::string &value)
174 {
175 HILOG_DEBUG("InsertData start");
176 if (rdbStore_ == nullptr) {
177 HILOG_ERROR("FormInfoRdbStore is null");
178 return ERR_APPEXECFWK_FORM_COMMON_CODE;
179 }
180
181 int64_t rowId = -1;
182 NativeRdb::ValuesBucket valuesBucket;
183 valuesBucket.PutString(FORM_KEY, key);
184 valuesBucket.PutString(FORM_VALUE, value);
185 auto ret = rdbStore_->InsertWithConflictResolution(
186 rowId, formRdbConfig_.tableName, valuesBucket, NativeRdb::ConflictResolution::ON_CONFLICT_REPLACE);
187 if (ret != NativeRdb::E_OK) {
188 HILOG_ERROR("Insert operation failed, result: %{public}d, key=%{public}s.", ret, key.c_str());
189 return ERR_APPEXECFWK_FORM_COMMON_CODE;
190 }
191 return ERR_OK;
192 }
193
DeleteData(const std::string & key)194 ErrCode FormRdbDataMgr::DeleteData(const std::string &key)
195 {
196 HILOG_DEBUG("DeleteData start");
197 if (rdbStore_ == nullptr) {
198 HILOG_ERROR("FormInfoRdbStore is null");
199 return ERR_APPEXECFWK_FORM_COMMON_CODE;
200 }
201
202 int32_t rowId = -1;
203 NativeRdb::AbsRdbPredicates absRdbPredicates(formRdbConfig_.tableName);
204 absRdbPredicates.EqualTo(FORM_KEY, key);
205 auto ret = rdbStore_->Delete(rowId, absRdbPredicates);
206 if (ret != NativeRdb::E_OK) {
207 HILOG_ERROR("Delete operation failed, result: %{public}d, key=%{public}s.",
208 ret, key.c_str());
209 return ERR_APPEXECFWK_FORM_COMMON_CODE;
210 }
211 return ERR_OK;
212 }
213
QueryData(const std::string & key,std::string & value)214 ErrCode FormRdbDataMgr::QueryData(const std::string &key, std::string &value)
215 {
216 HILOG_DEBUG("QueryData start");
217 if (rdbStore_ == nullptr) {
218 HILOG_ERROR("FormInfoRdbStore is null");
219 return ERR_APPEXECFWK_FORM_COMMON_CODE;
220 }
221
222 NativeRdb::AbsRdbPredicates absRdbPredicates(formRdbConfig_.tableName);
223 absRdbPredicates.EqualTo(FORM_KEY, key);
224 auto absSharedResultSet = rdbStore_->Query(absRdbPredicates, std::vector<std::string>());
225 if (absSharedResultSet == nullptr) {
226 HILOG_ERROR("absSharedResultSet is nullptr");
227 return false;
228 }
229
230 ScopeGuard stateGuard([absSharedResultSet] {
231 if (absSharedResultSet) {
232 absSharedResultSet->Close();
233 }
234 });
235 if (!absSharedResultSet->HasBlock()) {
236 HILOG_ERROR("absSharedResultSet has no block");
237 return false;
238 }
239 auto ret = absSharedResultSet->GoToFirstRow();
240 if (ret != NativeRdb::E_OK) {
241 HILOG_ERROR("GoToFirstRow failed, ret: %{public}d", ret);
242 return false;
243 }
244
245 ret = absSharedResultSet->GetString(FORM_VALUE_INDEX, value);
246 if (ret != NativeRdb::E_OK) {
247 HILOG_ERROR("QueryData failed, ret: %{public}d", ret);
248 return false;
249 }
250
251 return true;
252 }
253
QueryData(const std::string & key,std::unordered_map<std::string,std::string> & values)254 ErrCode FormRdbDataMgr::QueryData(const std::string &key, std::unordered_map<std::string, std::string> &values)
255 {
256 HILOG_DEBUG("QueryData start");
257 if (rdbStore_ == nullptr) {
258 HILOG_ERROR("FormInfoRdbStore is null");
259 return ERR_APPEXECFWK_FORM_COMMON_CODE;
260 }
261
262 NativeRdb::AbsRdbPredicates absRdbPredicates(formRdbConfig_.tableName);
263 absRdbPredicates.BeginsWith(FORM_KEY, key);
264 auto absSharedResultSet = rdbStore_->Query(absRdbPredicates, std::vector<std::string>());
265 if (absSharedResultSet == nullptr) {
266 HILOG_ERROR("absSharedResultSet is nullptr");
267 return ERR_APPEXECFWK_FORM_COMMON_CODE;
268 }
269
270 ScopeGuard stateGuard([absSharedResultSet] {
271 if (absSharedResultSet) {
272 absSharedResultSet->Close();
273 }
274 });
275 if (!absSharedResultSet->HasBlock()) {
276 HILOG_ERROR("absSharedResultSet has no block");
277 return ERR_APPEXECFWK_FORM_COMMON_CODE;
278 }
279
280 if (absSharedResultSet->GoToFirstRow() != NativeRdb::E_OK) {
281 HILOG_ERROR("GoToFirstRow failed");
282 return ERR_APPEXECFWK_FORM_COMMON_CODE;
283 }
284
285 do {
286 std::string resultKey;
287 if (absSharedResultSet->GetString(FORM_KEY_INDEX, resultKey) != NativeRdb::E_OK) {
288 HILOG_ERROR("GetString key failed");
289 return ERR_APPEXECFWK_FORM_COMMON_CODE;
290 }
291
292 std::string resultValue;
293 if (absSharedResultSet->GetString(FORM_VALUE_INDEX, resultValue) != NativeRdb::E_OK) {
294 HILOG_ERROR("GetString value failed");
295 return ERR_APPEXECFWK_FORM_COMMON_CODE;
296 }
297
298 values.emplace(resultKey, resultValue);
299 } while (absSharedResultSet->GoToNextRow() == NativeRdb::E_OK);
300 absSharedResultSet->Close();
301 return ERR_OK;
302 }
303
QueryAllData(std::unordered_map<std::string,std::string> & datas)304 ErrCode FormRdbDataMgr::QueryAllData(std::unordered_map<std::string, std::string> &datas)
305 {
306 HILOG_DEBUG("QueryAllData start");
307 if (rdbStore_ == nullptr) {
308 HILOG_ERROR("FormInfoRdbStore is null");
309 return ERR_APPEXECFWK_FORM_COMMON_CODE;
310 }
311
312 NativeRdb::AbsRdbPredicates absRdbPredicates(formRdbConfig_.tableName);
313 auto absSharedResultSet = rdbStore_->Query(absRdbPredicates, std::vector<std::string>());
314 if (absSharedResultSet == nullptr) {
315 HILOG_ERROR("absSharedResultSet is nullptr");
316 return ERR_APPEXECFWK_FORM_COMMON_CODE;
317 }
318
319 ScopeGuard stateGuard([absSharedResultSet] {
320 if (absSharedResultSet) {
321 absSharedResultSet->Close();
322 }
323 });
324 if (!absSharedResultSet->HasBlock()) {
325 HILOG_ERROR("absSharedResultSet has no block");
326 return ERR_APPEXECFWK_FORM_COMMON_CODE;
327 }
328
329 if (absSharedResultSet->GoToFirstRow() != NativeRdb::E_OK) {
330 HILOG_ERROR("GoToFirstRow failed");
331 return ERR_APPEXECFWK_FORM_COMMON_CODE;
332 }
333
334 do {
335 std::string resultKey;
336 if (absSharedResultSet->GetString(FORM_KEY_INDEX, resultKey) != NativeRdb::E_OK) {
337 HILOG_ERROR("GetString key failed");
338 return ERR_APPEXECFWK_FORM_COMMON_CODE;
339 }
340
341 std::string resultValue;
342 if (absSharedResultSet->GetString(FORM_VALUE_INDEX, resultValue) != NativeRdb::E_OK) {
343 HILOG_ERROR("GetString value failed");
344 return ERR_APPEXECFWK_FORM_COMMON_CODE;
345 }
346
347 datas.emplace(resultKey, resultValue);
348 } while (absSharedResultSet->GoToNextRow() == NativeRdb::E_OK);
349 return ERR_OK;
350 }
351
QueryAllKeys(std::set<std::string> & datas)352 ErrCode FormRdbDataMgr::QueryAllKeys(std::set<std::string> &datas)
353 {
354 HILOG_DEBUG("QueryAllKeys start");
355 if (rdbStore_ == nullptr) {
356 HILOG_ERROR("FormInfoRdbStore is null");
357 return ERR_APPEXECFWK_FORM_COMMON_CODE;
358 }
359
360 NativeRdb::AbsRdbPredicates absRdbPredicates(formRdbConfig_.tableName);
361 auto absSharedResultSet = rdbStore_->Query(absRdbPredicates, std::vector<std::string>());
362 if (absSharedResultSet == nullptr) {
363 HILOG_ERROR("absSharedResultSet is nullptr");
364 return ERR_APPEXECFWK_FORM_COMMON_CODE;
365 }
366
367 ScopeGuard stateGuard([absSharedResultSet] {
368 if (absSharedResultSet) {
369 absSharedResultSet->Close();
370 }
371 });
372 if (!absSharedResultSet->HasBlock() || absSharedResultSet->GoToFirstRow() != NativeRdb::E_OK) {
373 HILOG_ERROR("HasBlock or GoToFirstRow failed");
374 return ERR_APPEXECFWK_FORM_COMMON_CODE;
375 }
376
377 do {
378 std::string resultKey;
379 if (absSharedResultSet->GetString(FORM_KEY_INDEX, resultKey) != NativeRdb::E_OK) {
380 HILOG_ERROR("GetString key failed");
381 return ERR_APPEXECFWK_FORM_COMMON_CODE;
382 }
383
384 datas.insert(resultKey);
385 } while (absSharedResultSet->GoToNextRow() == NativeRdb::E_OK);
386 return ERR_OK;
387 }
388
QueryData(const NativeRdb::AbsRdbPredicates & absRdbPredicates)389 std::shared_ptr<NativeRdb::AbsSharedResultSet> FormRdbDataMgr::QueryData(
390 const NativeRdb::AbsRdbPredicates &absRdbPredicates)
391 {
392 HILOG_DEBUG("QueryData start");
393 if (rdbStore_ == nullptr) {
394 HILOG_ERROR("FormInfoRdbStore is null");
395 return nullptr;
396 }
397
398 return rdbStore_->Query(absRdbPredicates, std::vector<std::string>());
399 }
400
QuerySql(const std::string & sql)401 std::shared_ptr<NativeRdb::AbsSharedResultSet> FormRdbDataMgr::QuerySql(const std::string &sql)
402 {
403 HILOG_DEBUG("QuerySql start");
404 if (rdbStore_ == nullptr) {
405 HILOG_ERROR("FormInfoRdbStore is null");
406 return nullptr;
407 }
408
409 return rdbStore_->QuerySql(sql, std::vector<std::string>());
410 }
411
InsertData(const std::string & tableName,const NativeRdb::ValuesBucket & valuesBucket,int64_t & rowId)412 bool FormRdbDataMgr::InsertData(
413 const std::string &tableName, const NativeRdb::ValuesBucket &valuesBucket, int64_t &rowId)
414 {
415 HILOG_DEBUG("InsertData start");
416 if (rdbStore_ == nullptr) {
417 HILOG_ERROR("FormInfoRdbStore is null");
418 return false;
419 }
420
421 auto ret = rdbStore_->InsertWithConflictResolution(
422 rowId, tableName, valuesBucket, NativeRdb::ConflictResolution::ON_CONFLICT_REPLACE);
423 return ret == NativeRdb::E_OK;
424 }
425
DeleteData(const NativeRdb::AbsRdbPredicates & absRdbPredicates)426 bool FormRdbDataMgr::DeleteData(const NativeRdb::AbsRdbPredicates &absRdbPredicates)
427 {
428 if (rdbStore_ == nullptr) {
429 HILOG_ERROR("FormInfoRdbStore is null");
430 return false;
431 }
432
433 int32_t rowId = -1;
434 return rdbStore_->Delete(rowId, absRdbPredicates) == NativeRdb::E_OK;
435 }
436 } // namespace AppExecFwk
437 } // namespace OHOS