1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #include <climits>
19 #include <string>
20
21 #include "common.h"
22 #include "rdb_errno.h"
23 #include "rdb_helper.h"
24 #include "rdb_open_callback.h"
25
26 using namespace testing::ext;
27 using namespace OHOS::NativeRdb;
28
29 class RdbTransactionTest : public testing::Test {
30 public:
31 static void SetUpTestCase(void);
32 static void TearDownTestCase(void);
33 void SetUp();
34 void TearDown();
35
36 static const std::string DATABASE_NAME;
37 static std::shared_ptr<RdbStore> store;
38 };
39
40 const std::string RdbTransactionTest::DATABASE_NAME = RDB_TEST_PATH + "transaction_test.db";
41 std::shared_ptr<RdbStore> RdbTransactionTest::store = nullptr;
42
43 class TransactionTestOpenCallback : public RdbOpenCallback {
44 public:
45 int OnCreate(RdbStore &store) override;
46 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
47 static const std::string CREATE_TABLE_TEST;
48 };
49
50 const std::string TransactionTestOpenCallback::CREATE_TABLE_TEST = std::string("CREATE TABLE IF NOT EXISTS test ")
51 + std::string("(id INTEGER PRIMARY KEY "
52 "AUTOINCREMENT, name TEXT NOT NULL, "
53 "age INTEGER, salary REAL, blobType "
54 "BLOB)");
55
OnCreate(RdbStore & store)56 int TransactionTestOpenCallback::OnCreate(RdbStore &store)
57 {
58 return store.ExecuteSql(CREATE_TABLE_TEST);
59 }
60
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)61 int TransactionTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
62 {
63 return E_OK;
64 }
65
SetUpTestCase(void)66 void RdbTransactionTest::SetUpTestCase(void)
67 {
68 int errCode = E_OK;
69 RdbHelper::DeleteRdbStore(DATABASE_NAME);
70 RdbStoreConfig config(RdbTransactionTest::DATABASE_NAME);
71 TransactionTestOpenCallback helper;
72 RdbTransactionTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
73 EXPECT_NE(RdbTransactionTest::store, nullptr);
74 EXPECT_EQ(errCode, E_OK);
75 }
76
TearDownTestCase(void)77 void RdbTransactionTest::TearDownTestCase(void)
78 {
79 store = nullptr;
80 RdbHelper::DeleteRdbStore(RdbTransactionTest::DATABASE_NAME);
81 }
82
SetUp(void)83 void RdbTransactionTest::SetUp(void)
84 {
85 store->ExecuteSql("DELETE FROM test");
86 }
87
TearDown(void)88 void RdbTransactionTest::TearDown(void)
89 {
90 }
91
92 /**
93 * @tc.name: RdbStore_Transaction_001
94 * @tc.desc: test RdbStore BaseTransaction
95 * @tc.type: FUNC
96 */
97 HWTEST_F(RdbTransactionTest, RdbStore_Transaction_001, TestSize.Level1)
98 {
99 std::shared_ptr<RdbStore> &store = RdbTransactionTest::store;
100
101 int64_t id;
102 ValuesBucket values;
103
104 int ret = store->BeginTransaction();
105 EXPECT_EQ(ret, E_OK);
106
107 values.PutInt("id", 1);
108 values.PutString("name", std::string("zhangsan"));
109 values.PutInt("age", 18);
110 values.PutDouble("salary", 100.5);
111 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
112 ret = store->Insert(id, "test", values);
113 EXPECT_EQ(ret, E_OK);
114 EXPECT_EQ(1, id);
115
116 values.Clear();
117 values.PutInt("id", 2);
118 values.PutString("name", std::string("lisi"));
119 values.PutInt("age", 19);
120 values.PutDouble("salary", 200.5);
121 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
122 ret = store->Insert(id, "test", values);
123 EXPECT_EQ(ret, E_OK);
124 EXPECT_EQ(2, id);
125
126 values.Clear();
127 values.PutInt("id", 3);
128 values.PutString("name", std::string("wangyjing"));
129 values.PutInt("age", 20);
130 values.PutDouble("salary", 300.5);
131 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
132 ret = store->Insert(id, "test", values);
133 EXPECT_EQ(ret, E_OK);
134 EXPECT_EQ(3, id);
135
136 ret = store->Commit();
137 EXPECT_EQ(ret, E_OK);
138
139 int64_t count;
140 ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test");
141 EXPECT_EQ(ret, E_OK);
142 EXPECT_EQ(count, 3);
143
144 int deletedRows;
145 ret = store->Delete(deletedRows, "test");
146 EXPECT_EQ(ret, E_OK);
147 EXPECT_EQ(deletedRows, 3);
148 }
149
150 /**
151 * @tc.name: RdbStore_Transaction_002
152 * @tc.desc: test RdbStore BaseTransaction
153 * @tc.type: FUNC
154 */
155 HWTEST_F(RdbTransactionTest, RdbStore_Transaction_002, TestSize.Level1)
156 {
157 std::shared_ptr<RdbStore> &store = RdbTransactionTest::store;
158
159 int64_t id;
160 ValuesBucket values;
161
162 int ret = store->BeginTransaction();
163 EXPECT_EQ(ret, E_OK);
164
165 values.PutInt("id", 1);
166 values.PutString("name", std::string("zhangsan"));
167 values.PutInt("age", 18);
168 values.PutDouble("salary", 100.5);
169 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
170 ret = store->Insert(id, "test", values);
171 EXPECT_EQ(ret, E_OK);
172 EXPECT_EQ(1, id);
173
174 values.Clear();
175 values.PutInt("id", 2);
176 values.PutString("name", std::string("lisi"));
177 values.PutInt("age", 19);
178 values.PutDouble("salary", 200.5);
179 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
180 ret = store->Insert(id, "test", values);
181 EXPECT_EQ(ret, E_OK);
182 EXPECT_EQ(2, id);
183
184 values.Clear();
185 values.PutInt("id", 3);
186 values.PutString("name", std::string("wangyjing"));
187 values.PutInt("age", 20);
188 values.PutDouble("salary", 300.5);
189 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
190 ret = store->Insert(id, "test", values);
191 EXPECT_EQ(ret, E_OK);
192 EXPECT_EQ(3, id);
193
194 ret = store->Commit();
195 EXPECT_EQ(ret, E_OK);
196
197 int64_t count;
198 ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test");
199 EXPECT_EQ(ret, E_OK);
200 EXPECT_EQ(count, 3);
201
202 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
203 EXPECT_NE(resultSet, nullptr);
204 ret = resultSet->GoToNextRow();
205 EXPECT_EQ(ret, E_OK);
206 ret = resultSet->Close();
207 EXPECT_EQ(ret, E_OK);
208
209 int deletedRows;
210 ret = store->Delete(deletedRows, "test");
211 EXPECT_EQ(ret, E_OK);
212 EXPECT_EQ(deletedRows, 3);
213 }
214
215
216 /**
217 * @tc.name: RdbStore_Transaction_003
218 * @tc.desc: test RdbStore BaseTransaction
219 * @tc.type: FUNC
220 */
221 HWTEST_F(RdbTransactionTest, RdbStore_Transaction_003, TestSize.Level1)
222 {
223 std::shared_ptr<RdbStore> &store = RdbTransactionTest::store;
224
225 int64_t id;
226 ValuesBucket values;
227
228 int ret = store->BeginTransaction();
229 EXPECT_EQ(ret, E_OK);
230
231 values.PutInt("id", 1);
232 values.PutString("name", std::string("zhangsan"));
233 values.PutInt("age", 18);
234 values.PutDouble("salary", 100.5);
235 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
236 ret = store->Insert(id, "test", values);
237 EXPECT_EQ(ret, E_OK);
238 EXPECT_EQ(1, id);
239
240 values.Clear();
241 values.PutInt("id", 2);
242 values.PutString("name", std::string("lisi"));
243 values.PutInt("age", 19);
244 values.PutDouble("salary", 200.5);
245 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
246 ret = store->Insert(id, "test", values);
247 EXPECT_EQ(ret, E_OK);
248 EXPECT_EQ(2, id);
249
250 values.Clear();
251 values.PutInt("id", 3);
252 values.PutString("name", std::string("wangyjing"));
253 values.PutInt("age", 20);
254 values.PutDouble("salary", 300.5);
255 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
256 ret = store->Insert(id, "test", values);
257 EXPECT_EQ(ret, E_OK);
258 EXPECT_EQ(3, id);
259
260 ret = store->RollBack();
261 EXPECT_EQ(ret, E_OK);
262
263 int64_t count;
264 ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test");
265 EXPECT_EQ(ret, E_OK);
266 EXPECT_EQ(count, 0);
267
268 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
269 EXPECT_NE(resultSet, nullptr);
270 ret = resultSet->Close();
271 EXPECT_EQ(ret, E_OK);
272
273 int deletedRows;
274 ret = store->Delete(deletedRows, "test");
275 EXPECT_EQ(ret, E_OK);
276 EXPECT_EQ(deletedRows, 0);
277 }
278
279
280 /**
281 * @tc.name: RdbStore_NestedTransaction_001
282 * @tc.desc: test RdbStore BaseTransaction
283 * @tc.type: FUNC
284 */
285 HWTEST_F(RdbTransactionTest, RdbStore_NestedTransaction_001, TestSize.Level1)
286 {
287 std::shared_ptr<RdbStore> &store = RdbTransactionTest::store;
288
289 int64_t id;
290 ValuesBucket values;
291
292 int ret = store->BeginTransaction();
293 EXPECT_EQ(ret, E_OK);
294
295 values.PutInt("id", 1);
296 values.PutString("name", std::string("zhangsan"));
297 values.PutInt("age", 18);
298 values.PutDouble("salary", 100.5);
299 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
300 ret = store->Insert(id, "test", values);
301 EXPECT_EQ(ret, E_OK);
302 EXPECT_EQ(1, id);
303
304 ret = store->BeginTransaction();
305 EXPECT_EQ(ret, E_OK);
306 values.Clear();
307 values.PutInt("id", 2);
308 values.PutString("name", std::string("lisi"));
309 values.PutInt("age", 19);
310 values.PutDouble("salary", 200.5);
311 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
312 ret = store->Insert(id, "test", values);
313 EXPECT_EQ(ret, E_OK);
314 EXPECT_EQ(2, id);
315 ret = store->Commit(); // not commit
316 EXPECT_EQ(ret, E_OK);
317
318 values.Clear();
319 values.PutInt("id", 3);
320 values.PutString("name", std::string("wangyjing"));
321 values.PutInt("age", 20);
322 values.PutDouble("salary", 300.5);
323 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
324 ret = store->Insert(id, "test", values);
325 EXPECT_EQ(ret, E_OK);
326 EXPECT_EQ(3, id);
327
328 ret = store->Commit();
329 EXPECT_EQ(ret, E_OK);
330
331 int64_t count;
332 ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test");
333 EXPECT_EQ(ret, E_OK);
334 EXPECT_EQ(count, 3);
335
336 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
337 EXPECT_NE(resultSet, nullptr);
338 ret = resultSet->GoToNextRow();
339 EXPECT_EQ(ret, E_OK);
340 ret = resultSet->Close();
341 EXPECT_EQ(ret, E_OK);
342
343 int deletedRows;
344 ret = store->Delete(deletedRows, "test");
345 EXPECT_EQ(ret, E_OK);
346 EXPECT_EQ(deletedRows, 3);
347 }
348
349 /**
350 * @tc.name: RdbStore_NestedTransaction_002
351 * @tc.desc: test RdbStore BaseTransaction
352 * @tc.type: FUNC
353 */
354 HWTEST_F(RdbTransactionTest, RdbStore_NestedTransaction_002, TestSize.Level1)
355 {
356 std::shared_ptr<RdbStore> &store = RdbTransactionTest::store;
357
358 int64_t id;
359 ValuesBucket values;
360
361 int ret = store->BeginTransaction();
362 EXPECT_EQ(ret, E_OK);
363
364 values.PutInt("id", 1);
365 values.PutString("name", std::string("zhangsan"));
366 values.PutInt("age", 18);
367 values.PutDouble("salary", 100.5);
368 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
369 ret = store->Insert(id, "test", values);
370 EXPECT_EQ(ret, E_OK);
371 EXPECT_EQ(1, id);
372
373 ret = store->BeginTransaction();
374 EXPECT_EQ(ret, E_OK);
375 values.Clear();
376 values.PutInt("id", 2);
377 values.PutString("name", std::string("lisi"));
378 values.PutInt("age", 19);
379 values.PutDouble("salary", 200.5);
380 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
381 ret = store->Insert(id, "test", values);
382 EXPECT_EQ(ret, E_OK);
383 EXPECT_EQ(2, id);
384 ret = store->Commit();
385 EXPECT_EQ(ret, E_OK);
386 ret = store->Commit(); // commit
387 EXPECT_EQ(ret, E_OK);
388
389 values.Clear();
390 values.PutInt("id", 3);
391 values.PutString("name", std::string("wangyjing"));
392 values.PutInt("age", 20);
393 values.PutDouble("salary", 300.5);
394 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
395 ret = store->Insert(id, "test", values);
396 EXPECT_EQ(ret, E_OK);
397 EXPECT_EQ(3, id);
398
399 int64_t count;
400 ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test");
401 EXPECT_EQ(ret, E_OK);
402 EXPECT_EQ(count, 3);
403
404 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
405 EXPECT_NE(resultSet, nullptr);
406 ret = resultSet->GoToNextRow();
407 EXPECT_EQ(ret, E_OK);
408 ret = resultSet->Close();
409 EXPECT_EQ(ret, E_OK);
410
411 int deletedRows;
412 ret = store->Delete(deletedRows, "test");
413 EXPECT_EQ(ret, E_OK);
414 EXPECT_EQ(deletedRows, 3);
415 }
416
417 /**
418 * @tc.name: RdbStore_NestedTransaction_003
419 * @tc.desc: test RdbStore BaseTransaction
420 * @tc.type: FUNC
421 */
422 HWTEST_F(RdbTransactionTest, RdbStore_NestedTransaction_003, TestSize.Level1)
423 {
424 std::shared_ptr<RdbStore> &store = RdbTransactionTest::store;
425
426 int64_t id;
427 ValuesBucket values;
428
429 int ret = store->BeginTransaction();
430 EXPECT_EQ(ret, E_OK);
431
432 values.PutInt("id", 1);
433 values.PutString("name", std::string("zhangsan"));
434 values.PutInt("age", 18);
435 values.PutDouble("salary", 100.5);
436 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
437 ret = store->Insert(id, "test", values);
438 EXPECT_EQ(ret, E_OK);
439 EXPECT_EQ(1, id);
440
441 ret = store->BeginTransaction();
442 EXPECT_EQ(ret, E_OK);
443 values.Clear();
444 values.PutInt("id", 2);
445 values.PutString("name", std::string("lisi"));
446 values.PutInt("age", 19);
447 values.PutDouble("salary", 200.5);
448 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
449 ret = store->Insert(id, "test", values);
450 EXPECT_EQ(ret, E_OK);
451 EXPECT_EQ(2, id);
452 ret = store->Commit(); // not commit
453 EXPECT_EQ(ret, E_OK);
454
455 values.Clear();
456 values.PutInt("id", 3);
457 values.PutString("name", std::string("wangyjing"));
458 values.PutInt("age", 20);
459 values.PutDouble("salary", 300.5);
460 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
461 ret = store->Insert(id, "test", values);
462 EXPECT_EQ(ret, E_OK);
463 EXPECT_EQ(3, id);
464
465 ret = store->Commit(); // not commit
466 EXPECT_EQ(ret, E_OK);
467
468 int64_t count;
469 ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test");
470 EXPECT_EQ(ret, E_OK);
471 EXPECT_EQ(count, 3);
472
473 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
474 EXPECT_NE(resultSet, nullptr);
475 ret = resultSet->GoToNextRow();
476 EXPECT_EQ(ret, E_OK);
477 ret = resultSet->Close();
478 EXPECT_EQ(ret, E_OK);
479
480 int deletedRows;
481 ret = store->Delete(deletedRows, "test");
482 EXPECT_EQ(ret, E_OK);
483 EXPECT_EQ(deletedRows, 3);
484 }
485
486 /**
487 * @tc.name: RdbStore_NestedTransaction_004
488 * @tc.desc: test RdbStore BaseTransaction
489 * @tc.type: FUNC
490 */
491 HWTEST_F(RdbTransactionTest, RdbStore_NestedTransaction_004, TestSize.Level1)
492 {
493 std::shared_ptr<RdbStore> &store = RdbTransactionTest::store;
494
495 int64_t id;
496 ValuesBucket values;
497
498 int ret = store->BeginTransaction();
499 EXPECT_EQ(ret, E_OK);
500
501 values.PutInt("id", 1);
502 values.PutString("name", std::string("zhangsan"));
503 values.PutInt("age", 18);
504 values.PutDouble("salary", 100.5);
505 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
506 ret = store->Insert(id, "test", values);
507 EXPECT_EQ(ret, E_OK);
508 EXPECT_EQ(1, id);
509
510 ret = store->BeginTransaction();
511 EXPECT_EQ(ret, E_OK);
512 values.Clear();
513 values.PutInt("id", 2);
514 values.PutString("name", std::string("lisi"));
515 values.PutInt("age", 19);
516 values.PutDouble("salary", 200.5);
517 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
518 ret = store->Insert(id, "test", values);
519 EXPECT_EQ(ret, E_OK);
520 EXPECT_EQ(2, id);
521 ret = store->Commit(); // commit
522 EXPECT_EQ(ret, E_OK);
523
524 values.Clear();
525 values.PutInt("id", 3);
526 values.PutString("name", std::string("wangyjing"));
527 values.PutInt("age", 20);
528 values.PutDouble("salary", 300.5);
529 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
530 ret = store->Insert(id, "test", values);
531 EXPECT_EQ(ret, E_OK);
532 EXPECT_EQ(3, id);
533
534 ret = store->Commit(); // commit
535 EXPECT_EQ(ret, E_OK);
536
537 int64_t count;
538 ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test");
539 EXPECT_EQ(ret, E_OK);
540 EXPECT_EQ(count, 3);
541
542 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
543 EXPECT_NE(resultSet, nullptr);
544 ret = resultSet->GoToNextRow();
545 EXPECT_EQ(ret, E_OK);
546 ret = resultSet->GoToNextRow();
547 EXPECT_EQ(ret, E_OK);
548 ret = resultSet->GoToNextRow();
549 EXPECT_EQ(ret, E_OK);
550 ret = resultSet->GoToNextRow();
551 EXPECT_EQ(ret, E_ERROR);
552 ret = resultSet->Close();
553 EXPECT_EQ(ret, E_OK);
554
555 int deletedRows;
556 ret = store->Delete(deletedRows, "test");
557 EXPECT_EQ(ret, E_OK);
558 EXPECT_EQ(deletedRows, 3);
559 }
560
561 /**
562 * @tc.name: RdbStore_BatchInsert_001
563 * @tc.desc: test RdbStore BatchInsert
564 * @tc.type: FUNC
565 * @tc.require: issueI5GZGX
566 */
567 HWTEST_F(RdbTransactionTest, RdbStore_BatchInsert_001, TestSize.Level1)
568 {
569 std::shared_ptr<RdbStore> &store = RdbTransactionTest::store;
570
571 ValuesBucket values;
572
573 values.PutString("name", "zhangsan");
574 values.PutInt("age", 18);
575 values.PutDouble("salary", 100.5);
576 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
577
578 std::vector<ValuesBucket> valuesBuckets;
579 for (int i = 0; i < 100; i++) {
580 valuesBuckets.push_back(values);
581 }
582 int64_t insertNum = 0;
583 int ret = store->BatchInsert(insertNum, "test", valuesBuckets);
584 EXPECT_EQ(E_OK, ret);
585 EXPECT_EQ(100, insertNum);
586 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
587 int rowCount = 0;
588 resultSet->GetRowCount(rowCount);
589 EXPECT_EQ(100, rowCount);
590 }
591
592
593 /**
594 * @tc.name: RdbStore_BatchInsert_002
595 * @tc.desc: test RdbStore BatchInsert
596 * @tc.type: FUNC
597 * @tc.require: issue-I6BAX0
598 */
599 HWTEST_F(RdbTransactionTest, RdbStore_BatchInsert_002, TestSize.Level1)
600 {
601 std::shared_ptr<RdbStore> &store = RdbTransactionTest::store;
602 store->ExecuteSql("delete from test");
603 std::string name = "zhangsan";
604 int age = 18;
605 double salary = 100.5;
606 std::vector<uint8_t> blob = { 1, 2, 3 };
607 std::vector<ValuesBucket> valuesBuckets;
608 for (int i = 0; i < 100; i++) {
609 ValuesBucket values;
610 values.PutString("name", name);
611 values.PutInt("age", age + i);
612 values.PutDouble("salary", salary + i);
613 values.PutBlob("blobType", blob);
614 valuesBuckets.push_back(std::move(values));
615 }
616
617 int64_t number = 0;
618 int error = store->BatchInsert(number, "test", valuesBuckets);
619 EXPECT_EQ(E_OK, error);
620 EXPECT_EQ(100, number);
621 int rowCount = 0;
622 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
623 resultSet->GetRowCount(rowCount);
624 EXPECT_EQ(100, rowCount);
625 }
626
627
628 /**
629 * @tc.name: RdbStore_BatchInsert_003
630 * @tc.desc: test RdbStore BatchInsert
631 * @tc.type: FUNC
632 * @tc.require: issue-I6BAX0
633 */
634 HWTEST_F(RdbTransactionTest, RdbStore_BatchInsert_003, TestSize.Level1)
635 {
636 std::shared_ptr<RdbStore> &store = RdbTransactionTest::store;
637 store->ExecuteSql("delete from test");
638
639 int id = 0;
640 std::string name = "zhangsan";
641 int age = 18;
642 double salary = 100.5;
643 std::vector<uint8_t> blob = { 1, 2, 3 };
644 std::vector<ValuesBucket> valuesBuckets;
645 for (int i = 0; i < 100; i++) {
646 ValuesBucket values;
647 values.PutInt("id", id + i);
648 values.PutString("name", name);
649 values.PutInt("age", age + i);
650 values.PutDouble("salary", salary + i);
651 values.PutBlob("blobType", blob);
652 valuesBuckets.push_back(std::move(values));
653 }
654
655 int64_t number = 0;
656 int error = store->BatchInsert(number, "test", valuesBuckets);
657 EXPECT_EQ(E_OK, error);
658 EXPECT_EQ(100, number);
659
660 int rowCount = 0;
661 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
662 resultSet->GetRowCount(rowCount);
663 EXPECT_EQ(100, rowCount);
664
665 valuesBuckets.clear();
666 for (int i = 50; i < 100; i++) {
667 ValuesBucket values;
668 values.PutInt("id", id + i);
669 values.PutString("name", name);
670 values.PutInt("age", age + i);
671 values.PutDouble("salary", salary + i);
672 values.PutBlob("blobType", blob);
673 valuesBuckets.push_back(std::move(values));
674 }
675
676 number = INT_MIN;
677 error = store->BatchInsert(number, "test", valuesBuckets);
678 EXPECT_EQ(E_OK, error);
679 EXPECT_EQ(-1, number);
680
681 resultSet = store->QuerySql("SELECT * FROM test");
682 resultSet->GetRowCount(rowCount);
683 EXPECT_EQ(100, rowCount);
684 number = 0l;
685 while (true) {
686 error = resultSet->GoToNextRow();
687 if (error != E_OK) {
688 break;
689 }
690 number++;
691 }
692 resultSet->Close();
693 EXPECT_EQ(100, number);
694 }
695
696 /**
697 * @tc.name: RdbStore_BatchInsert_004
698 * @tc.desc: Abnormal testCase of transaction for batchInsert, if batchInsert in transaction
699 * @tc.type: FUNC
700 */
701 HWTEST_F(RdbTransactionTest, RdbStore_BatchInsert_004, TestSize.Level1)
702 {
703 std::shared_ptr<RdbStore> &store = RdbTransactionTest::store;
704 store->ExecuteSql("delete from test");
705
706 int id = 0;
707 ValuesBucket values;
708 std::vector<ValuesBucket> valuesBuckets;
709
710 for (int i = 0; i < 10; i++) {
711 values.Clear();
712 values.PutInt("id", id + i);
713 values.PutString("name", "zhangsan");
714 valuesBuckets.push_back(values);
715 }
716
717 int error = store->BeginTransaction();
718 EXPECT_EQ(E_OK, error);
719
720 int64_t number = 0;
721 error = store->BatchInsert(number, "test", valuesBuckets);
722 EXPECT_EQ(E_TRANSACTION_IN_EXECUTE, error);
723 EXPECT_EQ(0, number);
724
725 error = store->Commit();
726 EXPECT_EQ(E_OK, error);
727 }