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 ret = OH_Value_GetType(nullptr, &type);
767 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
768 ret = OH_Value_GetType(value, nullptr);
769 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
770 size_t length;
771 ret = OH_Value_GetFloatVectorCount(value, &length);
772 EXPECT_EQ(ret, RDB_OK);
773 EXPECT_EQ(length, 3);
774 float retArray[10];
775 size_t outLen;
776 ret = OH_Value_GetFloatVector(value, retArray, 10, &outLen);
777 EXPECT_EQ(ret, RDB_OK);
778 EXPECT_EQ(outLen, 3);
779 EXPECT_EQ(retArray[0], 1.0);
780 ret = OH_Value_Destroy(value);
781 EXPECT_EQ(ret, RDB_OK);
782 }
783
784 /**
785 * @tc.name: RDB_Transaction_capi_test_012
786 * @tc.desc: Normal testCase of store transaction for OH_Data_Value
787 * @tc.type: FUNC
788 */
789 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_012, TestSize.Level1)
790 {
791 OH_Data_Value *value = OH_Value_Create();
792 EXPECT_NE(value, nullptr);
793 float floatArr[] = {1.0, 2.0, 3.0};
794 int ret = OH_Value_PutFloatVector(value, nullptr, 0);
795 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
796 ret = OH_Value_PutFloatVector(value, floatArr, 0);
797 EXPECT_EQ(ret, RDB_OK);
798
799 size_t length;
800 ret = OH_Value_GetFloatVectorCount(value, &length);
801 EXPECT_EQ(ret, RDB_OK);
802 EXPECT_EQ(length, 0);
803 double realValue;
804 ret = OH_Value_GetReal(value, &realValue);
805 EXPECT_EQ(ret, RDB_E_TYPE_MISMATCH);
806
807 ret = OH_Value_PutNull(value);
808 EXPECT_EQ(ret, RDB_OK);
809 ret = OH_Value_PutNull(nullptr);
810 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
811 double val = 1;
812 ret = OH_Value_PutReal(nullptr, val);
813 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
814 Data_Asset *asset = OH_Data_Asset_CreateOne();
815 ret = OH_Value_PutAsset(nullptr, asset);
816 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
817 ret = OH_Value_PutAsset(value, nullptr);
818 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
819 Data_Asset **assets = OH_Data_Asset_CreateMultiple(2);
820 ret = OH_Value_PutAssets(nullptr, assets, 0);
821 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
822 ret = OH_Value_PutAssets(value, assets, 0);
823 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
824 bool isNull;
825 ret = OH_Value_IsNull(nullptr, &isNull);
826 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
827 ret = OH_Value_IsNull(value, nullptr);
828 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
829 ret = OH_Value_GetReal(value, &realValue);
830 EXPECT_EQ(ret, RDB_E_DATA_TYPE_NULL);
831 ret = OH_Value_Destroy(value);
832 EXPECT_EQ(ret, RDB_OK);
833 }
834
835 /**
836 * @tc.name: RDB_Transaction_capi_test_013
837 * @tc.desc: Normal testCase of OH_VBucket_PutFloatVector
838 * @tc.type: FUNC
839 */
840 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_013, TestSize.Level1)
841 {
842 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
843 EXPECT_NE(valueBucket, nullptr);
844 float floatArr[] = { 1.0, 2.0, 3.0 };
845 int ret = OH_VBucket_PutFloatVector(valueBucket, "data1", floatArr, 0);
846 EXPECT_EQ(ret, RDB_OK);
847 ret = OH_VBucket_PutFloatVector(valueBucket, "data2", floatArr, 3);
848 EXPECT_EQ(ret, RDB_OK);
849 valueBucket->destroy(valueBucket);
850 }
851
852 /**
853 * @tc.name: RDB_Transaction_capi_test_014
854 * @tc.desc: Normal testCase of OH_VBucket_PutUnlimitedInt
855 * @tc.type: FUNC
856 */
857 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_014, TestSize.Level1)
858 {
859 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
860 EXPECT_NE(valueBucket, nullptr);
861 uint64_t trueForm[] = { 1, 2, 3 };
862 int ret = OH_VBucket_PutUnlimitedInt(valueBucket, "data1", 0, trueForm, 0);
863 EXPECT_EQ(ret, RDB_OK);
864 ret = OH_VBucket_PutUnlimitedInt(valueBucket, "data2", 1, trueForm, 3);
865 EXPECT_EQ(ret, RDB_OK);
866 valueBucket->destroy(valueBucket);
867 }
868
869 /**
870 * @tc.name: RDB_Transaction_capi_test_015
871 * @tc.desc: invalid args test
872 * @tc.type: FUNC
873 */
874 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_015, TestSize.Level1)
875 {
876 OH_Rdb_Transaction *trans = nullptr;
877 int ret = OH_Rdb_CreateTransaction(g_transStore, g_options, &trans);
878 EXPECT_EQ(ret, RDB_OK);
879 EXPECT_NE(trans, nullptr);
880 ret = OH_Rdb_CreateTransaction(g_transStore, g_options, nullptr);
881 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
882 ret = OH_Rdb_CreateTransaction(g_transStore, nullptr, &trans);
883 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
884 ret = OH_Rdb_CreateTransaction(nullptr, g_options, &trans);
885 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
886
887 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
888 EXPECT_NE(valueBucket, nullptr);
889 float floatArr[] = { 1.0, 2.0, 3.0 };
890 ret = OH_VBucket_PutFloatVector(nullptr, "data1", floatArr, 0);
891 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
892 ret = OH_VBucket_PutFloatVector(valueBucket, nullptr, floatArr, 0);
893 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
894 ret = OH_VBucket_PutFloatVector(valueBucket, "data1", nullptr, 0);
895 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
896
897 uint64_t trueForm[] = { 1, 2, 3 };
898 ret = OH_VBucket_PutUnlimitedInt(nullptr, "data1", 0, trueForm, 0);
899 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
900 ret = OH_VBucket_PutUnlimitedInt(valueBucket, nullptr, 0, trueForm, 0);
901 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
902 ret = OH_VBucket_PutUnlimitedInt(valueBucket, "data1", 0, nullptr, 0);
903 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
904 ret = valueBucket->destroy(valueBucket);
905 EXPECT_EQ(ret, RDB_OK);
906 ret = OH_RdbTrans_Destroy(trans);
907 EXPECT_EQ(ret, RDB_OK);
908 }
909
910 /**
911 * @tc.name: RDB_Transaction_capi_test_016
912 * @tc.desc: Normal testCase of store transaction for OH_RdbTrans_InsertWithConflictResolution
913 * @tc.type: FUNC
914 */
915 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_016, TestSize.Level1)
916 {
917 OH_Rdb_Transaction *trans = nullptr;
918 const char *table = "test";
919 int ret = OH_Rdb_CreateTransaction(g_transStore, g_options, &trans);
920 EXPECT_EQ(ret, RDB_OK);
921 EXPECT_NE(trans, nullptr);
922
923 // new row
924 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
925 valueBucket->putText(valueBucket, "data1", "liSi");
926 // init data2 value is 13800
927 valueBucket->putInt64(valueBucket, "data2", 13800);
928 // init data3 value is 200.1
929 valueBucket->putReal(valueBucket, "data3", 200.1);
930 valueBucket->putNull(valueBucket, "data5");
931
932 // create predicates
933 OH_Predicates *predicates = OH_Rdb_CreatePredicates(table);
934 // create match data
935 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
936 const char *data1Value = "zhangSan";
937 valueObject->putText(valueObject, data1Value);
938 predicates->equalTo(predicates, "data1", valueObject);
939
940 // update
941 int64_t changes = -1;
942 ret = OH_RdbTrans_InsertWithConflictResolution(trans, table, valueBucket,
943 static_cast<Rdb_ConflictResolution>(0), &changes);
944 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
945
946 ret = OH_RdbTrans_UpdateWithConflictResolution(trans, valueBucket, predicates, RDB_CONFLICT_REPLACE, &changes);
947 EXPECT_EQ(ret, RDB_OK);
948 EXPECT_EQ(changes, 1);
949
950 // destroy
951 valueObject->destroy(valueObject);
952 valueBucket->destroy(valueBucket);
953
954 ret = OH_RdbTrans_Destroy(trans);
955 EXPECT_EQ(ret, RDB_OK);
956 }
957
958
959 /**
960 * @tc.name: RDB_Transaction_capi_test_017
961 * @tc.desc: Normal testCase of store transaction for OH_RdbTrans_InsertWithConflictResolution and OH_RdbTrans_Rollback
962 * @tc.type: FUNC
963 */
964 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_017, TestSize.Level1)
965 {
966 OH_Rdb_Transaction *trans = nullptr;
967 const char *table = "test";
968 int ret = OH_Rdb_CreateTransaction(g_transStore, g_options, &trans);
969 EXPECT_EQ(ret, RDB_OK);
970 EXPECT_NE(trans, nullptr);
971
972 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
973 valueBucket->putText(valueBucket, "data1", "test_name4");
974 // init is data2 is 14800
975 valueBucket->putInt64(valueBucket, "data2", 14800);
976 // init is data2 is 300.1
977 valueBucket->putReal(valueBucket, "data3", 300.1);
978 valueBucket->putText(valueBucket, "data5", "ABCDEFGHI");
979 int64_t rowId = -1;
980 ret = OH_RdbTrans_InsertWithConflictResolution(trans, table, valueBucket,
981 static_cast<Rdb_ConflictResolution>(0), &rowId);
982 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
983
984 ret = OH_RdbTrans_InsertWithConflictResolution(trans, table, valueBucket, RDB_CONFLICT_ROLLBACK, &rowId);
985 EXPECT_EQ(ret, RDB_OK);
986 // expect value is 4
987 EXPECT_EQ(rowId, 4);
988
989 ret = OH_RdbTrans_Rollback(trans);
990 EXPECT_EQ(ret, RDB_OK);
991
992 valueBucket->destroy(valueBucket);
993 ret = OH_RdbTrans_Destroy(trans);
994 EXPECT_EQ(ret, RDB_OK);
995 }
996
997 /**
998 * @tc.name: RDB_Transaction_capi_test_018
999 * @tc.desc: Abnormal testCase of store transaction for OH_Value_PutBlob
1000 * @tc.type: FUNC
1001 */
1002 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_018, TestSize.Level1)
1003 {
1004 OH_Data_Value *value = OH_Value_Create();
1005 ASSERT_NE(value, nullptr);
1006 const unsigned char val[] = { 0x01, 0x02, 0x03 };
1007 size_t length = sizeof(val) / sizeof(val[0]);
1008 int ret = OH_Value_PutBlob(value, nullptr, length);
1009 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1010
1011 ret = OH_Value_PutBlob(nullptr, val, length);
1012 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1013
1014 ret = OH_Value_Destroy(value);
1015 EXPECT_EQ(ret, RDB_OK);
1016 }
1017
1018 /**
1019 * @tc.name: RDB_Transaction_capi_test_019
1020 * @tc.desc: Abnormal testCase of store transaction for OH_Value_PutFloatVector
1021 * @tc.type: FUNC
1022 */
1023 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_019, TestSize.Level1)
1024 {
1025 OH_Data_Value *value = OH_Value_Create();
1026 ASSERT_NE(value, nullptr);
1027 float floatArr[] = { 1.0, 2.0, 3.0 };
1028 int ret = OH_Value_PutFloatVector(nullptr, floatArr, 3);
1029 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1030 ret = OH_Value_Destroy(value);
1031 EXPECT_EQ(ret, RDB_OK);
1032 }
1033
1034 /**
1035 * @tc.name: RDB_Transaction_capi_test_020
1036 * @tc.desc: Abnormal testCase of store transaction for OH_Value_PutUnlimitedInt
1037 * @tc.type: FUNC
1038 */
1039 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_020, TestSize.Level1)
1040 {
1041 OH_Data_Value *value = OH_Value_Create();
1042 ASSERT_NE(value, nullptr);
1043 const uint64_t trueForm[] = { 0x01, 0x02, 0x03 };
1044 size_t length = sizeof(trueForm) / sizeof(trueForm[0]);
1045 int ret = OH_Value_PutUnlimitedInt(nullptr, 0, trueForm, length);
1046 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1047
1048 ret = OH_Value_PutUnlimitedInt(value, 2, trueForm, length);
1049 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1050
1051 ret = OH_Value_PutUnlimitedInt(value, 0, nullptr, length);
1052 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1053
1054 ret = OH_Value_PutUnlimitedInt(value, 0, trueForm, length);
1055 EXPECT_EQ(ret, RDB_OK);
1056
1057 ret = OH_Value_Destroy(nullptr);
1058 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1059
1060 ret = OH_Value_Destroy(value);
1061 EXPECT_EQ(ret, RDB_OK);
1062 }
1063
1064 /**
1065 * @tc.name: RDB_Transaction_capi_test_021
1066 * @tc.desc: Abnormal testCase of store transaction for OH_Data_Asset_CreateMultiple
1067 * @tc.type: FUNC
1068 */
1069 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_021, TestSize.Level1)
1070 {
1071 OH_Data_Value *value = OH_Value_Create();
1072 ASSERT_NE(value, nullptr);
1073 Data_Asset **assets = OH_Data_Asset_CreateMultiple(2);
1074 int ret = OH_Data_Asset_DestroyMultiple(assets, 2);
1075 EXPECT_EQ(ret, RDB_OK);
1076 }
1077
1078 /**
1079 * @tc.name: RDB_Transaction_capi_test_023
1080 * @tc.desc: Abnormal testCase of store transaction for OH_Values_PutAssets
1081 * @tc.type: FUNC
1082 */
1083 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_023, TestSize.Level1)
1084 {
1085 OH_Data_Values *values = OH_Values_Create();
1086 ASSERT_NE(values, nullptr);
1087 // 2 elements in assets
1088 Data_Asset **assets = OH_Data_Asset_CreateMultiple(2);
1089 ASSERT_NE(assets, nullptr);
1090 int ret = OH_Data_Asset_SetName(assets[0], "name1");
1091 EXPECT_EQ(ret, RDB_OK);
1092 ret = OH_Data_Asset_SetName(assets[1], "name2");
1093 EXPECT_EQ(ret, RDB_OK);
1094 // 2 elements in assets
1095 ret = OH_Values_PutAssets(nullptr, assets, 2);
1096 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1097 // 2 elements in assets
1098 ret = OH_Values_PutAssets(values, nullptr, 2);
1099 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1100 // 2 elements in assets
1101 ret = OH_Values_PutAssets(values, assets, 2);
1102 EXPECT_EQ(ret, RDB_OK);
1103
1104 ret = OH_Data_Asset_DestroyMultiple(assets, 2);
1105 EXPECT_EQ(ret, RDB_OK);
1106 ret = OH_Values_Destroy(values);
1107 EXPECT_EQ(ret, RDB_OK);
1108 }
1109
1110 /**
1111 * @tc.name: RDB_Transaction_capi_test_024
1112 * @tc.desc: Normal testCase of store transaction for OH_RdbTrans_InsertWithConflictResolution and OH_RdbTrans_Commit
1113 * @tc.type: FUNC
1114 */
1115 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_024, TestSize.Level1)
1116 {
1117 OH_Rdb_Transaction *trans = nullptr;
1118 const char *table = "test";
1119 int ret = OH_Rdb_CreateTransaction(g_transStore, g_options, &trans);
1120 EXPECT_EQ(ret, RDB_OK);
1121 EXPECT_NE(trans, nullptr);
1122
1123 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
1124 EXPECT_NE(valueBucket, nullptr);
1125 valueBucket->putText(valueBucket, "data1", "test_name4");
1126 // init is data2 is 14800
1127 valueBucket->putInt64(valueBucket, "data2", 14800);
1128 // init is data2 is 300.1
1129 valueBucket->putReal(valueBucket, "data3", 300.1);
1130 valueBucket->putText(valueBucket, "data5", "ABCDEFGHI");
1131 int64_t rowId = -1;
1132 ret = OH_RdbTrans_InsertWithConflictResolution(trans, table, valueBucket,
1133 static_cast<Rdb_ConflictResolution>(0), &rowId);
1134 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1135
1136 ret = OH_RdbTrans_InsertWithConflictResolution(trans, table, valueBucket, RDB_CONFLICT_ROLLBACK, &rowId);
1137 EXPECT_EQ(ret, RDB_OK);
1138 // expect value is 4
1139 EXPECT_EQ(rowId, 4);
1140
1141 ret = OH_RdbTrans_Commit(trans);
1142 EXPECT_EQ(ret, RDB_OK);
1143
1144 valueBucket->destroy(valueBucket);
1145 ret = OH_RdbTrans_Destroy(trans);
1146 EXPECT_EQ(ret, RDB_OK);
1147 }
1148
1149 /**
1150 * @tc.name: RDB_Transaction_capi_test_025
1151 * @tc.desc: test invalid options
1152 * @tc.type: FUNC
1153 */
1154 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_025, TestSize.Level1)
1155 {
1156 EXPECT_EQ(OH_RdbTransOption_SetType(nullptr, RDB_TRANS_DEFERRED), RDB_E_INVALID_ARGS);
1157 OH_RDB_TransOptions *options = OH_RdbTrans_CreateOptions();
1158 auto ret = OH_RdbTransOption_SetType(options, static_cast<OH_RDB_TransType>(RDB_TRANS_DEFERRED - 1));
1159 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1160 ret = 0;
1161 ret = OH_RdbTransOption_SetType(options, static_cast<OH_RDB_TransType>(RDB_TRANS_BUTT + 1));
1162 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1163 EXPECT_EQ(OH_RdbTrans_DestroyOptions(options), RDB_OK);
1164 EXPECT_EQ(OH_RdbTrans_DestroyOptions(nullptr), RDB_E_INVALID_ARGS);
1165 }
1166
1167 /**
1168 * @tc.name: RDB_Transaction_capi_test_026
1169 * @tc.desc: Abnormal testCase of drop the table before closing the resultSet after querying the data.
1170 * @tc.type: FUNC
1171 */
1172 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_026, TestSize.Level1)
1173 {
1174 OH_Rdb_Transaction *trans = nullptr;
1175 int ret = OH_Rdb_CreateTransaction(g_transStore, g_options, &trans);
1176 EXPECT_EQ(ret, RDB_OK);
1177 EXPECT_NE(trans, nullptr);
1178
1179 const char *querySql = "SELECT * FROM test";
1180 OH_Cursor *cursor = OH_RdbTrans_QuerySql(trans, querySql, nullptr);
1181 EXPECT_NE(cursor, nullptr);
1182
1183 ret = cursor->goToNextRow(cursor);
1184 EXPECT_EQ(ret, RDB_OK);
1185 ret = cursor->goToNextRow(cursor);
1186 EXPECT_EQ(ret, RDB_OK);
1187 ret = cursor->goToNextRow(cursor);
1188 EXPECT_EQ(ret, RDB_OK);
1189
1190 const char *sql = "DROP TABLE test";
1191 ret = OH_RdbTrans_Execute(trans, sql, nullptr, nullptr);
1192 EXPECT_EQ(ret, RDB_E_SQLITE_LOCKED);
1193
1194 cursor->destroy(cursor);
1195
1196 ret = OH_RdbTrans_Rollback(trans);
1197 EXPECT_EQ(ret, RDB_OK);
1198
1199 ret = OH_RdbTrans_Destroy(trans);
1200 EXPECT_EQ(ret, RDB_OK);
1201 }
1202
1203 /**
1204 * @tc.name: RDB_Transaction_capi_test_027
1205 * @tc.desc: Abnormal testCase of drop the table before closing the resultSet after querying the data.
1206 * @tc.type: FUNC
1207 */
1208 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_027, TestSize.Level1)
1209 {
1210 OH_Rdb_Transaction *trans = nullptr;
1211 int ret = OH_Rdb_CreateTransaction(g_transStore, g_options, &trans);
1212 EXPECT_EQ(ret, RDB_OK);
1213 EXPECT_NE(trans, nullptr);
1214
1215 const char *querySql = "SELECT * FROM test";
1216 OH_Cursor *cursor = OH_RdbTrans_QuerySql(trans, querySql, nullptr);
1217 EXPECT_NE(cursor, nullptr);
1218
1219 ret = cursor->goToNextRow(cursor);
1220 EXPECT_EQ(ret, RDB_OK);
1221 ret = cursor->goToNextRow(cursor);
1222 EXPECT_EQ(ret, RDB_OK);
1223
1224 const char *sql = "DROP TABLE test";
1225 ret = OH_RdbTrans_Execute(trans, sql, nullptr, nullptr);
1226 EXPECT_EQ(ret, RDB_E_SQLITE_LOCKED);
1227
1228 cursor->destroy(cursor);
1229
1230 ret = OH_RdbTrans_Rollback(trans);
1231 EXPECT_EQ(ret, RDB_OK);
1232
1233 ret = OH_RdbTrans_Destroy(trans);
1234 EXPECT_EQ(ret, RDB_OK);
1235 }
1236
1237 /**
1238 * @tc.name: RDB_Transaction_capi_test_028
1239 * @tc.desc: Normal testCase of drop the table after querying the data and closing the resultSet.
1240 * @tc.type: FUNC
1241 */
1242 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_028, TestSize.Level1)
1243 {
1244 OH_Rdb_Transaction *trans = nullptr;
1245
1246 char createTableSql[] = "CREATE TABLE test1 (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, data2 INTEGER, "
1247 "data3 FLOAT, data4 BLOB, data5 TEXT);";
1248 int ret = OH_Rdb_Execute(g_transStore, createTableSql);
1249 EXPECT_EQ(ret, RDB_OK);
1250
1251 ret = OH_Rdb_CreateTransaction(g_transStore, g_options, &trans);
1252 EXPECT_EQ(ret, RDB_OK);
1253 EXPECT_NE(trans, nullptr);
1254
1255 const char *querySql = "SELECT * FROM test";
1256 OH_Cursor *cursor = OH_RdbTrans_QuerySql(trans, querySql, nullptr);
1257 EXPECT_NE(cursor, nullptr);
1258
1259 ret = cursor->goToNextRow(cursor);
1260 EXPECT_EQ(ret, RDB_OK);
1261 ret = cursor->goToNextRow(cursor);
1262 EXPECT_EQ(ret, RDB_OK);
1263
1264 cursor->destroy(cursor);
1265
1266 const char *sql = "DROP TABLE test1";
1267 ret = OH_RdbTrans_Execute(trans, sql, nullptr, nullptr);
1268 EXPECT_EQ(ret, RDB_OK);
1269
1270 ret = OH_RdbTrans_Commit(trans);
1271 EXPECT_EQ(ret, RDB_OK);
1272
1273 ret = OH_RdbTrans_Destroy(trans);
1274 EXPECT_EQ(ret, RDB_OK);
1275 }
1276
1277 /**
1278 * @tc.name: RDB_Transaction_capi_test_029
1279 * @tc.desc: Abnormal testCase of drop the index before closing the resultSet after querying the data.
1280 * @tc.type: FUNC
1281 */
1282 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_029, TestSize.Level1)
1283 {
1284 OH_Rdb_Transaction *trans = nullptr;
1285
1286 char createIndexSql[] = "CREATE INDEX test_index ON test(data2);";
1287 int ret = OH_Rdb_Execute(g_transStore, createIndexSql);
1288 EXPECT_EQ(ret, RDB_OK);
1289
1290 ret = OH_Rdb_CreateTransaction(g_transStore, g_options, &trans);
1291 EXPECT_EQ(ret, RDB_OK);
1292 EXPECT_NE(trans, nullptr);
1293
1294 const char *querySql = "SELECT * FROM test";
1295 OH_Cursor *cursor = OH_RdbTrans_QuerySql(trans, querySql, nullptr);
1296 EXPECT_NE(cursor, nullptr);
1297
1298 ret = cursor->goToNextRow(cursor);
1299 EXPECT_EQ(ret, RDB_OK);
1300 ret = cursor->goToNextRow(cursor);
1301 EXPECT_EQ(ret, RDB_OK);
1302 ret = cursor->goToNextRow(cursor);
1303 EXPECT_EQ(ret, RDB_OK);
1304
1305 const char *sql = "DROP INDEX test_index";
1306 ret = OH_RdbTrans_Execute(trans, sql, nullptr, nullptr);
1307 EXPECT_EQ(ret, RDB_E_SQLITE_LOCKED);
1308
1309 cursor->destroy(cursor);
1310
1311 ret = OH_RdbTrans_Rollback(trans);
1312 EXPECT_EQ(ret, RDB_OK);
1313
1314 char dropIndexSql[] = "DROP INDEX test_index;";
1315 ret = OH_Rdb_Execute(g_transStore, dropIndexSql);
1316 EXPECT_EQ(ret, RDB_OK);
1317
1318 ret = OH_RdbTrans_Destroy(trans);
1319 EXPECT_EQ(ret, RDB_OK);
1320 }
1321
1322 /**
1323 * @tc.name: RDB_Transaction_capi_test_030
1324 * @tc.desc: Abnormal testCase of drop the index before closing the resultSet after querying the data.
1325 * @tc.type: FUNC
1326 */
1327 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_030, TestSize.Level1)
1328 {
1329 OH_Rdb_Transaction *trans = nullptr;
1330
1331 char createIndexSql[] = "CREATE INDEX test_index ON test(data2);";
1332 int ret = OH_Rdb_Execute(g_transStore, createIndexSql);
1333 EXPECT_EQ(ret, RDB_OK);
1334
1335 ret = OH_Rdb_CreateTransaction(g_transStore, g_options, &trans);
1336 EXPECT_EQ(ret, RDB_OK);
1337 EXPECT_NE(trans, nullptr);
1338
1339 const char *querySql = "SELECT * FROM test";
1340 OH_Cursor *cursor = OH_RdbTrans_QuerySql(trans, querySql, nullptr);
1341 EXPECT_NE(cursor, nullptr);
1342
1343 ret = cursor->goToNextRow(cursor);
1344 EXPECT_EQ(ret, RDB_OK);
1345 ret = cursor->goToNextRow(cursor);
1346 EXPECT_EQ(ret, RDB_OK);
1347
1348 const char *sql = "DROP INDEX test_index";
1349 ret = OH_RdbTrans_Execute(trans, sql, nullptr, nullptr);
1350 EXPECT_EQ(ret, RDB_E_SQLITE_LOCKED);
1351
1352 cursor->destroy(cursor);
1353
1354 ret = OH_RdbTrans_Rollback(trans);
1355 EXPECT_EQ(ret, RDB_OK);
1356
1357 char dropIndexSql[] = "DROP INDEX test_index;";
1358 ret = OH_Rdb_Execute(g_transStore, dropIndexSql);
1359 EXPECT_EQ(ret, RDB_OK);
1360
1361 ret = OH_RdbTrans_Destroy(trans);
1362 EXPECT_EQ(ret, RDB_OK);
1363 }
1364
1365 /**
1366 * @tc.name: RDB_Transaction_capi_test_031
1367 * @tc.desc: Abnormal testCase of drop the index after querying the data and closing the resultSet.
1368 * @tc.type: FUNC
1369 */
1370 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_031, TestSize.Level1)
1371 {
1372 OH_Rdb_Transaction *trans = nullptr;
1373
1374 char createIndexSql[] = "CREATE index test_index ON test(data2);";
1375 int ret = OH_Rdb_Execute(g_transStore, createIndexSql);
1376 EXPECT_EQ(ret, RDB_OK);
1377
1378 ret = OH_Rdb_CreateTransaction(g_transStore, g_options, &trans);
1379 EXPECT_EQ(ret, RDB_OK);
1380 EXPECT_NE(trans, nullptr);
1381
1382 const char *querySql = "SELECT * FROM test";
1383 OH_Cursor *cursor = OH_RdbTrans_QuerySql(trans, querySql, nullptr);
1384 EXPECT_NE(cursor, nullptr);
1385
1386 ret = cursor->goToNextRow(cursor);
1387 EXPECT_EQ(ret, RDB_OK);
1388 ret = cursor->goToNextRow(cursor);
1389 EXPECT_EQ(ret, RDB_OK);
1390
1391 cursor->destroy(cursor);
1392
1393 const char *sql = "DROP INDEX test_index";
1394 ret = OH_RdbTrans_Execute(trans, sql, nullptr, nullptr);
1395 EXPECT_EQ(ret, RDB_OK);
1396
1397 ret = OH_RdbTrans_Commit(trans);
1398 EXPECT_EQ(ret, RDB_OK);
1399
1400 ret = OH_RdbTrans_Destroy(trans);
1401 EXPECT_EQ(ret, RDB_OK);
1402 }
1403
1404 /**
1405 * @tc.name: RDB_Transaction_capi_test_032
1406 * @tc.desc: Normal testCase of drop the table after querying the data and closing the resultSet.
1407 * @tc.type: FUNC
1408 */
1409 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_032, TestSize.Level1)
1410 {
1411 OH_Rdb_Transaction *trans = nullptr;
1412
1413 char createTableSql[] = "CREATE TABLE test1 (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, data2 INTEGER, "
1414 "data3 FLOAT, data4 BLOB, data5 TEXT);";
1415 int ret = OH_Rdb_Execute(g_transStore, createTableSql);
1416 EXPECT_EQ(ret, RDB_OK);
1417
1418 ret = OH_Rdb_CreateTransaction(g_transStore, g_options, &trans);
1419 EXPECT_EQ(ret, RDB_OK);
1420 EXPECT_NE(trans, nullptr);
1421
1422 const char *querySql = "SELECT * FROM test1";
1423 OH_Cursor *cursor = OH_RdbTrans_QuerySql(trans, querySql, nullptr);
1424 EXPECT_NE(cursor, nullptr);
1425
1426 ret = cursor->goToNextRow(cursor);
1427 EXPECT_NE(ret, RDB_OK);
1428
1429 const char *sql = "DROP TABLE test1";
1430 ret = OH_RdbTrans_Execute(trans, sql, nullptr, nullptr);
1431 EXPECT_EQ(ret, RDB_OK);
1432
1433 cursor->destroy(cursor);
1434
1435 ret = OH_RdbTrans_Commit(trans);
1436 EXPECT_EQ(ret, RDB_OK);
1437
1438 ret = OH_RdbTrans_Destroy(trans);
1439 EXPECT_EQ(ret, RDB_OK);
1440 }
1441
1442 /**
1443 * @tc.name: RDB_Transaction_capi_test_033
1444 * @tc.desc: Normal testCase of drop the index after querying the data and closing the resultSet.
1445 * @tc.type: FUNC
1446 */
1447 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_033, TestSize.Level1)
1448 {
1449 OH_Rdb_Transaction *trans = nullptr;
1450
1451 char createIndexSql[] = "CREATE index test_index ON test(data2);";
1452 int ret = OH_Rdb_Execute(g_transStore, createIndexSql);
1453 EXPECT_EQ(ret, RDB_OK);
1454
1455 ret = OH_Rdb_CreateTransaction(g_transStore, g_options, &trans);
1456 EXPECT_EQ(ret, RDB_OK);
1457 EXPECT_NE(trans, nullptr);
1458
1459 const char *querySql = "SELECT * FROM test1";
1460 OH_Cursor *cursor = OH_RdbTrans_QuerySql(trans, querySql, nullptr);
1461 EXPECT_NE(cursor, nullptr);
1462
1463 ret = cursor->goToNextRow(cursor);
1464 EXPECT_NE(ret, RDB_OK);
1465
1466 const char *sql = "DROP INDEX test_index";
1467 ret = OH_RdbTrans_Execute(trans, sql, nullptr, nullptr);
1468 EXPECT_EQ(ret, RDB_OK);
1469
1470 cursor->destroy(cursor);
1471
1472 ret = OH_RdbTrans_Commit(trans);
1473 EXPECT_EQ(ret, RDB_OK);
1474
1475 ret = OH_RdbTrans_Destroy(trans);
1476 EXPECT_EQ(ret, RDB_OK);
1477 }
1478
1479 /**
1480 * @tc.name: RDB_Transaction_capi_test_034
1481 * @tc.desc: Abnormal testCase of drop the table after querying the data and closing the resultSet.
1482 * @tc.type: FUNC
1483 */
1484 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_034, TestSize.Level1)
1485 {
1486 OH_Rdb_Transaction *trans = nullptr;
1487
1488 char createTableSql[] = "CREATE TABLE test1 (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, data2 INTEGER, "
1489 "data3 FLOAT, data4 BLOB, data5 TEXT);";
1490 int ret = OH_Rdb_Execute(g_transStore, createTableSql);
1491 EXPECT_EQ(ret, RDB_OK);
1492
1493 ret = OH_Rdb_CreateTransaction(g_transStore, g_options, &trans);
1494 EXPECT_EQ(ret, RDB_OK);
1495 EXPECT_NE(trans, nullptr);
1496
1497 const char *querySql = "SELECT * FROM test1";
1498 OH_Cursor *cursor = OH_RdbTrans_QuerySql(trans, querySql, nullptr);
1499 EXPECT_NE(cursor, nullptr);
1500
1501 ret = cursor->goToNextRow(cursor);
1502 EXPECT_NE(ret, RDB_OK);
1503
1504 const char *sql = "DROP TABLE test";
1505 ret = OH_RdbTrans_Execute(trans, sql, nullptr, nullptr);
1506 EXPECT_EQ(ret, RDB_OK);
1507
1508 cursor->destroy(cursor);
1509
1510 ret = OH_RdbTrans_Rollback(trans);
1511 EXPECT_EQ(ret, RDB_OK);
1512
1513 ret = OH_RdbTrans_Destroy(trans);
1514 EXPECT_EQ(ret, RDB_OK);
1515 }
1516
1517 /**
1518 * @tc.name: RDB_Transaction_capi_test_035
1519 * @tc.desc: Abnormal testCase of drop the table after querying the data and closing the resultSet.
1520 * @tc.type: FUNC
1521 */
1522 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_035, TestSize.Level1)
1523 {
1524 OH_Rdb_Transaction *trans = nullptr;
1525
1526 int ret = OH_Rdb_CreateTransaction(g_transStore, g_options, &trans);
1527 EXPECT_EQ(ret, RDB_OK);
1528 EXPECT_NE(trans, nullptr);
1529
1530 const char *querySql = "SELECT * FROM test";
1531 OH_Cursor *cursor = OH_RdbTrans_QuerySql(trans, querySql, nullptr);
1532 EXPECT_NE(cursor, nullptr);
1533
1534 const char *sql = "DROP TABLE test1";
1535 ret = OH_RdbTrans_Execute(trans, sql, nullptr, nullptr);
1536 EXPECT_EQ(ret, RDB_OK);
1537
1538 cursor->destroy(cursor);
1539
1540 ret = OH_RdbTrans_Rollback(trans);
1541 EXPECT_EQ(ret, RDB_OK);
1542
1543 ret = OH_RdbTrans_Destroy(trans);
1544 EXPECT_EQ(ret, RDB_OK);
1545 }
1546
1547 /**
1548 * @tc.name: RDB_Transaction_capi_test_036
1549 * @tc.desc: Normal testCase of drop the table before closing the resultSet after querying the data.
1550 * @tc.type: FUNC
1551 */
1552 HWTEST_F(RdbTransactionCapiTest, RDB_Transaction_capi_test_036, TestSize.Level1)
1553 {
1554 OH_Rdb_Transaction *trans = nullptr;
1555 int ret = OH_Rdb_CreateTransaction(g_transStore, g_options, &trans);
1556 EXPECT_EQ(ret, RDB_OK);
1557 EXPECT_NE(trans, nullptr);
1558
1559 const char *querySql = "SELECT * FROM test";
1560 OH_Cursor *cursor = OH_RdbTrans_QuerySql(trans, querySql, nullptr);
1561 EXPECT_NE(cursor, nullptr);
1562
1563 int rowCount = 0;
1564 ret = cursor->getRowCount(cursor, &rowCount);
1565 EXPECT_EQ(ret, RDB_OK);
1566
1567 for (int i = 0; i < rowCount; i++) {
1568 ret = cursor->goToNextRow(cursor);
1569 EXPECT_EQ(ret, RDB_OK);
1570 }
1571
1572 ret = cursor->goToNextRow(cursor);
1573 EXPECT_NE(ret, RDB_OK);
1574
1575 const char *sql = "DROP TABLE test";
1576 ret = OH_RdbTrans_Execute(trans, sql, nullptr, nullptr);
1577 EXPECT_EQ(ret, RDB_OK);
1578
1579 cursor->destroy(cursor);
1580
1581 ret = OH_RdbTrans_Commit(trans);
1582 EXPECT_EQ(ret, RDB_OK);
1583
1584 ret = OH_RdbTrans_Destroy(trans);
1585 EXPECT_EQ(ret, RDB_OK);
1586 }