1 /*
2 * Copyright (c) 2024 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 #define LOG_TAG "GrdAdapter"
16
17 #include "grd_adapter.h"
18
19 #include <cinttypes>
20 #include <map>
21
22 #include "gdb_errors.h"
23 #include "gdb_utils.h"
24 #include "grd_adapter_manager.h"
25 #include "grd_error.h"
26 #include "logger.h"
27
28 namespace OHOS::DistributedDataAip {
29
30 static GrdAdapterHolder g_adapterHolder;
31
32 std::map<int32_t, int32_t> GrdAdapter::GRD_ERRNO_MAP = {
33 { GRD_OK, E_OK },
34 { GRD_REBUILD_DATABASE, E_OK },
35 { GRD_NO_DATA, E_GRD_NO_DATA },
36 { GRD_DATA_CORRUPTED, E_GRD_DATA_CORRUPTED },
37 { GRD_INVALID_FILE_FORMAT, E_GRD_INVALID_FILE_FORMAT },
38 { GRD_PRIMARY_KEY_VIOLATION, E_GRD_DATA_CONFLICT },
39 { GRD_RESTRICT_VIOLATION, E_GRD_DATA_CONFLICT },
40 { GRD_CONSTRAINT_CHECK_VIOLATION, E_GRD_DATA_CONFLICT },
41 { GRD_NOT_SUPPORT, E_GRD_NOT_SUPPORT },
42 { GRD_OVER_LIMIT, E_GRD_OVER_LIMIT },
43 { GRD_INVALID_ARGS, E_GRD_INVALID_ARGS },
44 { GRD_FAILED_FILE_OPERATION, E_GRD_FAILED_FILE_OPERATION },
45 { GRD_INSUFFICIENT_SPACE, E_GRD_DISK_SPACE_FULL },
46 { GRD_RESOURCE_BUSY, E_DATABASE_BUSY },
47 { GRD_DB_BUSY, E_DATABASE_BUSY },
48 { GRD_FAILED_MEMORY_ALLOCATE, E_GRD_FAILED_MEMORY_ALLOCATE },
49 { GRD_CRC_CHECK_DISABLED, E_GRD_CRC_CHECK_DISABLED },
50 { GRD_DISK_SPACE_FULL, E_GRD_DISK_SPACE_FULL },
51
52 { GRD_PERMISSION_DENIED, E_GRD_PERMISSION_DENIED },
53 { GRD_PASSWORD_UNMATCHED, E_GRD_PASSWORD_UNMATCHED },
54 { GRD_PASSWORD_NEED_REKEY, E_GRD_PASSWORD_NEED_REKEY },
55
56 { GRD_NAME_TOO_LONG, E_GRD_INVALID_NAME },
57 { GRD_INVALID_TABLE_DEFINITION, E_GRD_SEMANTIC_ERROR },
58 { GRD_SEMANTIC_ERROR, E_GRD_SEMANTIC_ERROR },
59 { GRD_SYNTAX_ERROR, E_GRD_SYNTAX_ERROR },
60 { GRD_WRONG_STMT_OBJECT, E_GRD_WRONG_STMT_OBJECT },
61 { GRD_DATA_CONFLICT, E_GRD_DATA_CONFLICT },
62
63 { GRD_INNER_ERR, E_GRD_INNER_ERR },
64 { GRD_FAILED_MEMORY_RELEASE, E_GRD_FAILED_MEMORY_RELEASE },
65 { GRD_NOT_AVAILABLE, E_GRD_NOT_AVAILABLE },
66 { GRD_INVALID_FORMAT, E_GRD_SEMANTIC_ERROR },
67 { GRD_TIME_OUT, E_DATABASE_BUSY },
68 { GRD_DB_INSTANCE_ABNORMAL, E_GRD_DB_INSTANCE_ABNORMAL },
69 { GRD_CIPHER_ERROR, E_GRD_CIPHER_ERROR },
70 { GRD_DUPLICATE_TABLE, E_GRD_DUPLICATE_PARAM },
71 { GRD_DUPLICATE_OBJECT, E_GRD_DUPLICATE_PARAM },
72 { GRD_DUPLICATE_COLUMN, E_GRD_DUPLICATE_PARAM },
73 { GRD_UNDEFINE_COLUMN, E_GRD_UNDEFINED_PARAM },
74 { GRD_UNDEFINED_OBJECT, E_GRD_UNDEFINED_PARAM },
75 { GRD_UNDEFINED_TABLE, E_GRD_UNDEFINED_PARAM },
76 { GRD_INVALID_CONFIG_VALUE, E_CONFIG_INVALID_CHANGE },
77 { GRD_REQUEST_TIME_OUT, E_DATABASE_BUSY },
78 { GRD_DATATYPE_MISMATCH, E_GRD_SEMANTIC_ERROR },
79 { GRD_UNIQUE_VIOLATION, E_GRD_DATA_CONFLICT },
80 { GRD_INVALID_BIND_VALUE, E_GRD_INVALID_BIND_VALUE },
81 { GRD_JSON_OPERATION_NOT_SUPPORT, E_GRD_SEMANTIC_ERROR },
82 { GRD_MODEL_NOT_SUPPORT, E_GRD_SEMANTIC_ERROR },
83 { GRD_FEATURE_NOT_SUPPORTED, E_GRD_SEMANTIC_ERROR },
84 { GRD_JSON_LEN_LIMIT, E_GRD_DATA_CONFLICT },
85 { GRD_SUBSCRIPTION_EXCEEDED_LIMIT, E_GRD_INNER_ERR },
86 { GRD_SYNC_EXCEED_TASK_QUEUE_LIMIT, E_DATABASE_BUSY },
87 { GRD_SHARED_OBJ_ENABLE_UNDO_EXCEED_LIMIT, E_GRD_INNER_ERR },
88 { GRD_TABLE_LIMIT_EXCEEDED, E_GRD_OVER_LIMIT },
89 { GRD_FIELD_TYPE_NOT_MATCH, E_GRD_SEMANTIC_ERROR },
90 { GRD_LARGE_JSON_NEST, E_GRD_SEMANTIC_ERROR },
91 { GRD_INVALID_JSON_TYPE, E_GRD_SEMANTIC_ERROR },
92 { GRD_INVALID_OPERATOR, E_GRD_SEMANTIC_ERROR },
93 { GRD_INVALID_PROJECTION_FIELD, E_GRD_SEMANTIC_ERROR },
94 { GRD_INVALID_PROJECTION_VALUE, E_GRD_SEMANTIC_ERROR },
95 { GRD_DB_NOT_EXIST, E_GRD_DB_NOT_EXIST },
96 { GRD_INVALID_VALUE, E_GRD_INVALID_ARGS },
97 { GRD_SHARED_OBJ_NOT_EXIST, E_GRD_DATA_NOT_FOUND },
98 { GRD_SUBSCRIBE_NOT_EXIST, E_GRD_DATA_NOT_FOUND },
99 { GRD_COLLECTION_NOT_EXIST, E_GRD_DATA_NOT_FOUND },
100 { GRD_RESULTSET_BUSY, E_DATABASE_BUSY },
101 { GRD_RECORD_NOT_FOUND, E_GRD_DATA_NOT_FOUND },
102 { GRD_FIELD_NOT_FOUND, E_GRD_DATA_NOT_FOUND },
103 { GRD_ARRAY_INDEX_NOT_FOUND, E_GRD_DATA_NOT_FOUND },
104 { GRD_RESULT_SET_NOT_AVAILABLE, E_GRD_DATA_NOT_FOUND },
105 { GRD_SHARED_OBJ_UNDO_NOT_AVAILABLE, E_GRD_DATA_NOT_FOUND },
106 { GRD_SHARED_OBJ_REDO_NOT_AVAILABLE, E_GRD_DATA_NOT_FOUND },
107 { GRD_INVALID_JSON_FORMAT, E_GRD_DATA_CONFLICT },
108 { GRD_INVALID_KEY_FORMAT, E_GRD_INVALID_NAME },
109 { GRD_INVALID_COLLECTION_NAME, E_GRD_INVALID_NAME },
110 { GRD_INVALID_EQUIP_ID, E_GRD_SEMANTIC_ERROR },
111 { GRD_KEY_CONFLICT, E_GRD_DATA_CONFLICT },
112 { GRD_FIELD_TYPE_CONFLICT, E_GRD_DATA_CONFLICT },
113 { GRD_SHARED_OBJ_CONFLICT, E_GRD_DATA_CONFLICT },
114 { GRD_SUBSCRIBE_CONFLICT, E_GRD_DATA_CONFLICT },
115 { GRD_EQUIP_ID_CONFLICT, E_GRD_DATA_CONFLICT },
116 { GRD_SHARED_OBJ_ENABLE_UNDO_CONFLICT, E_GRD_DATA_CONFLICT },
117 { GRD_SCHEMA_CHANGED, E_CONFIG_INVALID_CHANGE },
118 { GRD_DATA_EXCEPTION, E_GRD_DATA_EXCEPTION },
119 { GRD_FIELD_OVERFLOW, E_GRD_SEMANTIC_ERROR },
120 { GRD_DIVISION_BY_ZERO, E_GRD_SYNTAX_ERROR },
121 { GRD_TRANSACTION_ROLLBACK, E_GRD_TRANSACTION_ROLLBACK },
122 { GRD_NO_ACTIVE_TRANSACTION, E_GRD_NO_ACTIVE_TRANSACTION },
123 { GRD_ACTIVE_TRANSACTION, E_GRD_ACTIVE_TRANSACTION },
124 };
125
TransErrno(int err)126 int GrdAdapter::TransErrno(int err)
127 {
128 if (err > 0) {
129 return err;
130 }
131 auto result = GRD_ERRNO_MAP.find(err);
132 if (result != GRD_ERRNO_MAP.end()) {
133 return result->second;
134 }
135 return E_GRD_INNER_ERR;
136 }
137
TransColType(int grdColType)138 ColumnType GrdAdapter::TransColType(int grdColType)
139 {
140 switch (grdColType) {
141 case GRD_DB_DATATYPE_INTEGER:
142 return ColumnType::TYPE_INTEGER;
143 case GRD_DB_DATATYPE_FLOAT:
144 return ColumnType::TYPE_FLOAT;
145 case GRD_DB_DATATYPE_TEXT:
146 return ColumnType::TYPE_TEXT;
147 case GRD_DB_DATATYPE_BLOB:
148 return ColumnType::TYPE_BLOB;
149 case GRD_DB_DATATYPE_FLOATVECTOR:
150 return ColumnType::TYPE_FLOATVECTOR;
151 case GRD_DB_DATATYPE_JSONSTR:
152 return ColumnType::TYPE_JSONSTR;
153 case GRD_DB_DATATYPE_NULL:
154 return ColumnType::TYPE_NULL;
155 default:
156 LOG_ERROR("trans failed. GRD_DbDataTypeE=%{public}d.", grdColType);
157 return ColumnType::TYPE_NULL;
158 }
159 }
160
Open(const char * dbPath,const char * configStr,uint32_t flags,GRD_DB ** db)161 int GrdAdapter::Open(const char *dbPath, const char *configStr, uint32_t flags, GRD_DB **db)
162 {
163 if (g_adapterHolder.Open == nullptr) {
164 g_adapterHolder = GetAdapterHolder();
165 }
166 if (g_adapterHolder.Open == nullptr) {
167 return E_NOT_SUPPORT;
168 }
169 auto ret = g_adapterHolder.Open(dbPath, configStr, flags, db);
170 return TransErrno(ret);
171 }
172
Close(GRD_DB * db,uint32_t flags)173 int GrdAdapter::Close(GRD_DB *db, uint32_t flags)
174 {
175 if (g_adapterHolder.Close == nullptr) {
176 g_adapterHolder = GetAdapterHolder();
177 }
178 if (g_adapterHolder.Close == nullptr) {
179 return E_NOT_SUPPORT;
180 }
181 auto ret = g_adapterHolder.Close(db, flags);
182 LOG_DEBUG("Close ret=%{public}d", ret);
183 return TransErrno(ret);
184 }
185
Repair(const char * dbPath,const char * configStr)186 int GrdAdapter::Repair(const char *dbPath, const char *configStr)
187 {
188 if (g_adapterHolder.Repair == nullptr) {
189 g_adapterHolder = GetAdapterHolder();
190 }
191 if (g_adapterHolder.Repair == nullptr) {
192 return E_NOT_SUPPORT;
193 }
194 return E_NOT_SUPPORT;
195 }
196
Backup(GRD_DB * db,const char * backupDbFile,const std::vector<uint8_t> & encryptedKey)197 int GrdAdapter::Backup(GRD_DB *db, const char *backupDbFile, const std::vector<uint8_t> &encryptedKey)
198 {
199 if (g_adapterHolder.Backup == nullptr) {
200 g_adapterHolder = GetAdapterHolder();
201 }
202 if (g_adapterHolder.Backup == nullptr) {
203 return E_NOT_SUPPORT;
204 }
205 return E_NOT_SUPPORT;
206 }
207
Restore(const char * dbFile,const char * backupDbFile,const std::vector<uint8_t> & encryptedKey)208 int GrdAdapter::Restore(const char *dbFile, const char *backupDbFile, const std::vector<uint8_t> &encryptedKey)
209 {
210 if (g_adapterHolder.Restore == nullptr) {
211 g_adapterHolder = GetAdapterHolder();
212 }
213 if (g_adapterHolder.Restore == nullptr) {
214 return E_NOT_SUPPORT;
215 }
216 return E_NOT_SUPPORT;
217 }
218
Rekey(const char * dbFile,const char * configStr,const std::vector<uint8_t> & encryptedKey)219 int GrdAdapter::Rekey(const char *dbFile, const char *configStr, const std::vector<uint8_t> &encryptedKey)
220 {
221 if (g_adapterHolder.Rekey == nullptr) {
222 g_adapterHolder = GetAdapterHolder();
223 }
224 if (g_adapterHolder.Rekey == nullptr) {
225 return E_NOT_SUPPORT;
226 }
227 if (encryptedKey.empty()) {
228 return E_GRD_INVALID_ARGS;
229 }
230 int32_t ret = E_OK;
231 GRD_CipherInfoT info = { 0 };
232 const size_t keySize = encryptedKey.size() * 2 + 1; // 2 hex number can represent a uint8_t, 1 is for '\0'
233 std::vector<char> key(keySize);
234 info.hexPassword = GdbUtils::GetEncryptKey(encryptedKey, key.data(), keySize);
235 ret = g_adapterHolder.Rekey(dbFile, configStr, &info);
236 key.assign(keySize, 0);
237 return TransErrno(ret);
238 }
239
Prepare(GRD_DB * db,const char * str,uint32_t strLen,GRD_StmtT ** stmt,const char ** unusedStr)240 int32_t GrdAdapter::Prepare(GRD_DB *db, const char *str, uint32_t strLen, GRD_StmtT **stmt, const char **unusedStr)
241 {
242 if (g_adapterHolder.Prepare == nullptr) {
243 g_adapterHolder = GetAdapterHolder();
244 }
245 if (g_adapterHolder.Prepare == nullptr) {
246 return E_NOT_SUPPORT;
247 }
248 int32_t ret = g_adapterHolder.Prepare(db, str, strLen, stmt, unusedStr);
249 return TransErrno(ret);
250 }
251
Reset(GRD_StmtT * stmt)252 int32_t GrdAdapter::Reset(GRD_StmtT *stmt)
253 {
254 if (g_adapterHolder.Reset == nullptr) {
255 g_adapterHolder = GetAdapterHolder();
256 }
257 if (g_adapterHolder.Reset == nullptr) {
258 return E_NOT_SUPPORT;
259 }
260 return TransErrno(g_adapterHolder.Reset(stmt));
261 }
262
Finalize(GRD_StmtT * stmt)263 int32_t GrdAdapter::Finalize(GRD_StmtT *stmt)
264 {
265 if (g_adapterHolder.Finalize == nullptr) {
266 g_adapterHolder = GetAdapterHolder();
267 }
268 if (g_adapterHolder.Finalize == nullptr) {
269 return E_NOT_SUPPORT;
270 }
271 int32_t ret = g_adapterHolder.Finalize(stmt);
272 LOG_DEBUG("Finalize ret=%{public}d", ret);
273 return TransErrno(ret);
274 }
275
Step(GRD_StmtT * stmt)276 int32_t GrdAdapter::Step(GRD_StmtT *stmt)
277 {
278 if (g_adapterHolder.Step == nullptr) {
279 g_adapterHolder = GetAdapterHolder();
280 }
281 if (g_adapterHolder.Step == nullptr) {
282 return E_NOT_SUPPORT;
283 }
284 int32_t ret = g_adapterHolder.Step(stmt);
285 LOG_DEBUG("Step ret=%{public}d", ret);
286 return TransErrno(ret);
287 }
288
ColumnCount(GRD_StmtT * stmt)289 uint32_t GrdAdapter::ColumnCount(GRD_StmtT *stmt)
290 {
291 if (g_adapterHolder.ColumnCount == nullptr) {
292 g_adapterHolder = GetAdapterHolder();
293 }
294 if (g_adapterHolder.ColumnCount == nullptr) {
295 return E_NOT_SUPPORT;
296 }
297 return g_adapterHolder.ColumnCount(stmt);
298 }
299
ColumnType(GRD_StmtT * stmt,uint32_t idx)300 GRD_DbDataTypeE GrdAdapter::ColumnType(GRD_StmtT *stmt, uint32_t idx)
301 {
302 if (g_adapterHolder.GetColumnType == nullptr) {
303 g_adapterHolder = GetAdapterHolder();
304 }
305 if (g_adapterHolder.GetColumnType == nullptr) {
306 return GRD_DB_DATATYPE_NULL;
307 }
308 return g_adapterHolder.GetColumnType(stmt, idx);
309 }
310
ColumnBytes(GRD_StmtT * stmt,uint32_t idx)311 uint32_t GrdAdapter::ColumnBytes(GRD_StmtT *stmt, uint32_t idx)
312 {
313 if (g_adapterHolder.ColumnBytes == nullptr) {
314 g_adapterHolder = GetAdapterHolder();
315 }
316 if (g_adapterHolder.ColumnBytes == nullptr) {
317 return E_NOT_SUPPORT;
318 }
319 return g_adapterHolder.ColumnBytes(stmt, idx);
320 }
321
ColumnName(GRD_StmtT * stmt,uint32_t idx)322 char *GrdAdapter::ColumnName(GRD_StmtT *stmt, uint32_t idx)
323 {
324 if (g_adapterHolder.ColumnName == nullptr) {
325 g_adapterHolder = GetAdapterHolder();
326 }
327 if (g_adapterHolder.ColumnName == nullptr) {
328 return nullptr;
329 }
330 return g_adapterHolder.ColumnName(stmt, idx);
331 }
332
ColumnValue(GRD_StmtT * stmt,uint32_t idx)333 GRD_DbValueT GrdAdapter::ColumnValue(GRD_StmtT *stmt, uint32_t idx)
334 {
335 if (g_adapterHolder.ColumnValue == nullptr) {
336 g_adapterHolder = GetAdapterHolder();
337 }
338 if (g_adapterHolder.ColumnValue == nullptr) {
339 return {};
340 }
341 return g_adapterHolder.ColumnValue(stmt, idx);
342 }
343
ColumnInt64(GRD_StmtT * stmt,uint32_t idx)344 int64_t GrdAdapter::ColumnInt64(GRD_StmtT *stmt, uint32_t idx)
345 {
346 if (g_adapterHolder.ColumnInt64 == nullptr) {
347 g_adapterHolder = GetAdapterHolder();
348 }
349 if (g_adapterHolder.ColumnInt64 == nullptr) {
350 return 0;
351 }
352 return g_adapterHolder.ColumnInt64(stmt, idx);
353 }
354
ColumnInt(GRD_StmtT * stmt,uint32_t idx)355 int32_t GrdAdapter::ColumnInt(GRD_StmtT *stmt, uint32_t idx)
356 {
357 if (g_adapterHolder.ColumnInt == nullptr) {
358 g_adapterHolder = GetAdapterHolder();
359 }
360 if (g_adapterHolder.ColumnInt == nullptr) {
361 return 0;
362 }
363 return g_adapterHolder.ColumnInt(stmt, idx);
364 }
365
ColumnDouble(GRD_StmtT * stmt,uint32_t idx)366 double GrdAdapter::ColumnDouble(GRD_StmtT *stmt, uint32_t idx)
367 {
368 if (g_adapterHolder.ColumnDouble == nullptr) {
369 g_adapterHolder = GetAdapterHolder();
370 }
371 if (g_adapterHolder.ColumnDouble == nullptr) {
372 return 0;
373 }
374 return g_adapterHolder.ColumnDouble(stmt, idx);
375 }
376
ColumnText(GRD_StmtT * stmt,uint32_t idx)377 const char *GrdAdapter::ColumnText(GRD_StmtT *stmt, uint32_t idx)
378 {
379 if (g_adapterHolder.ColumnText == nullptr) {
380 g_adapterHolder = GetAdapterHolder();
381 }
382 if (g_adapterHolder.ColumnText == nullptr) {
383 return nullptr;
384 }
385 return g_adapterHolder.ColumnText(stmt, idx);
386 }
387
388 } // namespace OHOS::DistributedDataAip
389