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
16 #define LOG_TAG "RdUtils"
17 #include "rd_utils.h"
18
19 #include <securec.h>
20
21 #include "grd_error.h"
22 #include "grd_api_manager.h"
23 #include "logger.h"
24 #include "remote_result_set.h"
25
26 namespace OHOS {
27 namespace NativeRdb {
28 using namespace OHOS::Rdb;
29
30 static GRD_APIInfo GRD_KVApiInfo;
31
32 struct GrdErrnoPair {
33 int32_t grdCode;
34 int kvDbCode;
35 };
36
37 const GrdErrnoPair GRD_ERRNO_MAP[] = {
38 { GRD_OK, E_OK },
39 { GRD_NO_DATA, E_NO_MORE_ROWS },
40 { GRD_INNER_ERR, E_ERROR },
41 { GRD_DATA_CORRUPTED, E_SQLITE_CORRUPT },
42 { GRD_INVALID_FILE_FORMAT, E_SQLITE_CORRUPT },
43 };
44
TransferGrdErrno(int err)45 int RdUtils::TransferGrdErrno(int err)
46 {
47 if (err > 0) {
48 return err;
49 }
50 for (const auto &item : GRD_ERRNO_MAP) {
51 if (item.grdCode == err) {
52 return item.kvDbCode;
53 }
54 }
55 return E_ERROR;
56 }
57
TransferGrdTypeToColType(int grdColType)58 ColumnType RdUtils::TransferGrdTypeToColType(int grdColType)
59 {
60 switch (grdColType) {
61 case GRD_DB_DATATYPE_INTEGER:
62 return ColumnType::TYPE_INTEGER;
63 case GRD_DB_DATATYPE_FLOAT:
64 return ColumnType::TYPE_FLOAT;
65 case GRD_DB_DATATYPE_TEXT:
66 return ColumnType::TYPE_STRING;
67 case GRD_DB_DATATYPE_BLOB:
68 return ColumnType::TYPE_BLOB;
69 case GRD_DB_DATATYPE_FLOATVECTOR:
70 return ColumnType::TYPE_FLOAT32_ARRAY;
71 default:
72 break;
73 }
74 return ColumnType::TYPE_NULL;
75 }
76
RdDbOpen(const char * dbPath,const char * configStr,uint32_t flags,GRD_DB ** db)77 int RdUtils::RdDbOpen(const char *dbPath, const char *configStr, uint32_t flags, GRD_DB **db)
78 {
79 if (GRD_KVApiInfo.DBOpenApi == nullptr) {
80 GRD_KVApiInfo = GetApiInfoInstance();
81 }
82 if (GRD_KVApiInfo.DBOpenApi == nullptr) {
83 return TransferGrdErrno(GRD_INNER_ERR);
84 }
85 return TransferGrdErrno(GRD_KVApiInfo.DBOpenApi(dbPath, configStr, flags, db));
86 }
87
RdDbClose(GRD_DB * db,uint32_t flags)88 int RdUtils::RdDbClose(GRD_DB *db, uint32_t flags)
89 {
90 LOG_DEBUG("[RdUtils::RdDbClose]");
91 if (GRD_KVApiInfo.DBCloseApi == nullptr) {
92 GRD_KVApiInfo = GetApiInfoInstance();
93 }
94 if (GRD_KVApiInfo.DBCloseApi == nullptr) {
95 return TransferGrdErrno(GRD_INNER_ERR);
96 }
97 return TransferGrdErrno(GRD_KVApiInfo.DBCloseApi(db, flags));
98 }
99
RdDbRepair(const char * dbPath,const char * configStr)100 int RdUtils::RdDbRepair(const char *dbPath, const char *configStr)
101 {
102 LOG_DEBUG("[RdUtils::RdDbRepair]");
103 if (GRD_KVApiInfo.DBRepairApi == nullptr) {
104 GRD_KVApiInfo = GetApiInfoInstance();
105 }
106 if (GRD_KVApiInfo.DBRepairApi == nullptr) {
107 return TransferGrdErrno(GRD_INNER_ERR);
108 }
109 return TransferGrdErrno(GRD_KVApiInfo.DBRepairApi(dbPath, configStr));
110 }
111
RdSqlPrepare(GRD_DB * db,const char * str,uint32_t strLen,GRD_SqlStmt ** stmt,const char ** unusedStr)112 int RdUtils::RdSqlPrepare(GRD_DB *db, const char *str, uint32_t strLen, GRD_SqlStmt **stmt, const char **unusedStr)
113 {
114 LOG_DEBUG("[RdUtils::RdSqlPrepare]");
115 if (GRD_KVApiInfo.DBSqlPrepare == nullptr) {
116 GRD_KVApiInfo = GetApiInfoInstance();
117 }
118 if (GRD_KVApiInfo.DBSqlPrepare == nullptr) {
119 return TransferGrdErrno(GRD_INNER_ERR);
120 }
121 return TransferGrdErrno(GRD_KVApiInfo.DBSqlPrepare(db, str, strLen, stmt, unusedStr));
122 }
123
RdSqlReset(GRD_SqlStmt * stmt)124 int RdUtils::RdSqlReset(GRD_SqlStmt *stmt)
125 {
126 LOG_DEBUG("[RdUtils::RdSqlReset]");
127 if (GRD_KVApiInfo.DBSqlReset == nullptr) {
128 GRD_KVApiInfo = GetApiInfoInstance();
129 }
130 if (GRD_KVApiInfo.DBSqlReset == nullptr) {
131 return TransferGrdErrno(GRD_INNER_ERR);
132 }
133 return TransferGrdErrno(GRD_KVApiInfo.DBSqlReset(stmt));
134 }
135
RdSqlFinalize(GRD_SqlStmt * stmt)136 int RdUtils::RdSqlFinalize(GRD_SqlStmt *stmt)
137 {
138 LOG_DEBUG("[RdUtils::RdSqlFinalize]");
139 if (GRD_KVApiInfo.DBSqlFinalize == nullptr) {
140 GRD_KVApiInfo = GetApiInfoInstance();
141 }
142 if (GRD_KVApiInfo.DBSqlFinalize == nullptr) {
143 return TransferGrdErrno(GRD_INNER_ERR);
144 }
145 return TransferGrdErrno(GRD_KVApiInfo.DBSqlFinalize(stmt));
146 }
147
RdSqlFreeBlob(void * blobElementSize)148 void RdSqlFreeBlob(void *blobElementSize)
149 {
150 delete[] ((uint8_t *)blobElementSize);
151 }
152
RdSqlBindBlob(GRD_SqlStmt * stmt,uint32_t idx,const void * val,int32_t len,void (* freeFunc)(void *))153 int RdUtils::RdSqlBindBlob(GRD_SqlStmt *stmt, uint32_t idx, const void *val, int32_t len, void (*freeFunc)(void *))
154 {
155 LOG_DEBUG("[RdUtils::RdSqlBindBlob]");
156 if (GRD_KVApiInfo.DBSqlBindBlob == nullptr) {
157 GRD_KVApiInfo = GetApiInfoInstance();
158 }
159 if (GRD_KVApiInfo.DBSqlBindBlob == nullptr) {
160 return TransferGrdErrno(GRD_INNER_ERR);
161 }
162 if (len <= 0) {
163 LOG_ERROR("Invalid len %{public}d", len);
164 return E_INVALID_ARGS;
165 }
166 uint8_t *tmpVal = new uint8_t[len]();
167 if (tmpVal == nullptr) {
168 return E_ERROR;
169 }
170 errno_t err = memcpy_s(tmpVal, len * sizeof(uint8_t), val, len * sizeof(uint8_t));
171 if (err < 0) {
172 delete[] tmpVal;
173 LOG_ERROR("BindBlob failed due to memcpy %{public}d, len is %{public}d", err, len);
174 return TransferGrdErrno(GRD_INNER_ERR);
175 }
176 if (freeFunc == nullptr) {
177 freeFunc = RdSqlFreeBlob;
178 }
179 return TransferGrdErrno(GRD_KVApiInfo.DBSqlBindBlob(stmt, idx, tmpVal, len, freeFunc));
180 }
181
RdSqlFreeCharStr(void * charStr)182 void RdSqlFreeCharStr(void *charStr)
183 {
184 delete[] ((char *)charStr);
185 }
186
RdSqlBindText(GRD_SqlStmt * stmt,uint32_t idx,const void * val,int32_t len,void (* freeFunc)(void *))187 int RdUtils::RdSqlBindText(GRD_SqlStmt *stmt, uint32_t idx, const void *val, int32_t len, void (*freeFunc)(void *))
188 {
189 LOG_DEBUG("[RdUtils::RdSqlBindText]");
190 if (GRD_KVApiInfo.DBSqlBindText == nullptr) {
191 GRD_KVApiInfo = GetApiInfoInstance();
192 }
193 if (GRD_KVApiInfo.DBSqlBindText == nullptr) {
194 return TransferGrdErrno(GRD_INNER_ERR);
195 }
196 if (len <= 0) {
197 LOG_ERROR("Invalid len %{public}d", len);
198 return E_INVALID_ARGS;
199 }
200 char *tmpVal = new char[len + 1]();
201 if (tmpVal == nullptr) {
202 return E_ERROR;
203 }
204 errno_t err = strcpy_s(tmpVal, len + 1, (const char *)val);
205 if (err < 0) {
206 LOG_ERROR("BindText failed due to strycpy %{public}d, len is %{public}d", err, len + 1);
207 delete[] tmpVal;
208 return TransferGrdErrno(GRD_INNER_ERR);
209 }
210 if (freeFunc == nullptr) {
211 freeFunc = RdSqlFreeCharStr;
212 }
213 return TransferGrdErrno(GRD_KVApiInfo.DBSqlBindText(stmt, idx, tmpVal, len, freeFunc));
214 }
215
RdSqlBindInt(GRD_SqlStmt * stmt,uint32_t idx,int32_t val)216 int RdUtils::RdSqlBindInt(GRD_SqlStmt *stmt, uint32_t idx, int32_t val)
217 {
218 LOG_DEBUG("[RdUtils::RdSqlBindInt]");
219 if (GRD_KVApiInfo.DBSqlBindInt == nullptr) {
220 GRD_KVApiInfo = GetApiInfoInstance();
221 }
222 if (GRD_KVApiInfo.DBSqlBindInt == nullptr) {
223 return TransferGrdErrno(GRD_INNER_ERR);
224 }
225 return TransferGrdErrno(GRD_KVApiInfo.DBSqlBindInt(stmt, idx, val));
226 }
227
RdSqlBindInt64(GRD_SqlStmt * stmt,uint32_t idx,int64_t val)228 int RdUtils::RdSqlBindInt64(GRD_SqlStmt *stmt, uint32_t idx, int64_t val)
229 {
230 LOG_DEBUG("[RdUtils::RdSqlBindInt64]");
231 if (GRD_KVApiInfo.DBSqlBindInt64 == nullptr) {
232 GRD_KVApiInfo = GetApiInfoInstance();
233 }
234 if (GRD_KVApiInfo.DBSqlBindInt64 == nullptr) {
235 return TransferGrdErrno(GRD_INNER_ERR);
236 }
237 return TransferGrdErrno(GRD_KVApiInfo.DBSqlBindInt64(stmt, idx, val));
238 }
239
RdSqlBindDouble(GRD_SqlStmt * stmt,uint32_t idx,double val)240 int RdUtils::RdSqlBindDouble(GRD_SqlStmt *stmt, uint32_t idx, double val)
241 {
242 LOG_DEBUG("[RdUtils::RdSqlBindDouble]");
243 if (GRD_KVApiInfo.DBSqlBindDouble == nullptr) {
244 GRD_KVApiInfo = GetApiInfoInstance();
245 }
246 if (GRD_KVApiInfo.DBSqlBindDouble == nullptr) {
247 return TransferGrdErrno(GRD_INNER_ERR);
248 }
249 return TransferGrdErrno(GRD_KVApiInfo.DBSqlBindDouble(stmt, idx, val));
250 }
251
RdSqlBindNull(GRD_SqlStmt * stmt,uint32_t idx)252 int RdUtils::RdSqlBindNull(GRD_SqlStmt *stmt, uint32_t idx)
253 {
254 LOG_DEBUG("[RdUtils::RdSqlBindNull]");
255 if (GRD_KVApiInfo.DBSqlBindNull == nullptr) {
256 GRD_KVApiInfo = GetApiInfoInstance();
257 }
258 if (GRD_KVApiInfo.DBSqlBindNull == nullptr) {
259 return TransferGrdErrno(GRD_INNER_ERR);
260 }
261 return TransferGrdErrno(GRD_KVApiInfo.DBSqlBindNull(stmt, idx));
262 }
263
RdSqlFreeFloatArr(void * floatElement)264 void RdSqlFreeFloatArr(void *floatElement)
265 {
266 delete[] ((float *)floatElement);
267 }
268
RdSqlBindFloatVector(GRD_SqlStmt * stmt,uint32_t idx,float * val,uint32_t dim,void (* freeFunc)(void *))269 int RdUtils::RdSqlBindFloatVector(GRD_SqlStmt *stmt, uint32_t idx, float *val,
270 uint32_t dim, void (*freeFunc)(void *))
271 {
272 LOG_DEBUG("[RdUtils::RdSqlBindFloatVector]");
273 if (GRD_KVApiInfo.DBSqlBindFloatVector == nullptr) {
274 GRD_KVApiInfo = GetApiInfoInstance();
275 }
276 if (GRD_KVApiInfo.DBSqlBindFloatVector == nullptr) {
277 return TransferGrdErrno(GRD_INNER_ERR);
278 }
279 if (dim <= 0) {
280 LOG_ERROR("Invalid dim %{public}d", dim);
281 return E_INVALID_ARGS;
282 }
283 float *tmpVal = new float[dim]();
284 if (tmpVal == nullptr) {
285 return E_ERROR;
286 }
287 errno_t err = memcpy_s(tmpVal, dim * sizeof(float), val, dim * sizeof(float));
288 if (err < 0) {
289 delete[] tmpVal;
290 LOG_ERROR("BindFloat failed due to memcpy %{public}d, dim is %{public}d", err, dim);
291 return TransferGrdErrno(GRD_INNER_ERR);
292 }
293 if (freeFunc == nullptr) {
294 freeFunc = RdSqlFreeFloatArr;
295 }
296 return TransferGrdErrno(GRD_KVApiInfo.DBSqlBindFloatVector(stmt, idx, tmpVal, dim, freeFunc));
297 }
298
RdSqlStep(GRD_SqlStmt * stmt)299 int RdUtils::RdSqlStep(GRD_SqlStmt *stmt)
300 {
301 LOG_DEBUG("[RdUtils::RdSqlStep]");
302 if (GRD_KVApiInfo.DBSqlStep == nullptr) {
303 GRD_KVApiInfo = GetApiInfoInstance();
304 }
305 if (GRD_KVApiInfo.DBSqlStep == nullptr) {
306 return TransferGrdErrno(GRD_INNER_ERR);
307 }
308 return TransferGrdErrno(GRD_KVApiInfo.DBSqlStep(stmt));
309 }
310
RdSqlColCnt(GRD_SqlStmt * stmt)311 int RdUtils::RdSqlColCnt(GRD_SqlStmt *stmt)
312 {
313 LOG_DEBUG("[RdUtils::RdSqlColCnt]");
314 if (GRD_KVApiInfo.DBSqlColCnt == nullptr) {
315 GRD_KVApiInfo = GetApiInfoInstance();
316 }
317 if (GRD_KVApiInfo.DBSqlColCnt == nullptr) {
318 return TransferGrdErrno(GRD_INNER_ERR);
319 }
320 return TransferGrdErrno(GRD_KVApiInfo.DBSqlColCnt(stmt));
321 }
322
RdSqlColType(GRD_SqlStmt * stmt,uint32_t idx)323 ColumnType RdUtils::RdSqlColType(GRD_SqlStmt *stmt, uint32_t idx)
324 {
325 LOG_DEBUG("[RdUtils::RdSqlColType]");
326 if (GRD_KVApiInfo.DBSqlColType == nullptr) {
327 GetApiInfoInstance();
328 }
329 if (GRD_KVApiInfo.DBSqlColType == nullptr) {
330 return TransferGrdTypeToColType(0); // for invalid
331 }
332 return TransferGrdTypeToColType(GRD_KVApiInfo.DBSqlColType(stmt, idx));
333 }
334
RdSqlColBytes(GRD_SqlStmt * stmt,uint32_t idx)335 int RdUtils::RdSqlColBytes(GRD_SqlStmt *stmt, uint32_t idx)
336 {
337 LOG_DEBUG("[RdUtils::RdSqlColBytes]");
338 if (GRD_KVApiInfo.DBSqlColBytes == nullptr) {
339 GRD_KVApiInfo = GetApiInfoInstance();
340 }
341 if (GRD_KVApiInfo.DBSqlColBytes == nullptr) {
342 return TransferGrdErrno(GRD_INNER_ERR);
343 }
344 return TransferGrdErrno(GRD_KVApiInfo.DBSqlColBytes(stmt, idx));
345 }
346
RdSqlColName(GRD_SqlStmt * stmt,uint32_t idx)347 char *RdUtils::RdSqlColName(GRD_SqlStmt *stmt, uint32_t idx)
348 {
349 LOG_DEBUG("[RdUtils::RdSqlColName]");
350 if (GRD_KVApiInfo.DBSqlColName == nullptr) {
351 GRD_KVApiInfo = GetApiInfoInstance();
352 }
353 if (GRD_KVApiInfo.DBSqlColName == nullptr) {
354 return nullptr;
355 }
356 return GRD_KVApiInfo.DBSqlColName(stmt, idx);
357 }
358
RdSqlColValue(GRD_SqlStmt * stmt,uint32_t idx)359 GRD_DbValueT RdUtils::RdSqlColValue(GRD_SqlStmt *stmt, uint32_t idx)
360 {
361 LOG_DEBUG("[RdUtils::RdSqlColValue]");
362 if (GRD_KVApiInfo.DBSqlColValue == nullptr) {
363 GRD_KVApiInfo = GetApiInfoInstance();
364 }
365 if (GRD_KVApiInfo.DBSqlColValue == nullptr) {
366 return {};
367 }
368 return GRD_KVApiInfo.DBSqlColValue(stmt, idx);
369 }
370
RdSqlColBlob(GRD_SqlStmt * stmt,uint32_t idx)371 uint8_t *RdUtils::RdSqlColBlob(GRD_SqlStmt *stmt, uint32_t idx)
372 {
373 LOG_DEBUG("[RdUtils::RdSqlColBlob]");
374 if (GRD_KVApiInfo.DBSqlColBlob == nullptr) {
375 GRD_KVApiInfo = GetApiInfoInstance();
376 }
377 if (GRD_KVApiInfo.DBSqlColBlob == nullptr) {
378 return nullptr;
379 }
380 return GRD_KVApiInfo.DBSqlColBlob(stmt, idx);
381 }
382
RdSqlColText(GRD_SqlStmt * stmt,uint32_t idx)383 char *RdUtils::RdSqlColText(GRD_SqlStmt *stmt, uint32_t idx)
384 {
385 LOG_DEBUG("[RdUtils::RdSqlColText]");
386 if (GRD_KVApiInfo.DBSqlColText == nullptr) {
387 GRD_KVApiInfo = GetApiInfoInstance();
388 }
389 if (GRD_KVApiInfo.DBSqlColText == nullptr) {
390 return nullptr;
391 }
392 return GRD_KVApiInfo.DBSqlColText(stmt, idx);
393 }
394
RdSqlColInt(GRD_SqlStmt * stmt,uint32_t idx)395 int RdUtils::RdSqlColInt(GRD_SqlStmt *stmt, uint32_t idx)
396 {
397 LOG_DEBUG("[RdUtils::RdSqlColInt]");
398 if (GRD_KVApiInfo.DBSqlColInt == nullptr) {
399 GRD_KVApiInfo = GetApiInfoInstance();
400 }
401 if (GRD_KVApiInfo.DBSqlColInt == nullptr) {
402 return 0;
403 }
404 return GRD_KVApiInfo.DBSqlColInt(stmt, idx);
405 }
406
RdSqlColInt64(GRD_SqlStmt * stmt,uint32_t idx)407 uint64_t RdUtils::RdSqlColInt64(GRD_SqlStmt *stmt, uint32_t idx)
408 {
409 LOG_DEBUG("[RdUtils::RdSqlColInt64]");
410 if (GRD_KVApiInfo.DBSqlColInt64 == nullptr) {
411 GRD_KVApiInfo = GetApiInfoInstance();
412 }
413 if (GRD_KVApiInfo.DBSqlColInt64 == nullptr) {
414 return 0;
415 }
416 return GRD_KVApiInfo.DBSqlColInt64(stmt, idx);
417 }
418
RdSqlColDouble(GRD_SqlStmt * stmt,uint32_t idx)419 double RdUtils::RdSqlColDouble(GRD_SqlStmt *stmt, uint32_t idx)
420 {
421 LOG_DEBUG("[RdUtils::RdSqlColDouble]");
422 if (GRD_KVApiInfo.DBSqlColDouble == nullptr) {
423 GRD_KVApiInfo = GetApiInfoInstance();
424 }
425 if (GRD_KVApiInfo.DBSqlColDouble == nullptr) {
426 return 0;
427 }
428 return GRD_KVApiInfo.DBSqlColDouble(stmt, idx);
429 }
430
RdSqlColumnFloatVector(GRD_SqlStmt * stmt,uint32_t idx,uint32_t * dim)431 const float *RdUtils::RdSqlColumnFloatVector(GRD_SqlStmt *stmt, uint32_t idx, uint32_t *dim)
432 {
433 LOG_DEBUG("[RdUtils::RdSqlColumnFloatVector]");
434 if (GRD_KVApiInfo.DBSqlColumnFloatVector == nullptr) {
435 GRD_KVApiInfo = GetApiInfoInstance();
436 }
437 if (GRD_KVApiInfo.DBSqlColumnFloatVector == nullptr) {
438 return nullptr;
439 }
440 return GRD_KVApiInfo.DBSqlColumnFloatVector(stmt, idx, dim);
441 }
442
RdDbBackup(GRD_DB * db,const char * backupDbFile,uint8_t * encryptedKey,uint32_t encryptedKeyLen)443 int RdUtils::RdDbBackup(GRD_DB *db, const char *backupDbFile, uint8_t *encryptedKey, uint32_t encryptedKeyLen)
444 {
445 LOG_DEBUG("[RdUtils::RdDbBackup]");
446 if (GRD_KVApiInfo.DBBackupApi == nullptr) {
447 GRD_KVApiInfo = GetApiInfoInstance();
448 }
449 if (GRD_KVApiInfo.DBBackupApi == nullptr) {
450 return TransferGrdErrno(GRD_INNER_ERR);
451 }
452 return TransferGrdErrno(GRD_KVApiInfo.DBBackupApi(db, backupDbFile, encryptedKey, encryptedKeyLen));
453 }
454
RdDbRestore(GRD_DB * db,const char * backupDbFile,uint8_t * encryptedKey,uint32_t encryptedKeyLen)455 int RdUtils::RdDbRestore(GRD_DB *db, const char *backupDbFile, uint8_t *encryptedKey, uint32_t encryptedKeyLen)
456 {
457 LOG_DEBUG("[RdUtils::RdDbRestore]");
458 if (GRD_KVApiInfo.DBRestoreApi == nullptr) {
459 GRD_KVApiInfo = GetApiInfoInstance();
460 }
461 if (GRD_KVApiInfo.DBRestoreApi == nullptr) {
462 return TransferGrdErrno(GRD_INNER_ERR);
463 }
464 return TransferGrdErrno(GRD_KVApiInfo.DBRestoreApi(db, backupDbFile, encryptedKey, encryptedKeyLen));
465 }
466
RdDbGetVersion(GRD_DB * db,GRD_ConfigTypeE type,int & version)467 int RdUtils::RdDbGetVersion(GRD_DB *db, GRD_ConfigTypeE type, int &version)
468 {
469 if (GRD_KVApiInfo.DBGetConfigApi == nullptr) {
470 GRD_KVApiInfo = GetApiInfoInstance();
471 }
472 if (GRD_KVApiInfo.DBGetConfigApi == nullptr) {
473 return TransferGrdErrno(GRD_INNER_ERR);
474 }
475 GRD_DbValueT value = GRD_KVApiInfo.DBGetConfigApi(db, type);
476 version = value.value.longValue;
477 return E_OK;
478 }
479
RdDbSetVersion(GRD_DB * db,GRD_ConfigTypeE type,int version)480 int RdUtils::RdDbSetVersion(GRD_DB *db, GRD_ConfigTypeE type, int version)
481 {
482 if (GRD_KVApiInfo.DBSetConfigApi == nullptr) {
483 GRD_KVApiInfo = GetApiInfoInstance();
484 }
485 if (GRD_KVApiInfo.DBSetConfigApi == nullptr) {
486 return TransferGrdErrno(GRD_INNER_ERR);
487 }
488 GRD_DbValueT value;
489 value.type = GRD_DB_DATATYPE_INTEGER;
490 value.value.longValue = version;
491 return TransferGrdErrno(GRD_KVApiInfo.DBSetConfigApi(db, type, value));
492 }
493
494 } // namespace NativeRdb
495 } // namespace OHOS
496