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 #include <gtest/gtest.h>
16 #include <sys/stat.h>
17 #include <sys/types.h>
18 #include <string>
19 #include "relational_store.h"
20 #include "oh_values_bucket.h"
21 #include "oh_values_bucket.h"
22 #include "common.h"
23 #include "relational_store_error_code.h"
24 #include "oh_data_values.h"
25 #include "oh_data_value.h"
26
27 using namespace testing::ext;
28 using namespace OHOS::NativeRdb;
29
30 class RdbTransactionCapiTest : public testing::Test {
31 public:
32 static void SetUpTestCase(void);
33 static void TearDownTestCase(void);
34 void SetUp();
35 void TearDown();
InitRdbConfig()36 static void InitRdbConfig()
37 {
38 config_.dataBaseDir = RDB_TEST_PATH;
39 config_.storeName = "rdb_store_test.db";
40 config_.bundleName = "com.ohos.example.distributedndk";
41 config_.moduleName = "";
42 config_.securityLevel = OH_Rdb_SecurityLevel::S1;
43 config_.isEncrypt = false;
44 config_.selfSize = sizeof(OH_Rdb_Config);
45 config_.area = RDB_SECURITY_AREA_EL1;
46 }
47 static OH_Rdb_Config config_;
48 };
49
50 static OH_Rdb_Store *g_transStore;
51 static OH_RDB_TransOptions *g_options;
52 OH_Rdb_Config RdbTransactionCapiTest::config_ = { 0 };
53
SetUpTestCase(void)54 void RdbTransactionCapiTest::SetUpTestCase(void)
55 {
56 InitRdbConfig();
57 int chmodValue = 0770;
58 mkdir(config_.dataBaseDir, chmodValue);
59 int errCode = 0;
60 char table[] = "test";
61 g_transStore = OH_Rdb_GetOrOpen(&config_, &errCode);
62 EXPECT_NE(g_transStore, NULL);
63
64 char createTableSql[] = "CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, data2 INTEGER, "
65 "data3 FLOAT, data4 BLOB, data5 TEXT);";
66 errCode = OH_Rdb_Execute(g_transStore, createTableSql);
67
68 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
69 valueBucket->putInt64(valueBucket, "id", 1);
70 valueBucket->putText(valueBucket, "data1", "zhangSan");
71 // init row one data2 value 12800
72 valueBucket->putInt64(valueBucket, "data2", 12800);
73 // init row one data3 value 100.1
74 valueBucket->putReal(valueBucket, "data3", 100.1);
75 uint8_t arr[] = { 1, 2, 3, 4, 5 };
76 int len = sizeof(arr) / sizeof(arr[0]);
77 valueBucket->putBlob(valueBucket, "data4", arr, len);
78 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
79 errCode = OH_Rdb_Insert(g_transStore, table, valueBucket);
80 // expect value is 1
81 EXPECT_EQ(errCode, 1);
82
83 valueBucket->clear(valueBucket);
84 // init row two id value 2
85 valueBucket->putInt64(valueBucket, "id", 2);
86 valueBucket->putText(valueBucket, "data1", "liSi");
87 // init row two data2 value 13800
88 valueBucket->putInt64(valueBucket, "data2", 13800);
89 // init row two data2 value 200.1
90 valueBucket->putReal(valueBucket, "data3", 200.1);
91 valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
92 errCode = OH_Rdb_Insert(g_transStore, table, valueBucket);
93 // expect value is 2
94 EXPECT_EQ(errCode, 2);
95
96 valueBucket->clear(valueBucket);
97 // init row three id value 3
98 valueBucket->putInt64(valueBucket, "id", 3);
99 valueBucket->putText(valueBucket, "data1", "wangWu");
100 // init row three data2 value 14800
101 valueBucket->putInt64(valueBucket, "data2", 14800);
102 // init row three data3 value 300.1
103 valueBucket->putReal(valueBucket, "data3", 300.1);
104 valueBucket->putText(valueBucket, "data5", "ABCDEFGHI");
105 errCode = OH_Rdb_Insert(g_transStore, table, valueBucket);
106 // expect value is 3
107 EXPECT_EQ(errCode, 3);
108
109 valueBucket->destroy(valueBucket);
110
111 g_options = OH_RdbTrans_CreateOptions();
112 EXPECT_NE(g_options, nullptr);
113 int ret = OH_RdbTransOption_SetType(g_options, RDB_TRANS_BUTT);
114 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
115 ret = OH_RdbTransOption_SetType(g_options, RDB_TRANS_DEFERRED);
116 EXPECT_EQ(ret, RDB_OK);
117 }
118
TearDownTestCase(void)119 void RdbTransactionCapiTest::TearDownTestCase(void)
120 {
121 char dropTableSql[] = "DROP TABLE IF EXISTS test";
122 int errCode = OH_Rdb_Execute(g_transStore, dropTableSql);
123 EXPECT_EQ(errCode, 0);
124 delete g_transStore;
125 g_transStore = NULL;
126 OH_Rdb_DeleteStore(&config_);
127 OH_RdbTrans_DestroyOptions(g_options);
128 g_options = nullptr;
129 }
130
SetUp(void)131 void RdbTransactionCapiTest::SetUp(void)
132 {
133 }
134
TearDown(void)135 void RdbTransactionCapiTest::TearDown(void)
136 {
137 }
138
FillDataValues(OH_Data_Values * values)139 static void FillDataValues(OH_Data_Values *values)
140 {
141 EXPECT_NE(values, nullptr);
142 OH_Data_Value *value = OH_Value_Create();
143 int ret = OH_Value_PutInt(nullptr, 1);
144 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
145 ret = OH_Value_PutInt(value, 1);
146 EXPECT_EQ(ret, RDB_OK);
147
148 ret = OH_Values_Put(nullptr, value);
149 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
150 ret = OH_Values_Put(values, nullptr);
151 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
152 ret = OH_Values_Put(values, value);
153 EXPECT_EQ(ret, RDB_OK);
154 ret = OH_Value_Destroy(value);
155 EXPECT_EQ(ret, RDB_OK);
156
157 // Add int value 2 to values
158 ret = OH_Values_PutInt(values, 2);
159 EXPECT_EQ(ret, RDB_OK);
160 // Add double value 1.1 to values
161 ret = OH_Values_PutReal(values, 1.1);
162 EXPECT_EQ(ret, RDB_OK);
163 ret = OH_Values_PutText(values, "1");
164 EXPECT_EQ(ret, RDB_OK);
165 // init unsigend char 1 and 2
166 unsigned char val[] = {1, 2};
167 ret = OH_Values_PutBlob(values, val, sizeof(val) / sizeof(val[0]));
168 EXPECT_EQ(ret, RDB_OK);
169
170 // asset
171 Data_Asset *asset = OH_Data_Asset_CreateOne();
172 ret = OH_Data_Asset_SetName(asset, "name");
173 EXPECT_EQ(ret, RDB_OK);
174 ret = OH_Values_PutAsset(values, asset);
175 EXPECT_EQ(ret, RDB_OK);
176 OH_Data_Asset_DestroyOne(asset);
177
178 // asset array
179 Data_Asset **assets = OH_Data_Asset_CreateMultiple(2);
180 ret = OH_Data_Asset_SetName(assets[0], "name1");
181 EXPECT_EQ(ret, RDB_OK);
182 ret = OH_Data_Asset_SetName(assets[1], "name2");
183 EXPECT_EQ(ret, RDB_OK);
184 // 2 elements in assets
185 ret = OH_Values_PutAssets(values, assets, 2);
186 EXPECT_EQ(ret, RDB_OK);
187 // 2 elements in assets
188 ret = OH_Data_Asset_DestroyMultiple(assets, 2);
189 EXPECT_EQ(ret, RDB_OK);
190
191 // big int
192 uint64_t bigInt[] = {1, 2, 3, 4, 5};
193 ret = OH_Values_PutUnlimitedInt(values, 0, bigInt, sizeof(bigInt) / sizeof(bigInt[0]));
194 EXPECT_EQ(ret, RDB_OK);
195 }
196
ReadDataValuesPartOne(OH_Data_Values * values)197 static void ReadDataValuesPartOne(OH_Data_Values *values)
198 {
199 // read
200 size_t readSize = 0;
201 int ret = OH_Values_Count(values, &readSize);
202 EXPECT_EQ(ret, RDB_OK);
203 // ecpect value is 8
204 EXPECT_EQ(readSize, 8);
205
206 OH_ColumnType columnType;
207 ret = OH_Values_GetType(values, 0, &columnType);
208 EXPECT_EQ(ret, RDB_OK);
209 EXPECT_EQ(columnType, TYPE_INT64);
210
211 OH_Data_Value *readData0 = nullptr;
212 ret = OH_Values_Get(values, 0, &readData0);
213 EXPECT_EQ(ret, RDB_OK);
214 EXPECT_NE(readData0, nullptr);
215
216 bool isNull;
217 ret = OH_Values_IsNull(values, 0, &isNull);
218 EXPECT_EQ(ret, RDB_OK);
219 EXPECT_EQ(isNull, false);
220
221 int64_t readData1;
222 // index 1 in values array
223 ret = OH_Values_GetInt(values, 1, &readData1);
224 EXPECT_EQ(ret, RDB_OK);
225 // ecpect value is 2
226 EXPECT_EQ(readData1, 2);
227
228 double readData2;
229 // index 2 in values array
230 ret = OH_Values_GetReal(values, 2, &readData2);
231 EXPECT_EQ(ret, RDB_OK);
232 // ecpect value is 1.1
233 EXPECT_EQ(readData2, 1.1);
234
235 const char *readData3 = nullptr;
236 // index 3 in values array
237 ret = OH_Values_GetText(values, 3, &readData3);
238 EXPECT_EQ(ret, RDB_OK);
239 EXPECT_EQ(strcmp(readData3, "1"), 0);
240
241 const uint8_t *readData4 = nullptr;
242 size_t len4;
243 // index 43 in values array
244 ret = OH_Values_GetBlob(values, 4, &readData4, &len4);
245 EXPECT_EQ(ret, RDB_OK);
246 // ecpect len is 2
247 EXPECT_EQ(len4, 2);
248 EXPECT_EQ(readData4[0], 1);
249 // ecpect value is 2
250 EXPECT_EQ(readData4[1], 2);
251 }
252
ReadDataValuesPartTwo(OH_Data_Values * values)253 static void ReadDataValuesPartTwo(OH_Data_Values *values)
254 {
255 Data_Asset *readData5 = OH_Data_Asset_CreateOne();
256 EXPECT_NE(readData5, nullptr);
257 OH_ColumnType columnType5;
258 // index 5 in values array
259 int ret = OH_Values_GetType(values, 5, &columnType5);
260 EXPECT_EQ(ret, RDB_OK);
261 EXPECT_EQ(columnType5, TYPE_ASSET);
262 // index 5 in values array
263 ret = OH_Values_GetAsset(values, 5, readData5);
264 EXPECT_EQ(ret, RDB_OK);
265 char readDataName[32];
266 size_t length5 = 32;
267 ret = OH_Data_Asset_GetName(readData5, readDataName, &length5);
268 EXPECT_EQ(ret, RDB_OK);
269 EXPECT_EQ(strcmp(readDataName, "name"), 0);
270 // expect string length is 4
271 EXPECT_EQ(length5, 4);
272 OH_Data_Asset_DestroyOne(readData5);
273
274 size_t readDataCount6;
275 // index 6 in values array
276 ret = OH_Values_GetAssetsCount(values, 6, &readDataCount6);
277 EXPECT_EQ(ret, RDB_OK);
278 // 2 is two element in data.
279 EXPECT_EQ(readDataCount6, 2);
280
281 Data_Asset **readData6 = OH_Data_Asset_CreateMultiple(2);
282 EXPECT_NE(readData6, nullptr);
283 size_t out6;
284 // index 6 in values array, 2 is two element in data.
285 ret = OH_Values_GetAssets(values, 6, readData6, 2, &out6);
286 EXPECT_EQ(ret, RDB_OK);
287 // expect value is 2
288 EXPECT_EQ(out6, 2);
289 // 2 is two element in data.
290 OH_Data_Asset_DestroyMultiple(readData6, 2);
291
292 size_t readDataLen7;
293 // index 7 in values array
294 ret = OH_Values_GetUnlimitedIntBand(values, 7, &readDataLen7);
295 EXPECT_EQ(ret, RDB_OK);
296 // expect value is 5
297 EXPECT_EQ(readDataLen7, 5);
298
299 int readDataSign7;
300 uint64_t readData7[5];
301 size_t outLen;
302 // index 7 in values array, 5 is input memory length.
303 ret = OH_Values_GetUnlimitedInt(values, 7, &readDataSign7, readData7, 5, &outLen);
304 EXPECT_EQ(ret, RDB_OK);
305 // expect value is 5
306 EXPECT_EQ(outLen, 5);
307 EXPECT_EQ(readDataSign7, 0);
308 EXPECT_EQ(readData7[0], 1);
309 // expect value is 5, 4 is index.
310 EXPECT_EQ(readData7[4], 5);
311 }
312
313 /**
314 * @tc.name: RDB_Transaction_capi_test_001
315 * @tc.desc: Normal testCase of store transaction for create.
316 * @tc.type: FUNC
317 */
318 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_001, TestSize.Level1)
319 {
320 OH_Rdb_Transaction *trans = nullptr;
321 int ret = OH_Rdb_CreateTransaction(g_transStore, g_options, &trans);
322 EXPECT_EQ(ret, RDB_OK);
323 EXPECT_NE(trans, nullptr);
324 }
325
326 /**
327 * @tc.name: RDB_Transaction_capi_test_002
328 * @tc.desc: Normal testCase of store transaction for create and OH_RdbTrans_Commit
329 * @tc.type: FUNC
330 */
331 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_002, TestSize.Level1)
332 {
333 OH_Rdb_Transaction *trans = nullptr;
334 const char *table = "test";
335 int ret = OH_Rdb_CreateTransaction(g_transStore, g_options, &trans);
336 EXPECT_EQ(ret, RDB_OK);
337 EXPECT_NE(trans, nullptr);
338
339 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
340 // init is value is 4
341 valueBucket->putInt64(valueBucket, "id", 4);
342 valueBucket->putText(valueBucket, "data1", "test_name4");
343 // init is data2 is 14800
344 valueBucket->putInt64(valueBucket, "data2", 14800);
345 // init is data3 is 300.1
346 valueBucket->putReal(valueBucket, "data3", 300.1);
347 valueBucket->putText(valueBucket, "data5", "ABCDEFGHI");
348 int64_t rowId = -1;
349 ret = OH_RdbTrans_Insert(trans, table, valueBucket, &rowId);
350 EXPECT_EQ(ret, RDB_OK);
351 EXPECT_EQ(rowId, 4);
352
353 valueBucket->destroy(valueBucket);
354 ret = OH_RdbTrans_Destroy(trans);
355 EXPECT_EQ(ret, RDB_OK);
356 }
357
358 /**
359 * @tc.name: RDB_Transaction_capi_test_003
360 * @tc.desc: Normal testCase of store transaction for insert and OH_RdbTrans_Rollback
361 * @tc.type: FUNC
362 */
363 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_003, TestSize.Level1)
364 {
365 OH_Rdb_Transaction *trans = nullptr;
366 const char *table = "test";
367 int ret = OH_Rdb_CreateTransaction(g_transStore, g_options, &trans);
368 EXPECT_EQ(ret, RDB_OK);
369 EXPECT_NE(trans, nullptr);
370
371 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
372 valueBucket->putText(valueBucket, "data1", "test_name4");
373 // init is data2 is 14800
374 valueBucket->putInt64(valueBucket, "data2", 14800);
375 // init is data2 is 300.1
376 valueBucket->putReal(valueBucket, "data3", 300.1);
377 valueBucket->putText(valueBucket, "data5", "ABCDEFGHI");
378 int64_t rowId = -1;
379 ret = OH_RdbTrans_Insert(trans, table, valueBucket, &rowId);
380 EXPECT_EQ(ret, RDB_OK);
381 // expect value is 4
382 EXPECT_EQ(rowId, 4);
383
384 ret = OH_RdbTrans_Rollback(trans);
385 EXPECT_EQ(ret, RDB_OK);
386
387 valueBucket->destroy(valueBucket);
388 ret = OH_RdbTrans_Destroy(trans);
389 EXPECT_EQ(ret, RDB_OK);
390 }
391
392 /**
393 * @tc.name: RDB_Transaction_capi_test_004
394 * @tc.desc: Normal testCase of store transaction for OH_RdbTrans_BatchInsert
395 * OH_VBuckets_RowCount, OH_VBuckets_PutRow, OH_RdbTrans_Destroy, OH_VBuckets_Destroy
396 * @tc.type: FUNC
397 */
398 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_004, TestSize.Level1)
399 {
400 OH_Rdb_Transaction *trans = nullptr;
401 const char *table = "test";
402 int ret = OH_Rdb_CreateTransaction(g_transStore, g_options, &trans);
403 EXPECT_EQ(ret, RDB_OK);
404 EXPECT_NE(trans, nullptr);
405
406 // data row1
407 OH_VBucket *row1 = OH_Rdb_CreateValuesBucket();
408 EXPECT_NE(row1, nullptr);
409 row1->putInt64(row1, "id", 4);
410 row1->putText(row1, "data1", "test_name4");
411 row1->putInt64(row1, "data2", 14800);
412 row1->putReal(row1, "data3", 300.1);
413 row1->putText(row1, "data5", "ABCDEFGHI");
414
415 // data row2
416 OH_VBucket *row2 = OH_Rdb_CreateValuesBucket();
417 EXPECT_NE(row2, nullptr);
418 row2->putInt64(row2, "id", 5);
419 row2->putText(row2, "data1", "test_name5");
420 row2->putInt64(row2, "data2", 15800);
421 row2->putReal(row2, "data3", 500.1);
422 row2->putText(row2, "data5", "ABCDEFGHI");
423
424 // create rows
425 OH_Data_VBuckets *rows = OH_VBuckets_Create();
426 EXPECT_NE(rows, nullptr);
427
428 // add row1 to rows
429 ret = OH_VBuckets_PutRow(rows, row1);
430 EXPECT_EQ(ret, RDB_OK);
431 size_t count = -1;
432 ret = OH_VBuckets_RowCount(rows, &count);
433 EXPECT_EQ(ret, RDB_OK);
434 EXPECT_EQ(count, 1);
435
436 // add row2 to rows
437 ret = OH_VBuckets_PutRow(rows, row2);
438 EXPECT_EQ(ret, RDB_OK);
439 ret = OH_VBuckets_RowCount(rows, &count);
440 EXPECT_EQ(ret, RDB_OK);
441 EXPECT_EQ(count, 2);
442
443 // batch insert
444 int64_t changes = -1;
445 ret = OH_RdbTrans_BatchInsert(trans, table, rows, RDB_CONFLICT_NONE, &changes);
446 EXPECT_EQ(ret, RDB_OK);
447 EXPECT_EQ(changes, 2);
448
449
450 // destroy
451 row1->destroy(row1);
452 row2->destroy(row2);
453 ret = OH_VBuckets_Destroy(rows);
454 EXPECT_EQ(ret, RDB_OK);
455
456 ret = OH_RdbTrans_Destroy(trans);
457 EXPECT_EQ(ret, RDB_OK);
458 }
459
460 /**
461 * @tc.name: RDB_Transaction_capi_test_005
462 * @tc.desc: Normal testCase of store transaction for OH_RdbTrans_BatchInsert
463 * OH_VBuckets_RowCount, OH_VBuckets_PutRows, OH_RdbTrans_Destroy, OH_VBuckets_Destroy
464 * @tc.type: FUNC
465 */
466 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_005, TestSize.Level1)
467 {
468 OH_Rdb_Transaction *trans = nullptr;
469 const char *table = "test";
470 int ret = OH_Rdb_CreateTransaction(g_transStore, g_options, &trans);
471 EXPECT_EQ(ret, RDB_OK);
472 EXPECT_NE(trans, nullptr);
473
474 // data row1
475 OH_VBucket *row1 = OH_Rdb_CreateValuesBucket();
476 EXPECT_NE(row1, nullptr);
477 row1->putInt64(row1, "id", 4);
478 row1->putText(row1, "data1", "test_name4");
479 row1->putInt64(row1, "data2", 14800);
480 row1->putReal(row1, "data3", 300.1);
481 row1->putText(row1, "data5", "ABCDEFGHI");
482
483 // data row2
484 OH_VBucket *row2 = OH_Rdb_CreateValuesBucket();
485 EXPECT_NE(row2, nullptr);
486 row2->putInt64(row2, "id", 5);
487 row2->putText(row2, "data1", "test_name5");
488 row2->putInt64(row2, "data2", 15800);
489 row2->putReal(row2, "data3", 500.1);
490 row2->putText(row2, "data5", "ABCDEFGHI");
491
492 // create rows
493 OH_Data_VBuckets *rows = OH_VBuckets_Create();
494 EXPECT_NE(rows, nullptr);
495
496 // add row1 to rows
497 ret = OH_VBuckets_PutRow(rows, row1);
498 EXPECT_EQ(ret, RDB_OK);
499 size_t count = -1;
500 ret = OH_VBuckets_RowCount(rows, &count);
501 EXPECT_EQ(ret, RDB_OK);
502 EXPECT_EQ(count, 1);
503
504 // add row2 to rows
505 ret = OH_VBuckets_PutRow(rows, row2);
506 EXPECT_EQ(ret, RDB_OK);
507 ret = OH_VBuckets_RowCount(rows, &count);
508 EXPECT_EQ(ret, RDB_OK);
509 EXPECT_EQ(count, 2);
510
511
512 // create rows
513 OH_Data_VBuckets *rows2 = OH_VBuckets_Create();
514 EXPECT_NE(rows, nullptr);
515 ret = OH_VBuckets_PutRows(rows2, rows);
516 EXPECT_EQ(ret, RDB_OK);
517
518 // destroy rows
519 ret = OH_VBuckets_Destroy(rows);
520 EXPECT_EQ(ret, RDB_OK);
521
522 // batch insert
523 int64_t changes = -1;
524 ret = OH_RdbTrans_BatchInsert(trans, table, rows2, RDB_CONFLICT_REPLACE, &changes);
525 EXPECT_EQ(ret, RDB_OK);
526 EXPECT_EQ(changes, 2);
527
528
529 // destroy
530 row1->destroy(row1);
531 row2->destroy(row2);
532 ret = OH_VBuckets_Destroy(rows2);
533 EXPECT_EQ(ret, RDB_OK);
534
535 ret = OH_RdbTrans_Destroy(trans);
536 EXPECT_EQ(ret, RDB_OK);
537 }
538
539 /**
540 * @tc.name: RDB_Transaction_capi_test_006
541 * @tc.desc: Normal testCase of store transaction for OH_RdbTrans_Update
542 * @tc.type: FUNC
543 */
544 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_006, TestSize.Level1)
545 {
546 OH_Rdb_Transaction *trans = nullptr;
547 const char *table = "test";
548 int ret = OH_Rdb_CreateTransaction(g_transStore, g_options, &trans);
549 EXPECT_EQ(ret, RDB_OK);
550 EXPECT_NE(trans, nullptr);
551
552 // new row
553 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
554 valueBucket->putText(valueBucket, "data1", "liSi");
555 // init data2 value is 13800
556 valueBucket->putInt64(valueBucket, "data2", 13800);
557 // init data3 value is 200.1
558 valueBucket->putReal(valueBucket, "data3", 200.1);
559 valueBucket->putNull(valueBucket, "data5");
560
561 // create predicates
562 OH_Predicates *predicates = OH_Rdb_CreatePredicates(table);
563 // create match data
564 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
565 const char *data1Value = "zhangSan";
566 valueObject->putText(valueObject, data1Value);
567 predicates->equalTo(predicates, "data1", valueObject);
568
569 // update
570 int64_t changes = -1;
571 ret = OH_RdbTrans_Update(trans, valueBucket, predicates, &changes);
572 EXPECT_EQ(ret, RDB_OK);
573 EXPECT_EQ(changes, 1);
574
575 // destroy
576 valueObject->destroy(valueObject);
577 valueBucket->destroy(valueBucket);
578
579 ret = OH_RdbTrans_Destroy(trans);
580 EXPECT_EQ(ret, RDB_OK);
581 }
582
583 /**
584 * @tc.name: RDB_Transaction_capi_test_007
585 * @tc.desc: Normal testCase of store transaction for OH_RdbTrans_Delete
586 * @tc.type: FUNC
587 */
588 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_007, TestSize.Level1)
589 {
590 OH_Rdb_Transaction *trans = nullptr;
591 const char *table = "test";
592 int ret = OH_Rdb_CreateTransaction(g_transStore, g_options, &trans);
593 EXPECT_EQ(ret, RDB_OK);
594 EXPECT_NE(trans, nullptr);
595
596 // create predicates
597 OH_Predicates *predicates = OH_Rdb_CreatePredicates(table);
598 // create match data
599 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
600 const char *data1Value = "liSi";
601 valueObject->putText(valueObject, data1Value);
602 predicates->equalTo(predicates, "data1", valueObject);
603
604 // update
605 int64_t changes = -1;
606 ret = OH_RdbTrans_Delete(trans, predicates, &changes);
607 EXPECT_EQ(ret, RDB_OK);
608 EXPECT_EQ(changes, 1);
609
610 // destroy
611 valueObject->destroy(valueObject);
612
613 ret = OH_RdbTrans_Destroy(trans);
614 EXPECT_EQ(ret, RDB_OK);
615 }
616
617 /**
618 * @tc.name: RDB_Transaction_capi_test_008
619 * @tc.desc: Normal testCase of store transaction for OH_RdbTrans_Query
620 * @tc.type: FUNC
621 */
622 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_008, TestSize.Level1)
623 {
624 OH_Rdb_Transaction *trans = nullptr;
625 const char *table = "test";
626 int ret = OH_Rdb_CreateTransaction(g_transStore, g_options, &trans);
627 EXPECT_EQ(ret, RDB_OK);
628 EXPECT_NE(trans, nullptr);
629
630 // create predicates
631 OH_Predicates *predicates = OH_Rdb_CreatePredicates(table);
632
633 const char *columns[] = {"id", "data1"};
634 // check args;
635 OH_Cursor *cursor = OH_RdbTrans_Query(nullptr, predicates, columns, 2);
636 EXPECT_EQ(cursor, nullptr);
637 cursor = OH_RdbTrans_Query(trans, nullptr, columns, 2);
638 EXPECT_EQ(cursor, nullptr);
639
640 cursor = OH_RdbTrans_Query(trans, predicates, nullptr, 0);
641 EXPECT_NE(cursor, nullptr);
642
643 int rowCount = 0;
644 cursor->getRowCount(cursor, &rowCount);
645 EXPECT_EQ(rowCount, 3);
646
647 ret = cursor->goToNextRow(cursor);
648 EXPECT_EQ(ret, 0);
649
650 int64_t id;
651 cursor->getInt64(cursor, 0, &id);
652 EXPECT_EQ(id, 1);
653
654 char data1[15];
655 cursor->getText(cursor, 1, data1, 15);
656 EXPECT_EQ(strcmp(data1, "zhangSan"), 0);
657
658 int64_t data2;
659 cursor->getInt64(cursor, 2, &data2);
660 EXPECT_EQ(data2, 12800);
661
662 // destroy
663 cursor->destroy(cursor);
664 ret = OH_RdbTrans_Destroy(trans);
665 EXPECT_EQ(ret, RDB_OK);
666 }
667
668 /**
669 * @tc.name: RDB_Transaction_capi_test_009
670 * @tc.desc: Normal testCase of store transaction for OH_RdbTrans_QuerySql, OH_Data_Values, OH_Data_Value,
671 * OH_RdbTrans_Execute
672 * @tc.type: FUNC
673 */
674 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_009, TestSize.Level1)
675 {
676 OH_Rdb_Transaction *trans = nullptr;
677 int ret = OH_Rdb_CreateTransaction(g_transStore, g_options, &trans);
678 EXPECT_EQ(ret, RDB_OK);
679 EXPECT_NE(trans, nullptr);
680
681 char createTableSql[] = "CREATE TABLE transaction_table (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 INTEGER, "
682 "data2 INTEGER, data3 FLOAT, data4 TEXT, data5 BLOB, data6 ASSET, data7 ASSETS, data8 UNLIMITED INT, "
683 "data9 FLOATVECTOR);";
684 ret = OH_Rdb_Execute(g_transStore, createTableSql);
685 EXPECT_EQ(ret, RDB_OK);
686
687 const char *sql = "SELECT id, data1 FROM transaction_table";
688 // check args;
689 OH_Cursor *cursor = OH_RdbTrans_QuerySql(nullptr, sql, nullptr);
690 EXPECT_EQ(cursor, nullptr);
691 cursor = OH_RdbTrans_QuerySql(trans, nullptr, nullptr);
692 EXPECT_EQ(cursor, nullptr);
693
694 cursor = OH_RdbTrans_QuerySql(trans, sql, nullptr);
695 EXPECT_NE(cursor, nullptr);
696 cursor->destroy(cursor);
697
698 // create OH_Data_Values
699 OH_Data_Values *values = OH_Values_Create();
700 FillDataValues(values);
701
702 const char *insertSql = "INSERT INTO transaction_table "
703 "(data1, data2, data3, data4, data5, data6, data7, data8) VALUES (?, ?, ?, ?, ?, ?, ?, ?)";
704 OH_Data_Value *outValue = nullptr;
705 ret = OH_RdbTrans_Execute(trans, insertSql, values, &outValue);
706 EXPECT_EQ(ret, RDB_OK);
707 EXPECT_NE(outValue, nullptr);
708 ret = OH_Value_Destroy(outValue);
709 EXPECT_EQ(ret, RDB_OK);
710 ret = OH_Values_Destroy(values);
711 EXPECT_EQ(ret, RDB_OK);
712
713 const char *querySql = "SELECT * FROM transaction_table WHERE data1=?";
714 OH_Data_Values *queryValues = OH_Values_Create();
715 EXPECT_NE(queryValues, nullptr);
716 ret = OH_Values_PutInt(queryValues, 1);
717 EXPECT_EQ(ret, RDB_OK);
718 OH_Cursor *cursorEnd = OH_RdbTrans_QuerySql(trans, querySql, queryValues);
719 EXPECT_NE(cursorEnd, nullptr);
720 int rowCount = 0;
721 cursorEnd->getRowCount(cursorEnd, &rowCount);
722 EXPECT_EQ(rowCount, 1);
723 ret = OH_Values_Destroy(queryValues);
724 EXPECT_EQ(ret, RDB_OK);
725 cursorEnd->destroy(cursorEnd);
726
727 ret = OH_RdbTrans_Destroy(trans);
728 EXPECT_EQ(ret, RDB_OK);
729 }
730
731 /**
732 * @tc.name: RDB_Transaction_capi_test_010
733 * @tc.desc: Normal testCase of store transaction for OH_Data_Values
734 * @tc.type: FUNC
735 */
736 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_010, TestSize.Level1)
737 {
738 OH_Data_Values *values = OH_Values_Create();
739 FillDataValues(values);
740 ReadDataValuesPartOne(values);
741 ReadDataValuesPartTwo(values);
742 // destroy
743 int ret = OH_Values_Destroy(values);
744 EXPECT_EQ(ret, RDB_OK);
745 }
746
747 /**
748 * @tc.name: RDB_Transaction_capi_test_011
749 * @tc.desc: Normal testCase of store transaction for OH_Data_Values
750 * @tc.type: FUNC
751 */
752 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_011, TestSize.Level1)
753 {
754 OH_Data_Value *value = OH_Value_Create();
755 EXPECT_NE(value, nullptr);
756 float floatArr[] = {1.0, 2.0, 3.0};
757 int ret = OH_Value_PutFloatVector(value, nullptr, 0);
758 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
759 ret = OH_Value_PutFloatVector(value, floatArr, 3);
760 EXPECT_EQ(ret, RDB_OK);
761
762 OH_ColumnType type;
763 ret = OH_Value_GetType(value, &type);
764 EXPECT_EQ(ret, RDB_OK);
765 EXPECT_EQ(type, TYPE_FLOAT_VECTOR);
766 size_t length;
767 ret = OH_Value_GetFloatVectorCount(value, &length);
768 EXPECT_EQ(ret, RDB_OK);
769 EXPECT_EQ(length, 3);
770 float retArray[10];
771 size_t outLen;
772 ret = OH_Value_GetFloatVector(value, retArray, 10, &outLen);
773 EXPECT_EQ(ret, RDB_OK);
774 EXPECT_EQ(outLen, 3);
775 EXPECT_EQ(retArray[0], 1.0);
776 ret = OH_Value_Destroy(value);
777 EXPECT_EQ(ret, RDB_OK);
778 }
779
780 /**
781 * @tc.name: RDB_Transaction_capi_test_012
782 * @tc.desc: Normal testCase of store transaction for OH_Data_Value
783 * @tc.type: FUNC
784 */
785 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_012, TestSize.Level1)
786 {
787 OH_Data_Value *value = OH_Value_Create();
788 EXPECT_NE(value, nullptr);
789 float floatArr[] = {1.0, 2.0, 3.0};
790 int ret = OH_Value_PutFloatVector(value, nullptr, 0);
791 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
792 ret = OH_Value_PutFloatVector(value, floatArr, 0);
793 EXPECT_EQ(ret, RDB_OK);
794
795 size_t length;
796 ret = OH_Value_GetFloatVectorCount(value, &length);
797 EXPECT_EQ(ret, RDB_OK);
798 EXPECT_EQ(length, 0);
799 double realValue;
800 ret = OH_Value_GetReal(value, &realValue);
801 EXPECT_EQ(ret, RDB_E_TYPE_MISMATCH);
802
803 ret = OH_Value_PutNull(value);
804 EXPECT_EQ(ret, RDB_OK);
805 ret = OH_Value_GetReal(value, &realValue);
806 EXPECT_EQ(ret, RDB_E_DATA_TYPE_NULL);
807 ret = OH_Value_Destroy(value);
808 EXPECT_EQ(ret, RDB_OK);
809 }
810
811 /**
812 * @tc.name: RDB_Transaction_capi_test_013
813 * @tc.desc: Normal testCase of OH_VBucket_PutFloatVector
814 * @tc.type: FUNC
815 */
816 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_013, TestSize.Level1)
817 {
818 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
819 EXPECT_NE(valueBucket, nullptr);
820 float floatArr[] = { 1.0, 2.0, 3.0 };
821 int ret = OH_VBucket_PutFloatVector(valueBucket, "data1", floatArr, 0);
822 EXPECT_EQ(ret, RDB_OK);
823 ret = OH_VBucket_PutFloatVector(valueBucket, "data2", floatArr, 3);
824 EXPECT_EQ(ret, RDB_OK);
825 valueBucket->destroy(valueBucket);
826 }
827
828 /**
829 * @tc.name: RDB_Transaction_capi_test_014
830 * @tc.desc: Normal testCase of OH_VBucket_PutUnlimitedInt
831 * @tc.type: FUNC
832 */
833 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_014, TestSize.Level1)
834 {
835 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
836 EXPECT_NE(valueBucket, nullptr);
837 uint64_t trueForm[] = { 1, 2, 3 };
838 int ret = OH_VBucket_PutUnlimitedInt(valueBucket, "data1", 0, trueForm, 0);
839 EXPECT_EQ(ret, RDB_OK);
840 ret = OH_VBucket_PutUnlimitedInt(valueBucket, "data2", 1, trueForm, 3);
841 EXPECT_EQ(ret, RDB_OK);
842 valueBucket->destroy(valueBucket);
843 }