1 /*
2 * Copyright (c) 2025 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 "grd_adapter.h"
17
18 #include <cinttypes>
19 #include <map>
20
21 #include "gdb_errors.h"
22 #include "gdb_utils.h"
23 #include "grd_adapter_manager.h"
24 #include "grd_error.h"
25
26 namespace OHOS::DistributedDataAip {
27
28 static GrdAdapterHolder g_adapterHolder;
29
30 int32_t GrdAdapter::errorCode_[FuncName::ALL] = { GRD_OK };
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
SetErrorCode(FuncName func,int32_t err)138 void GrdAdapter::SetErrorCode(FuncName func, int32_t err)
139 {
140 if (func == FuncName::ALL) {
141 for (int i = FuncName::PREPARE; i < FuncName::ALL; i++) {
142 errorCode_[i] = err;
143 }
144 } else {
145 errorCode_[func] = err;
146 }
147 }
148
Prepare(GRD_DB * db,const char * str,uint32_t strLen,GRD_StmtT ** stmt,const char ** unusedStr)149 int32_t GrdAdapter::Prepare(GRD_DB *db, const char *str, uint32_t strLen, GRD_StmtT **stmt, const char **unusedStr)
150 {
151 if (errorCode_[FuncName::PREPARE] == GRD_OK) {
152 if (g_adapterHolder.Prepare == nullptr) {
153 g_adapterHolder = GetAdapterHolder();
154 }
155 if (g_adapterHolder.Prepare == nullptr) {
156 return E_NOT_SUPPORT;
157 }
158 int32_t ret = g_adapterHolder.Prepare(db, str, strLen, stmt, unusedStr);
159 return TransErrno(ret);
160 }
161 return TransErrno(errorCode_[FuncName::PREPARE]);
162 }
163
Step(GRD_StmtT * stmt)164 int32_t GrdAdapter::Step(GRD_StmtT *stmt)
165 {
166 if (errorCode_[FuncName::STEP] == GRD_OK) {
167 if (g_adapterHolder.Step == nullptr) {
168 g_adapterHolder = GetAdapterHolder();
169 }
170 if (g_adapterHolder.Step == nullptr) {
171 return E_NOT_SUPPORT;
172 }
173 int32_t ret = g_adapterHolder.Step(stmt);
174 return TransErrno(ret);
175 }
176 return TransErrno(errorCode_[FuncName::STEP]);
177 }
178
Finalize(GRD_StmtT * stmt)179 int32_t GrdAdapter::Finalize(GRD_StmtT *stmt)
180 {
181 if (errorCode_[FuncName::FINALIZE] == GRD_OK) {
182 if (g_adapterHolder.Finalize == nullptr) {
183 g_adapterHolder = GetAdapterHolder();
184 }
185 if (g_adapterHolder.Finalize == nullptr) {
186 return E_NOT_SUPPORT;
187 }
188 int32_t ret = g_adapterHolder.Finalize(stmt);
189 return TransErrno(ret);
190 }
191 return TransErrno(errorCode_[FuncName::FINALIZE]);
192 }
193
Rekey(const char * dbFile,const char * configStr,const std::vector<uint8_t> & encryptedKey)194 int32_t GrdAdapter::Rekey(const char *dbFile, const char *configStr, const std::vector<uint8_t> &encryptedKey)
195 {
196 if (errorCode_[FuncName::REKEY] == GRD_OK) {
197 if (g_adapterHolder.Rekey == nullptr) {
198 g_adapterHolder = GetAdapterHolder();
199 }
200 if (g_adapterHolder.Rekey == nullptr) {
201 return E_NOT_SUPPORT;
202 }
203 if (encryptedKey.empty()) {
204 return E_GRD_INVALID_ARGS;
205 }
206 int32_t ret = E_OK;
207 GRD_CipherInfoT info = { 0 };
208 const size_t keySize = encryptedKey.size() * 2 + 1;
209 std::vector<char> key(keySize);
210 info.hexPassword = GdbUtils::GetEncryptKey(encryptedKey, key.data(), keySize);
211 ret = g_adapterHolder.Rekey(dbFile, configStr, &info);
212 key.assign(keySize, 0);
213 return TransErrno(ret);
214 }
215 return TransErrno(errorCode_[FuncName::REKEY]);
216 }
217
TransColType(int grdColType)218 ColumnType GrdAdapter::TransColType(int grdColType)
219 {
220 switch (grdColType) {
221 case GRD_DB_DATATYPE_INTEGER:
222 return ColumnType::TYPE_INTEGER;
223 case GRD_DB_DATATYPE_FLOAT:
224 return ColumnType::TYPE_FLOAT;
225 case GRD_DB_DATATYPE_TEXT:
226 return ColumnType::TYPE_TEXT;
227 case GRD_DB_DATATYPE_BLOB:
228 return ColumnType::TYPE_BLOB;
229 case GRD_DB_DATATYPE_FLOATVECTOR:
230 return ColumnType::TYPE_FLOATVECTOR;
231 case GRD_DB_DATATYPE_JSONSTR:
232 return ColumnType::TYPE_JSONSTR;
233 case GRD_DB_DATATYPE_NULL:
234 return ColumnType::TYPE_NULL;
235 default:
236 return ColumnType::TYPE_NULL;
237 }
238 }
239
Open(const char * dbPath,const char * configStr,uint32_t flags,GRD_DB ** db)240 int GrdAdapter::Open(const char *dbPath, const char *configStr, uint32_t flags, GRD_DB **db)
241 {
242 if (g_adapterHolder.Open == nullptr) {
243 g_adapterHolder = GetAdapterHolder();
244 }
245 if (g_adapterHolder.Open == nullptr) {
246 return E_NOT_SUPPORT;
247 }
248 auto ret = g_adapterHolder.Open(dbPath, configStr, flags, db);
249 return TransErrno(ret);
250 }
251
Close(GRD_DB * db,uint32_t flags)252 int GrdAdapter::Close(GRD_DB *db, uint32_t flags)
253 {
254 if (g_adapterHolder.Close == nullptr) {
255 g_adapterHolder = GetAdapterHolder();
256 }
257 if (g_adapterHolder.Close == nullptr) {
258 return E_NOT_SUPPORT;
259 }
260 auto ret = g_adapterHolder.Close(db, flags);
261 return TransErrno(ret);
262 }
263
Repair(const char * dbPath,const char * configStr)264 int GrdAdapter::Repair(const char *dbPath, const char *configStr)
265 {
266 if (g_adapterHolder.Repair == nullptr) {
267 g_adapterHolder = GetAdapterHolder();
268 }
269 if (g_adapterHolder.Repair == nullptr) {
270 return E_NOT_SUPPORT;
271 }
272 return E_NOT_SUPPORT;
273 }
274
Backup(GRD_DB * db,const char * backupDbFile,const std::vector<uint8_t> & encryptedKey)275 int GrdAdapter::Backup(GRD_DB *db, const char *backupDbFile, const std::vector<uint8_t> &encryptedKey)
276 {
277 if (g_adapterHolder.Backup == nullptr) {
278 g_adapterHolder = GetAdapterHolder();
279 }
280 if (g_adapterHolder.Backup == nullptr) {
281 return E_NOT_SUPPORT;
282 }
283 return E_NOT_SUPPORT;
284 }
285
Restore(const char * dbFile,const char * backupDbFile,const std::vector<uint8_t> & encryptedKey)286 int GrdAdapter::Restore(const char *dbFile, const char *backupDbFile, const std::vector<uint8_t> &encryptedKey)
287 {
288 if (g_adapterHolder.Restore == nullptr) {
289 g_adapterHolder = GetAdapterHolder();
290 }
291 if (g_adapterHolder.Restore == nullptr) {
292 return E_NOT_SUPPORT;
293 }
294 return E_NOT_SUPPORT;
295 }
296
Reset(GRD_StmtT * stmt)297 int32_t GrdAdapter::Reset(GRD_StmtT *stmt)
298 {
299 if (g_adapterHolder.Reset == nullptr) {
300 g_adapterHolder = GetAdapterHolder();
301 }
302 if (g_adapterHolder.Reset == nullptr) {
303 return E_NOT_SUPPORT;
304 }
305 return TransErrno(g_adapterHolder.Reset(stmt));
306 }
307
ColumnCount(GRD_StmtT * stmt)308 uint32_t GrdAdapter::ColumnCount(GRD_StmtT *stmt)
309 {
310 if (g_adapterHolder.ColumnCount == nullptr) {
311 g_adapterHolder = GetAdapterHolder();
312 }
313 if (g_adapterHolder.ColumnCount == nullptr) {
314 return E_NOT_SUPPORT;
315 }
316 return g_adapterHolder.ColumnCount(stmt);
317 }
318
ColumnType(GRD_StmtT * stmt,uint32_t idx)319 GRD_DbDataTypeE GrdAdapter::ColumnType(GRD_StmtT *stmt, uint32_t idx)
320 {
321 if (g_adapterHolder.GetColumnType == nullptr) {
322 g_adapterHolder = GetAdapterHolder();
323 }
324 if (g_adapterHolder.GetColumnType == nullptr) {
325 return GRD_DB_DATATYPE_NULL;
326 }
327 return g_adapterHolder.GetColumnType(stmt, idx);
328 }
329
ColumnBytes(GRD_StmtT * stmt,uint32_t idx)330 uint32_t GrdAdapter::ColumnBytes(GRD_StmtT *stmt, uint32_t idx)
331 {
332 if (g_adapterHolder.ColumnBytes == nullptr) {
333 g_adapterHolder = GetAdapterHolder();
334 }
335 if (g_adapterHolder.ColumnBytes == nullptr) {
336 return E_NOT_SUPPORT;
337 }
338 return g_adapterHolder.ColumnBytes(stmt, idx);
339 }
340
ColumnName(GRD_StmtT * stmt,uint32_t idx)341 char *GrdAdapter::ColumnName(GRD_StmtT *stmt, uint32_t idx)
342 {
343 if (g_adapterHolder.ColumnName == nullptr) {
344 g_adapterHolder = GetAdapterHolder();
345 }
346 if (g_adapterHolder.ColumnName == nullptr) {
347 return nullptr;
348 }
349 return g_adapterHolder.ColumnName(stmt, idx);
350 }
351
ColumnValue(GRD_StmtT * stmt,uint32_t idx)352 GRD_DbValueT GrdAdapter::ColumnValue(GRD_StmtT *stmt, uint32_t idx)
353 {
354 if (g_adapterHolder.ColumnValue == nullptr) {
355 g_adapterHolder = GetAdapterHolder();
356 }
357 if (g_adapterHolder.ColumnValue == nullptr) {
358 return {};
359 }
360 return g_adapterHolder.ColumnValue(stmt, idx);
361 }
362
ColumnInt64(GRD_StmtT * stmt,uint32_t idx)363 int64_t GrdAdapter::ColumnInt64(GRD_StmtT *stmt, uint32_t idx)
364 {
365 if (g_adapterHolder.ColumnInt64 == nullptr) {
366 g_adapterHolder = GetAdapterHolder();
367 }
368 if (g_adapterHolder.ColumnInt64 == nullptr) {
369 return 0;
370 }
371 return g_adapterHolder.ColumnInt64(stmt, idx);
372 }
373
ColumnInt(GRD_StmtT * stmt,uint32_t idx)374 int32_t GrdAdapter::ColumnInt(GRD_StmtT *stmt, uint32_t idx)
375 {
376 if (g_adapterHolder.ColumnInt == nullptr) {
377 g_adapterHolder = GetAdapterHolder();
378 }
379 if (g_adapterHolder.ColumnInt == nullptr) {
380 return 0;
381 }
382 return g_adapterHolder.ColumnInt(stmt, idx);
383 }
384
ColumnDouble(GRD_StmtT * stmt,uint32_t idx)385 double GrdAdapter::ColumnDouble(GRD_StmtT *stmt, uint32_t idx)
386 {
387 if (g_adapterHolder.ColumnDouble == nullptr) {
388 g_adapterHolder = GetAdapterHolder();
389 }
390 if (g_adapterHolder.ColumnDouble == nullptr) {
391 return 0;
392 }
393 return g_adapterHolder.ColumnDouble(stmt, idx);
394 }
395
ColumnText(GRD_StmtT * stmt,uint32_t idx)396 const char *GrdAdapter::ColumnText(GRD_StmtT *stmt, uint32_t idx)
397 {
398 if (g_adapterHolder.ColumnText == nullptr) {
399 g_adapterHolder = GetAdapterHolder();
400 }
401 if (g_adapterHolder.ColumnText == nullptr) {
402 return nullptr;
403 }
404 return g_adapterHolder.ColumnText(stmt, idx);
405 }
406 }
407
408