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 rdbStoreConfig.SetSecurityLevel(NativeRdb::SecurityLevel::S1);
52 int32_t errCode = NativeRdb::E_OK;
53 BmsRdbOpenCallback bmsRdbOpenCallback(bmsRdbConfig_);
54 return NativeRdb::RdbHelper::GetRdbStore(
55 rdbStoreConfig,
56 bmsRdbConfig_.version,
57 bmsRdbOpenCallback,
58 errCode);
59 }
60
InsertData(const std::string & key,const std::string & value)61 bool RdbDataManager::InsertData(const std::string &key, const std::string &value)
62 {
63 APP_LOGD("InsertData start");
64 auto rdbStore = GetRdbStore();
65 if (rdbStore == nullptr) {
66 APP_LOGE("RdbStore is null");
67 return false;
68 }
69
70 int64_t rowId = -1;
71 NativeRdb::ValuesBucket valuesBucket;
72 valuesBucket.PutString(BMS_KEY, key);
73 valuesBucket.PutString(BMS_VALUE, value);
74 auto ret = rdbStore->InsertWithConflictResolution(
75 rowId, bmsRdbConfig_.tableName, valuesBucket, NativeRdb::ConflictResolution::ON_CONFLICT_REPLACE);
76 return ret == NativeRdb::E_OK;
77 }
78
InsertData(const NativeRdb::ValuesBucket & valuesBucket)79 bool RdbDataManager::InsertData(const NativeRdb::ValuesBucket &valuesBucket)
80 {
81 APP_LOGD("InsertData start");
82 auto rdbStore = GetRdbStore();
83 if (rdbStore == nullptr) {
84 APP_LOGE("RdbStore is null");
85 return false;
86 }
87
88 int64_t rowId = -1;
89 auto ret = rdbStore->InsertWithConflictResolution(
90 rowId, bmsRdbConfig_.tableName, valuesBucket, NativeRdb::ConflictResolution::ON_CONFLICT_REPLACE);
91 return ret == NativeRdb::E_OK;
92 }
93
BatchInsert(int64_t & outInsertNum,const std::vector<NativeRdb::ValuesBucket> & valuesBuckets)94 bool RdbDataManager::BatchInsert(int64_t &outInsertNum, const std::vector<NativeRdb::ValuesBucket> &valuesBuckets)
95 {
96 APP_LOGD("BatchInsert start");
97 auto rdbStore = GetRdbStore();
98 if (rdbStore == nullptr) {
99 APP_LOGE("RdbStore is null");
100 return false;
101 }
102 auto ret = rdbStore->BatchInsert(outInsertNum, bmsRdbConfig_.tableName, valuesBuckets);
103 return ret == NativeRdb::E_OK;
104 }
105
UpdateData(const std::string & key,const std::string & value)106 bool RdbDataManager::UpdateData(const std::string &key, const std::string &value)
107 {
108 APP_LOGD("UpdateData start");
109 auto rdbStore = GetRdbStore();
110 if (rdbStore == nullptr) {
111 APP_LOGE("RdbStore is null");
112 return false;
113 }
114
115 int32_t rowId = -1;
116 NativeRdb::AbsRdbPredicates absRdbPredicates(bmsRdbConfig_.tableName);
117 absRdbPredicates.EqualTo(BMS_KEY, key);
118 NativeRdb::ValuesBucket valuesBucket;
119 valuesBucket.PutString(BMS_KEY, key);
120 valuesBucket.PutString(BMS_VALUE, value);
121 auto ret = rdbStore->Update(rowId, valuesBucket, absRdbPredicates);
122 return ret == NativeRdb::E_OK;
123 }
124
UpdateData(const NativeRdb::ValuesBucket & valuesBucket,const NativeRdb::AbsRdbPredicates & absRdbPredicates)125 bool RdbDataManager::UpdateData(
126 const NativeRdb::ValuesBucket &valuesBucket, const NativeRdb::AbsRdbPredicates &absRdbPredicates)
127 {
128 APP_LOGD("UpdateData start");
129 auto rdbStore = GetRdbStore();
130 if (rdbStore == nullptr) {
131 APP_LOGE("RdbStore is null");
132 return false;
133 }
134 if (absRdbPredicates.GetTableName() != bmsRdbConfig_.tableName) {
135 APP_LOGE("RdbStore table is invalid");
136 return false;
137 }
138 int32_t rowId = -1;
139 auto ret = rdbStore->Update(rowId, valuesBucket, absRdbPredicates);
140 return ret == NativeRdb::E_OK;
141 }
142
DeleteData(const std::string & key)143 bool RdbDataManager::DeleteData(const std::string &key)
144 {
145 APP_LOGD("DeleteData start");
146 auto rdbStore = GetRdbStore();
147 if (rdbStore == nullptr) {
148 APP_LOGE("RdbStore is null");
149 return false;
150 }
151
152 int32_t rowId = -1;
153 NativeRdb::AbsRdbPredicates absRdbPredicates(bmsRdbConfig_.tableName);
154 absRdbPredicates.EqualTo(BMS_KEY, key);
155 auto ret = rdbStore->Delete(rowId, absRdbPredicates);
156 return ret == NativeRdb::E_OK;
157 }
158
DeleteData(const NativeRdb::AbsRdbPredicates & absRdbPredicates)159 bool RdbDataManager::DeleteData(const NativeRdb::AbsRdbPredicates &absRdbPredicates)
160 {
161 auto rdbStore = GetRdbStore();
162 if (rdbStore == nullptr) {
163 APP_LOGE("RdbStore is null");
164 return false;
165 }
166 if (absRdbPredicates.GetTableName() != bmsRdbConfig_.tableName) {
167 APP_LOGE("RdbStore table is invalid");
168 return false;
169 }
170 int32_t rowId = -1;
171 auto ret = rdbStore->Delete(rowId, absRdbPredicates);
172 return ret == NativeRdb::E_OK;
173 }
174
QueryData(const std::string & key,std::string & value)175 bool RdbDataManager::QueryData(const std::string &key, std::string &value)
176 {
177 APP_LOGD("QueryData start");
178 auto rdbStore = GetRdbStore();
179 if (rdbStore == nullptr) {
180 APP_LOGE("RdbStore is null");
181 return false;
182 }
183
184 NativeRdb::AbsRdbPredicates absRdbPredicates(bmsRdbConfig_.tableName);
185 absRdbPredicates.EqualTo(BMS_KEY, key);
186 auto absSharedResultSet = rdbStore->Query(absRdbPredicates, std::vector<std::string>());
187 if (absSharedResultSet == nullptr) {
188 APP_LOGE("absSharedResultSet failed");
189 return false;
190 }
191 ScopeGuard stateGuard([&] { absSharedResultSet->Close(); });
192 if (!absSharedResultSet->HasBlock()) {
193 APP_LOGE("absSharedResultSet has no block");
194 return false;
195 }
196 auto ret = absSharedResultSet->GoToFirstRow();
197 if (ret != NativeRdb::E_OK) {
198 APP_LOGE("GoToFirstRow failed, ret: %{public}d", ret);
199 return false;
200 }
201
202 ret = absSharedResultSet->GetString(BMS_VALUE_INDEX, value);
203 if (ret != NativeRdb::E_OK) {
204 APP_LOGE("QueryData failed, ret: %{public}d", ret);
205 return false;
206 }
207
208 return true;
209 }
210
QueryData(const NativeRdb::AbsRdbPredicates & absRdbPredicates)211 std::shared_ptr<NativeRdb::AbsSharedResultSet> RdbDataManager::QueryData(
212 const NativeRdb::AbsRdbPredicates &absRdbPredicates)
213 {
214 APP_LOGD("QueryData start");
215 auto rdbStore = GetRdbStore();
216 if (rdbStore == nullptr) {
217 APP_LOGE("RdbStore is null");
218 return nullptr;
219 }
220 if (absRdbPredicates.GetTableName() != bmsRdbConfig_.tableName) {
221 APP_LOGE("RdbStore table is invalid");
222 return nullptr;
223 }
224 auto absSharedResultSet = rdbStore->Query(absRdbPredicates, std::vector<std::string>());
225 if (absSharedResultSet == nullptr || !absSharedResultSet->HasBlock()) {
226 APP_LOGE("absSharedResultSet failed");
227 return nullptr;
228 }
229 return absSharedResultSet;
230 }
231
QueryAllData(std::map<std::string,std::string> & datas)232 bool RdbDataManager::QueryAllData(std::map<std::string, std::string> &datas)
233 {
234 APP_LOGD("QueryAllData start");
235 auto rdbStore = GetRdbStore();
236 if (rdbStore == nullptr) {
237 APP_LOGE("RdbStore is null");
238 return false;
239 }
240
241 NativeRdb::AbsRdbPredicates absRdbPredicates(bmsRdbConfig_.tableName);
242 auto absSharedResultSet = rdbStore->Query(absRdbPredicates, std::vector<std::string>());
243 if (absSharedResultSet == nullptr) {
244 APP_LOGE("absSharedResultSet failed");
245 return false;
246 }
247 ScopeGuard stateGuard([&] { absSharedResultSet->Close(); });
248 if (!absSharedResultSet->HasBlock()) {
249 APP_LOGE("absSharedResultSet has no block");
250 return false;
251 }
252
253 if (absSharedResultSet->GoToFirstRow() != NativeRdb::E_OK) {
254 APP_LOGE("GoToFirstRow failed");
255 return false;
256 }
257
258 do {
259 std::string key;
260 if (absSharedResultSet->GetString(BMS_KEY_INDEX, key) != NativeRdb::E_OK) {
261 APP_LOGE("GetString key failed");
262 return false;
263 }
264
265 std::string value;
266 if (absSharedResultSet->GetString(BMS_VALUE_INDEX, value) != NativeRdb::E_OK) {
267 APP_LOGE("GetString value failed");
268 return false;
269 }
270
271 datas.emplace(key, value);
272 } while (absSharedResultSet->GoToNextRow() == NativeRdb::E_OK);
273 return !datas.empty();
274 }
275
CreateTable()276 bool RdbDataManager::CreateTable()
277 {
278 std::string createTableSql;
279 if (bmsRdbConfig_.createTableSql.empty()) {
280 createTableSql = std::string(
281 "CREATE TABLE IF NOT EXISTS "
282 + bmsRdbConfig_.tableName
283 + "(KEY TEXT NOT NULL PRIMARY KEY, VALUE TEXT NOT NULL);");
284 } else {
285 createTableSql = bmsRdbConfig_.createTableSql;
286 }
287 auto rdbStore = GetRdbStore();
288 if (rdbStore == nullptr) {
289 APP_LOGE("RdbStore is null");
290 return false;
291 }
292 int ret = rdbStore->ExecuteSql(createTableSql);
293 if (ret != NativeRdb::E_OK) {
294 APP_LOGE("CreateTable failed, ret: %{public}d", ret);
295 return false;
296 }
297 return true;
298 }
299 } // namespace AppExecFwk
300 } // namespace OHOS
301